\section{Script\-Interp  Class Reference}
\label{class_scriptinterp}\index{ScriptInterp@{Script\-Interp}}
System script interpreter core engine class. Extensible Bayonne Scripting Engine. 


{\tt \#include $<$script.h$>$}

Inheritance diagram for Script\-Interp:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=3cm]{class_scriptinterp}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf scriptsymbol\_\-t}$\ast$ {\bf get\-Local} (const char $\ast$name, size\_\-t size=0)
\begin{CompactList}\small\item\em Search for symbols either thru the virtual global space or thru local space if a local space has been allocated on the heap.\item\end{CompactList}\item 
bool {\bf Attach} (const char $\ast$scrname)
\begin{CompactList}\small\item\em Attempt to attach script engine to active session and specify a starting script.\item\end{CompactList}\item 
void {\bf Detach} (void)
\begin{CompactList}\small\item\em Detach the current script image.\item\end{CompactList}\item 
bool {\bf Redirect} (const char $\ast$scrname)
\begin{CompactList}\small\item\em Script redirection support.\item\end{CompactList}\item 
bool {\bf Step} (const char $\ast$trapname=NULL)
\begin{CompactList}\small\item\em Execute the next pending script statement.\item\end{CompactList}\item 
bool {\bf is\-Active} (void)
\begin{CompactList}\small\item\em Test if script interpreter is currently active.\item\end{CompactList}\item 
char$\ast$ {\bf get\-Option} (const char $\ast$def=NULL)
\begin{CompactList}\small\item\em Fetch next logical option but do not evaluate.\item\end{CompactList}\item 
char$\ast$ {\bf get\-Keyword} (const char $\ast$keyword)
\begin{CompactList}\small\item\em Fetch an embedded attribute keyword argument.\item\end{CompactList}\item 
int {\bf init\-Keywords} (int size)
\begin{CompactList}\small\item\em Initialize symbols from the keyword list.\item\end{CompactList}\item 
char$\ast$ {\bf get\-Value} (const char $\ast$def=NULL)
\begin{CompactList}\small\item\em Fetch and evaluate next logical option.\item\end{CompactList}\item 
char$\ast$ {\bf get\-Content} (char $\ast$sym)
\begin{CompactList}\small\item\em Evaluate the content of an option retrieved with get\-Option.\item\end{CompactList}\item 
{\bf scriptline\_\-t}$\ast$ {\bf get\-Script} (void)
\begin{CompactList}\small\item\em Return the current script line object so it may be debugged.\item\end{CompactList}\item 
const char$\ast$ {\bf get\-Member} (void)
\begin{CompactList}\small\item\em Return the member id of a script command.\item\end{CompactList}\item 
{\bf scriptname\_\-t}$\ast$ {\bf get\-Object} (void)
\begin{CompactList}\small\item\em Return the master script object for resource context.\item\end{CompactList}\item 
{\bf Script\-Image}$\ast$ {\bf get\-Image} (void)
\begin{CompactList}\small\item\em Return the script image holding this application's context.\item\end{CompactList}\item 
void {\bf autoloop} (bool enable)
\begin{CompactList}\small\item\em Enable or disable autolooping of statements.\item\end{CompactList}\end{CompactItemize}
\subsection*{Protected Methods}
\begin{CompactItemize}
\item 
{\bf Script\-Interp} ({\bf Script\-Command} $\ast$cmd, size\_\-t symsize, size\_\-t pgsize=1024)
\begin{CompactList}\small\item\em Derive a new instance of the system script interpreter.\item\end{CompactList}\item 
void {\bf get\-Trigger} (bool use)
\begin{CompactList}\small\item\em Get a local and/or global trigger.\item\end{CompactList}\item 
bool {\bf get\-Once} (void)
\begin{CompactList}\small\item\em Fetch unique "once" flag and set.\item\end{CompactList}\item 
void {\bf Notify} (unsigned long mask)
\begin{CompactList}\small\item\em Notify signal mask for "on" handlers.\item\end{CompactList}\item 
void {\bf Notify} (const char $\ast$str)
\begin{CompactList}\small\item\em Notify signal by symbolic name.\item\end{CompactList}\item 
unsigned long {\bf get\-Mask} (void)
\begin{CompactList}\small\item\em Fetch the current interpreter mask bits directly.\item\end{CompactList}\item 
{\bf Script\-Command}$\ast$ {\bf get\-Command} (void)
\begin{CompactList}\small\item\em Fetch the active command interpreter subsystem.\item\end{CompactList}\item 
bool {\bf Conditional} (void)
\begin{CompactList}\small\item\em Used to process "conditional" arguments such as for IF/DO/LOOP statements.\item\end{CompactList}\item 
bool {\bf scr\-Exit} (void)
\begin{CompactList}\small\item\em Some systems can derive alternative "exit" commands which can call this routine after performing other operations.\item\end{CompactList}\item 
bool {\bf scr\-Goto} (void)
\begin{CompactList}\small\item\em This is often called to process branching requests.\item\end{CompactList}\item 
bool {\bf scr\-Data} (void)
\begin{CompactList}\small\item\em Method used to encode "data" lines.\item\end{CompactList}\item 
virtual unsigned {\bf get\-Id} (void)
\begin{CompactList}\small\item\em Used to return channel identifiers in some systems.\item\end{CompactList}\item 
virtual bool {\bf get\-Global\-Trap} (unsigned id)
\begin{CompactList}\small\item\em Used to fetch a global trap execution context branch.\item\end{CompactList}\item 
{\bf scriptsymbol\_\-t}$\ast$ {\bf get\-Variable} (size\_\-t size=0)
\begin{CompactList}\small\item\em Fetch a variable (symbol) that will be used to store data.\item\end{CompactList}\item 
virtual {\bf scriptsymbol\_\-t}$\ast$ {\bf get\-Indirect} (char $\ast$sym)
\begin{CompactList}\small\item\em May be used to override processing of indirect content requests.\item\end{CompactList}\item 
void {\bf Advance} (void)
\begin{CompactList}\small\item\em Advance program to the next script statement.\item\end{CompactList}\item 
void {\bf Error} (const char $\ast$error)
\begin{CompactList}\small\item\em Set error variable and advance to either the error handler or next script statement.\item\end{CompactList}\item 
void {\bf Trap} (unsigned id)
\begin{CompactList}\small\item\em Set the execution interpreter to a trap identifier.\item\end{CompactList}\item 
void {\bf Trap} (const char $\ast$trapname)
\begin{CompactList}\small\item\em Select trap by symbolic name and execute if found, else advance to next script step (unless exit trap).\item\end{CompactList}\item 
bool {\bf Push} (void)
\begin{CompactList}\small\item\em Attempt to push a value onto the stack.\item\end{CompactList}\item 
bool {\bf Pull} (void)
\begin{CompactList}\small\item\em Attempt to recall a previous stack level.\item\end{CompactList}\item 
bool {\bf Signal} (const char $\ast$trapname)
\begin{CompactList}\small\item\em Signals are used during "delayed" execution steps when a signal event has occured aynchronously with the execution of a script controlled state event handler.\item\end{CompactList}\item 
bool {\bf Signal} (unsigned trapid)
\begin{CompactList}\small\item\em Signals can be referenced by numeric id as well as by symbolic name.\item\end{CompactList}\item 
virtual bool {\bf Execute} ({\bf scriptmethod\_\-t} method)
\begin{CompactList}\small\item\em Runtime execution of script handler.\item\end{CompactList}\item 
virtual void {\bf Stop} (unsigned long mask)
\begin{CompactList}\small\item\em Stop request handler.\item\end{CompactList}\item 
virtual void {\bf Exit} (void)=0
\begin{CompactList}\small\item\em Exit request handler.\item\end{CompactList}\item 
virtual {\bf scriptname\_\-t}$\ast$ {\bf get\-Script\-Image} (const char $\ast$label)
\begin{CompactList}\small\item\em Runtime branch point for label selection.\item\end{CompactList}\item 
{\bf scriptname\_\-t}$\ast$ {\bf get\-Script\-Copy} (const char $\ast$src)
\begin{CompactList}\small\item\em Fetch duplicative script image as needed.\item\end{CompactList}\item 
virtual void {\bf sleep\-Scheduler} (timeout\_\-t timeout)
\begin{CompactList}\small\item\em Patch point for sleep delay notification.\item\end{CompactList}\item 
virtual void {\bf step\-Scheduler} (const char $\ast$trapname)
\begin{CompactList}\small\item\em Step scheduler callback to force step execution.\item\end{CompactList}\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf Script\-Image}
\item 
class {\bf Script\-Session}
\item 
class {\bf Script\-Module}
\item 
class {\bf Script\-Command}
\end{CompactItemize}


\subsection{Detailed Description}
System script interpreter core engine class. Extensible Bayonne Scripting Engine.

This class is further derived to impliment application specific language dialects.

\begin{Desc}
\item[{\bf Author(s): }]\par
 David Sugar $<${\tt dyfet@ostel.com}$>$ \end{Desc}




\subsection{Constructor \& Destructor Documentation}
\index{ScriptInterp@{Script\-Interp}!ScriptInterp@{ScriptInterp}}
\index{ScriptInterp@{ScriptInterp}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Script\-Interp::Script\-Interp ({\bf Script\-Command} $\ast$ {\em cmd}, size\_\-t {\em symsize}, size\_\-t {\em pgsize} = 1024)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b0}


Derive a new instance of the system script interpreter.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em symsize}] for default symbol sizing. \item[
{\em pgsize}] for memory fragmentation. \end{description}
\end{Desc}


\subsection{Member Function Documentation}
\index{ScriptInterp@{Script\-Interp}!Advance@{Advance}}
\index{Advance@{Advance}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Advance (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b15}


Advance program to the next script statement.

\index{ScriptInterp@{Script\-Interp}!Attach@{Attach}}
\index{Attach@{Attach}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Attach (const char $\ast$ {\em scrname})}\label{class_scriptinterp_a1}


Attempt to attach script engine to active session and specify a starting script.

\begin{Desc}
\item[{\bf Returns: }]\par
 false if failed to attach. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em name}] of script entry. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Conditional@{Conditional}}
\index{Conditional@{Conditional}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Conditional (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b7}


Used to process "conditional" arguments such as for IF/DO/LOOP statements.

The index is kept at the next logical argument so a goto can be performed if needed.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if conditional test is true. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!Detach@{Detach}}
\index{Detach@{Detach}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Detach (void)}\label{class_scriptinterp_a2}


Detach the current script image.

If it is the last ref count and the exit flag is set, then delete it. \index{ScriptInterp@{Script\-Interp}!Error@{Error}}
\index{Error@{Error}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Error (const char $\ast$ {\em error})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b16}


Set error variable and advance to either the error handler or next script statement.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em error}] message. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Execute@{Execute}}
\index{Execute@{Execute}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Execute ({\bf scriptmethod\_\-t} {\em method})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b23}


Runtime execution of script handler.

This can be called in the current or derived class to invoke extensible methods.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if immediately ready for next step. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em derived}] method to call. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Exit@{Exit}}
\index{Exit@{Exit}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Exit (void)\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{class_scriptinterp_b25}


Exit request handler.

This is called when no script line exists. No default behavior is known. \index{ScriptInterp@{Script\-Interp}!Notify@{Notify}}
\index{Notify@{Notify}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Notify (const char $\ast$ {\em str})\hspace{0.3cm}{\tt  [inline, protected]}}\label{class_scriptinterp_b4}


Notify signal by symbolic name.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em mask}] name. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Notify@{Notify}}
\index{Notify@{Notify}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Notify (unsigned long {\em mask})\hspace{0.3cm}{\tt  [inline, protected]}}\label{class_scriptinterp_b3}


Notify signal mask for "on" handlers.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em mask}] value. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Pull@{Pull}}
\index{Pull@{Pull}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Pull (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b20}


Attempt to recall a previous stack level.

\begin{Desc}
\item[{\bf Returns: }]\par
 false if stack underflow. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!Push@{Push}}
\index{Push@{Push}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Push (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b19}


Attempt to push a value onto the stack.

\begin{Desc}
\item[{\bf Returns: }]\par
 false if stack overflow. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!Redirect@{Redirect}}
\index{Redirect@{Redirect}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Redirect (const char $\ast$ {\em scrname})}\label{class_scriptinterp_a3}


Script redirection support.

\begin{Desc}
\item[{\bf Returns: }]\par
 false if redirect failed. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em name}] of script entry. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Signal@{Signal}}
\index{Signal@{Signal}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Signal (unsigned {\em trapid})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b22}


Signals can be referenced by numeric id as well as by symbolic name.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if signal handler is not blocked. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em trap}] number of handler. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Signal@{Signal}}
\index{Signal@{Signal}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Signal (const char $\ast$ {\em trapname})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b21}


Signals are used during "delayed" execution steps when a signal event has occured aynchronously with the execution of a script controlled state event handler.

This mechanism can be used in place of calling implicit "Step" traps.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if signal handler is not blocked. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em name}] of signal identifier. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Step@{Step}}
\index{Step@{Step}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::Step (const char $\ast$ {\em trapname} = NULL)}\label{class_scriptinterp_a4}


Execute the next pending script statement.

If no statement is selected, then we execute the exit handler instead. We can also force feed a trap identifier.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if advanced to next script statement already. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em optional}] trap branch point (also checks mask). \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Stop@{Stop}}
\index{Stop@{Stop}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Stop (unsigned long {\em mask})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b24}


Stop request handler.

Used for handling external trap requests during a "Signal". This is needed in some state engines when the current state is being abandoned because of a signaled trap.\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em signal}] mask forcing stop. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Trap@{Trap}}
\index{Trap@{Trap}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Trap (const char $\ast$ {\em trapname})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b18}


Select trap by symbolic name and execute if found, else advance to next script step (unless exit trap).

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em name}] of trap to select. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!Trap@{Trap}}
\index{Trap@{Trap}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::Trap (unsigned {\em id})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b17}


Set the execution interpreter to a trap identifier.

If no trap id exists, then advance to next script statement (unless exit trap).\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em id}] of trap to select numerically. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!autoloop@{autoloop}}
\index{autoloop@{autoloop}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::autoloop (bool {\em enable})\hspace{0.3cm}{\tt  [inline]}}\label{class_scriptinterp_a15}


Enable or disable autolooping of statements.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em true}] to enable autoloop (default). \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getCommand@{getCommand}}
\index{getCommand@{getCommand}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Script\-Command} $\ast$ Script\-Interp::get\-Command (void)\hspace{0.3cm}{\tt  [inline, protected]}}\label{class_scriptinterp_b6}


Fetch the active command interpreter subsystem.

\begin{Desc}
\item[{\bf Returns: }]\par
 script interpreter. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getContent@{getContent}}
\index{getContent@{getContent}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Script\-Interp::get\-Content (char $\ast$ {\em sym})}\label{class_scriptinterp_a10}


Evaluate the content of an option retrieved with get\-Option.

\begin{Desc}
\item[{\bf Returns: }]\par
 value of evaluation. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em option}] string. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getGlobalTrap@{getGlobalTrap}}
\index{getGlobalTrap@{getGlobalTrap}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::get\-Global\-Trap (unsigned {\em id})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b12}


Used to fetch a global trap execution context branch.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if external global trap handler found. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em trap}] identifier. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getId@{getId}}
\index{getId@{getId}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned Script\-Interp::get\-Id (void)\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b11}


Used to return channel identifiers in some systems.

\begin{Desc}
\item[{\bf Returns: }]\par
 channel id or 0 for none. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getImage@{getImage}}
\index{getImage@{getImage}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Script\-Image} $\ast$ Script\-Interp::get\-Image (void)\hspace{0.3cm}{\tt  [inline]}}\label{class_scriptinterp_a14}


Return the script image holding this application's context.

\begin{Desc}
\item[{\bf Returns: }]\par
 script image. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getIndirect@{getIndirect}}
\index{getIndirect@{getIndirect}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptsymbol\_\-t} $\ast$ Script\-Interp::get\-Indirect (char $\ast$ {\em sym})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b14}


May be used to override processing of indirect content requests.

This is used in the Bayonne IVR to fetch content constants based on language and country settings.

\begin{Desc}
\item[{\bf Returns: }]\par
 symbol for indirect content. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em indirect}] fetch request. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getKeyword@{getKeyword}}
\index{getKeyword@{getKeyword}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Script\-Interp::get\-Keyword (const char $\ast$ {\em keyword})}\label{class_scriptinterp_a7}


Fetch an embedded attribute keyword argument.

This allows embedded tag=value keywords to be extracted.

\begin{Desc}
\item[{\bf Returns: }]\par
 option or NULL if not found. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em keyword}] to find. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getLocal@{getLocal}}
\index{getLocal@{getLocal}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptsymbol\_\-t} $\ast$ Script\-Interp::get\-Local (const char $\ast$ {\em name}, size\_\-t {\em size} = 0)}\label{class_scriptinterp_a0}


Search for symbols either thru the virtual global space or thru local space if a local space has been allocated on the heap.

\begin{Desc}
\item[{\bf Returns: }]\par
 symbol found. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em script}] symbol to look for or create. \item[
{\em size}] of symbol to allocate. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getMask@{getMask}}
\index{getMask@{getMask}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned long Script\-Interp::get\-Mask (void)\hspace{0.3cm}{\tt  [inline, protected]}}\label{class_scriptinterp_b5}


Fetch the current interpreter mask bits directly.

\begin{Desc}
\item[{\bf Returns: }]\par
 interpreter mask. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getMember@{getMember}}
\index{getMember@{getMember}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const char $\ast$ Script\-Interp::get\-Member (void)}\label{class_scriptinterp_a12}


Return the member id of a script command.

\begin{Desc}
\item[{\bf Returns: }]\par
 member id or NULL if none. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getObject@{getObject}}
\index{getObject@{getObject}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptname\_\-t} $\ast$ Script\-Interp::get\-Object (void)\hspace{0.3cm}{\tt  [inline]}}\label{class_scriptinterp_a13}


Return the master script object for resource context.

\begin{Desc}
\item[{\bf Returns: }]\par
 script object being executed. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getOnce@{getOnce}}
\index{getOnce@{getOnce}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::get\-Once (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b2}


Fetch unique "once" flag and set.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if once. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getOption@{getOption}}
\index{getOption@{getOption}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Script\-Interp::get\-Option (const char $\ast$ {\em def} = NULL)}\label{class_scriptinterp_a6}


Fetch next logical option but do not evaluate.

The index is advanced.

\begin{Desc}
\item[{\bf Returns: }]\par
 option or NULL if end of list. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em optional}] default. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getScript@{getScript}}
\index{getScript@{getScript}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptline\_\-t} $\ast$ Script\-Interp::get\-Script (void)\hspace{0.3cm}{\tt  [inline]}}\label{class_scriptinterp_a11}


Return the current script line object so it may be debugged.

\begin{Desc}
\item[{\bf Returns: }]\par
 script image record being executed. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!getScriptCopy@{getScriptCopy}}
\index{getScriptCopy@{getScriptCopy}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptname\_\-t} $\ast$ Script\-Interp::get\-Script\-Copy (const char $\ast$ {\em src})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b27}


Fetch duplicative script image as needed.

\begin{Desc}
\item[{\bf Returns: }]\par
 script object. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em label}] to dup. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getScriptImage@{getScriptImage}}
\index{getScriptImage@{getScriptImage}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptname\_\-t} $\ast$ Script\-Interp::get\-Script\-Image (const char $\ast$ {\em label})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{class_scriptinterp_b26}


Runtime branch point for label selection.

\begin{Desc}
\item[{\bf Returns: }]\par
 script found. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em label}] to locate. \item[
{\em script}] line associated. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getTrigger@{getTrigger}}
\index{getTrigger@{getTrigger}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::get\-Trigger (bool {\em use})\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b1}


Get a local and/or global trigger.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em use}] or clear. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getValue@{getValue}}
\index{getValue@{getValue}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Script\-Interp::get\-Value (const char $\ast$ {\em def} = NULL)}\label{class_scriptinterp_a9}


Fetch and evaluate next logical option.

If a symbol ref. then the symbol is also expressed. The index is advanced.

\begin{Desc}
\item[{\bf Returns: }]\par
 option value or NULL if end of list. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em optional}] default value. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!getVariable@{getVariable}}
\index{getVariable@{getVariable}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf scriptsymbol\_\-t} $\ast$ Script\-Interp::get\-Variable (size\_\-t {\em size} = 0)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b13}


Fetch a variable (symbol) that will be used to store data.

This advances the index.

\begin{Desc}
\item[{\bf Returns: }]\par
 symbol found if any. \end{Desc}
\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em optional}] size to allocate if new symbol. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!initKeywords@{initKeywords}}
\index{initKeywords@{initKeywords}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Script\-Interp::init\-Keywords (int {\em size})}\label{class_scriptinterp_a8}


Initialize symbols from the keyword list.

\index{ScriptInterp@{Script\-Interp}!isActive@{isActive}}
\index{isActive@{isActive}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::is\-Active (void)\hspace{0.3cm}{\tt  [inline]}}\label{class_scriptinterp_a5}


Test if script interpreter is currently active.

\begin{Desc}
\item[{\bf Returns: }]\par
 true if active. \end{Desc}
\index{ScriptInterp@{Script\-Interp}!scrData@{scrData}}
\index{scrData@{scrData}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::scr\-Data (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b10}


Method used to encode "data" lines.

\index{ScriptInterp@{Script\-Interp}!scrExit@{scrExit}}
\index{scrExit@{scrExit}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::scr\-Exit (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b8}


Some systems can derive alternative "exit" commands which can call this routine after performing other operations.

\index{ScriptInterp@{Script\-Interp}!scrGoto@{scrGoto}}
\index{scrGoto@{scrGoto}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Script\-Interp::scr\-Goto (void)\hspace{0.3cm}{\tt  [protected]}}\label{class_scriptinterp_b9}


This is often called to process branching requests.

\index{ScriptInterp@{Script\-Interp}!sleepScheduler@{sleepScheduler}}
\index{sleepScheduler@{sleepScheduler}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::sleep\-Scheduler (timeout\_\-t {\em timeout})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b28}


Patch point for sleep delay notification.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em sleep}] timeout expected. \end{description}
\end{Desc}
\index{ScriptInterp@{Script\-Interp}!stepScheduler@{stepScheduler}}
\index{stepScheduler@{stepScheduler}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Script\-Interp::step\-Scheduler (const char $\ast$ {\em trapname})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{class_scriptinterp_b29}


Step scheduler callback to force step execution.

\begin{Desc}
\item[{\bf Parameters: }]\par
\begin{description}
\item[
{\em trap}] name to use. \end{description}
\end{Desc}


\subsection{Friends And Related Function Documentation}
\index{ScriptInterp@{Script\-Interp}!ScriptCommand@{ScriptCommand}}
\index{ScriptCommand@{ScriptCommand}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class Script\-Command\hspace{0.3cm}{\tt  [friend]}}\label{class_scriptinterp_l3}


\index{ScriptInterp@{Script\-Interp}!ScriptImage@{ScriptImage}}
\index{ScriptImage@{ScriptImage}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class Script\-Image\hspace{0.3cm}{\tt  [friend]}}\label{class_scriptinterp_l0}


\index{ScriptInterp@{Script\-Interp}!ScriptModule@{ScriptModule}}
\index{ScriptModule@{ScriptModule}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class Script\-Module\hspace{0.3cm}{\tt  [friend]}}\label{class_scriptinterp_l2}


\index{ScriptInterp@{Script\-Interp}!ScriptSession@{ScriptSession}}
\index{ScriptSession@{ScriptSession}!ScriptInterp@{Script\-Interp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class Script\-Session\hspace{0.3cm}{\tt  [friend]}}\label{class_scriptinterp_l1}




The documentation for this class was generated from the following file:\begin{CompactItemize}
\item 
{\bf script.h}\end{CompactItemize}