Update of /cvsroot/nsclspectcl/SpecTcl/TCL In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13419/TCL Modified Files: Makefile.am TCLInterpreter.cpp Added Files: CTCLApplication.xml CTCLChannel.xml CTCLCommandPackage.xml CTCLCompatibilityProcessor.xml CTCLException.xml CTCLFileHandler.xml CTCLHashTable.xml CTCLHashTableItem.xml CTCLHashTableIterator.xml CTCLIdleProcess.xml CTCLInterpreter.xml CTCLInterpreterObject.xml CTCLList.xml CTCLObject.xml CTCLObjectProcessor.xml CTCLPackagedCommand.xml CTCLProcessor.xml CTCLResult.xml CTCLString.xml CTCLTimer.xml CTCLVariable.xml ClanguageTraceCallbacks.xml TclPlus.xml Log Message: Addeed documentation in docbook->Manpage format for the libtclPlus (CTCL) class library. This installs to SpecTclHome/man/man3. Starting point is TclPlus --- NEW FILE: CTCLHashTable.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLHashTable</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLHashTable</refname> <refpurpose> Object oriented interface to Tcl's hash table functions. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLHashTable.h> template <class T> class CTCLHashTable { public: CTCLHashTable () ; CTCLHashTable ( Tcl_HashTable am_HashTable ); CTCLHashTable (const CTCLHashTable& aCTCLHashTable ); virtual ~CTCLHashTable ( ); CTCLHashTable operator= (const CTCLHashTable& aCTCLHashTable); int operator== (const CTCLHashTable& aCTCLHashTable); Tcl_HashTable* getHashTable() const; void Enter (const std::string& rKey, rCTCLTHashTableItem rValue); const CTCLTHashTableItem* Find (const std::string& rsKeyword) const; CTCLTHashTableItem* Delete (const std::string& rsKeyword); CTCLTHashTableIterator begin (); CTCLTHashTableIterator end (); std::string Statistics (); }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> Hash tables are tables of keyword value pairs that are organized such that the lookup time for any key in the table is <firstterm>amortized constant</firstterm>. Hash tables operate by running the key through a function called the <firstterm>hash function</firstterm>, and storing the key/value pair as an element of an array indexed by the result of that hash function (<firstterm>hash index</firstterm>). Depending on the implementation of the hash table, different methods are used to resolve cases where two keys result in the same hash index. </para> <para> Tcl includes support libraries for hash tables with string keys and arbitrary value types (e.g. structures, pointers etc. etc.). One example of the use of this sort of data structure is Tcl's storage of array variables. Each array is a hash table indexed by the hash index of the array subscripts. In this way Tcl supports subscripts that are arbitrary strings without any search overhead when referencing an element of the array. </para> <para> The <classname>CTCLHashTable</classname> and related classes provide an object oriented interface to the Tcl API for hash tables. This class is a <firstterm>template class</firstterm>. The template parameter is the type of data that will be associated with each hash key. For example, to create a has key of <classname>CSpectrum*</classname> (pointers to SpecTcl Spectra): <programlisting> CTCLHashTable<CSpectrum*> spectrumHashTable; </programlisting> </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLHashTable</function> () ; <function>CTCLHashTable</function> ( <type>Tcl_HashTable</type> <parameter>aHashTable</parameter> ); <function>CTCLHashTable</function> (const <type>CTCLHashTable</type>& <parameter>aCTCLHashTable</parameter> ); </programlisting> </para> <para> Three methods for creating <classname>CTCLHashTable</classname> objects are defined. The first of these creates a new, empty hash table. The second, takes the handle to an existing hash table; <type>Tcl_HashTable</type> <parameter>aHashTable</parameter> and wraps a <classname>CTCLHashTable</classname> around this existing hash table providing an object oriented interface to that hash table. The final constructor, a copy constructor, creates a <classname>CTCLHashTable</classname> that refers to the same underlying <type>Tcl_HashTable</type> as the <parameter>aCTCLHashTable</parameter> parameter. </para> <para> <programlisting> <type>CTCLHashTable</type> <function>operator</function>= (const <type>CTCLHashTable</type>& <parameter>rhs</parameter>); <type>int</type> <function>operator==</function> (const <type>CTCLHashTable</type>& <parameter>rhs</parameter>); </programlisting> </para> <para> <function>operator=</function> assigns <parameter>rhs</parameter> to an existing object. The semantics of assignment are that followingt assignment, <varname>*this</varname> and <parameter>rhs</parameter> will refer to the same underlying hash table. </para> <para> <function>operator==</function> compares two hash tables, <varname>*this</varname> and <parameter>rhs</parameter> for equality. The semantics of equality are that the two <classname>CTCLHashTable</classname> objects refer to the same underlying Tcl hash tables. </para> <para> <programlisting> <type>Tcl_HashTable</type>* <function>getHashTable</function>() const; </programlisting> </para> <para> Gets the underlying <type>Tcl_HashTable</type> that is wrapped by a <classname>CTCLHashTable</classname> object. </para> <para> <programlisting> <type>void</type> <function>Enter</function> (const <type>std::string</type>& <parameter>rKey</parameter>, <type>CTCLTHashTableItem<T></type> <parameter>rValue</parameter>); </programlisting> </para> <para> Adds an entry to a hash table. <parameter>rKey</parameter> is the lookup key that will be associated with the entry. <parameter>rValue</parameter> is the data that is associated with that key. Note that <type>T</type> is the template type that was used to create the hashtable. E.g. if the hash table is a <classname>CTCLHashTable<float></classname>, <parameter>rValue</parameter> must be a <classname>CTCLHashTableItem<float></classname>. Note that Tcl hash tables do not support duplicate keys. If a hash table entry with the key <parameter>rKey</parameter> already is in the table it is replaced. </para> <para> <programlisting> const <type>CTCLTHashTableItem</type>* <function>Find</function> (const <type>std::string</type>& <parameter>rsKeyword</parameter>) const; </programlisting> </para> <para> Looks up a hash table item by key. If a hash table item with the key <parameter>rsKeyword</parameter> exists, a pointer to its entry is returned. If <parameter>rsKeyword</parameter> has not yet been <function>Enter</function>ed in the hash table, a <literal>NULL</literal> pointer is returned. </para> <para> <programlisting> <type>CTCLTHashTableItem</type>* <function>Delete</function> (const <type>std::string</type>& <parameter>rsKeyword</parameter>); </programlisting> </para> <para> Removes the hash table entry with the key <parameter>rsKeyword</parameter>. If the item existed, a pointer to it is returned. If the item does not exist in the hash table a <literal>NULL</literal> pointer is returned. </para> <para> <programlisting> <type>CTCLTHashTableIterator</type> <function>begin</function> (); <type>CTCLTHashTableIterator</type> <function>end</function> (); </programlisting> </para> <para> <function>begin</function> returns an <firstterm>iterator</firstterm> that "points" to the first entry in the hash table. dereferencing the iterator yields the pointer to a HashTableItem. The iterator can be incremented via ++ so that it advances to the next item in the table. </para> <para> <function>end</function>returns an iterator that points past the end of the table and can be used to determine when iteration is complete. </para> <para> Iterators are pointer like objects. See the STL reference below for more information about them. The following example Takes a Hash table and counts up the number of elements it contains. <programlisting> CTCLHashTableIterator i = table.begin(); // Table a CTCLHashTable int n = 0; while (i != table.end()) { n++; } // N is a count of elements in the table. </programlisting> </para> <para> <programlisting> <type>std::string</type> <function>Statistics</function> (); </programlisting> </para> <para> Returns a string that contains statistics about the hash table. This is a wrapper for <function>Tcl_HashStats</function> </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLHashTableItem(3), CTCLHashTableIterator(3), Tcl_HashStats(3tcl) </para> </refsect1> <refsect1> <title>REFERENCES</title> <para> <programlisting> Niklaus Wirth <parameter>Algorithms + Data Structures = Programs</parameter> Prentice Hall Series in Automatic Computation 1976 See section 4.6 Musser, Derge, Saini: <parameter>STL Tutorial and Reference Guide</parameter> Addison-Wesley Professional Computing Series; 2001 ISBN 0-201-37923-6 </programlisting> </para> </refsect1> </refentry> </article> </book> --- NEW FILE: CTCLTimer.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLTimer</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLTimer</refname> <refpurpose> Abstract base class for C++ objects attached to timer events. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLTimer.h> ... class CTCLTimer : public CTCLInterpreterObject { public: CTCLTimer (); CTCLTimer(CTCLInterpreter* pInterp, UInt_t nMsec = 0); virtual ~CTCLTimer ( ); Tk_TimerToken getToken() const; UInt_t getMsec() const; Bool_t IsSet() const; virtual void operator() () = 0; void Set () ; void Set(UInt_t nms); void Clear () ; }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> Tcl/Tk provide a mechanism for scheduling functions to be executed after a time delay specified in milliseconds. The <classname>CTCLTimer</classname> class is an abstract base class that provides an interface into the API for that facility. To use <classname>CTCLTimer</classname> you must create a class derived from <classname>CTCLTimer</classname> that overrides and implement the <function>operator()</function> function. Create an object from the resulting function class. Use the object's <function>Set</function> and <function>Clear</function> members to schedule or cancel a scheduled execution. The code fragment example below shows how to do this to create a class that periodically emits the text "Tick" to stderr. Many #include directives are missing for brevity. <programlisting> // Interface to <classname>Ticker</classname> normally goes in a header. class Ticker : public CTCLTimer { public: Ticker(CTCLInterpreter* pInterp, int seconds); virtual ~Ticker(); virtual void operator()(); }; ... // Implementation of <classname>Ticker</classname> normally goes in a .cpp // Constructor of Ticker: Ticker::Ticker(int seconds) : CTCLTimer(pInterp, seconds*1000) { Set(); // Schedule first one. } // Destructor.. chain to base class. Ticker::~Ticker() {} // called when timer goes off: void Ticker::operator()() { cerr << "Tick\n"; Set(); // Schedule next one. } ... Ticker Tick(pInterp, 1); // Tick every second. </programlisting> </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLTimer</function> (); <function>CTCLTimer</function>(<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>UInt_t</type> <parameter>nMsec</parameter> = <literal>0</literal>); </programlisting> </para> <para> Construct timer objects. The first form of the constructor creates a timer object that must be later bound into an interpreter via a call to <classname>CTCLInterpreterObject</classname>::<function>Bind</function>. The seconf form of the contructor creates a timer object that is already bound to <parameter>pInterp</parameter> and has an initial schedule delay of <parameter>nMsec</parameter>. </para> <para> <programlisting> Tk_TimerToken getToken() const; UInt_t getMsec() const; </programlisting> </para> <para> These two members access internal state of the object. <function>getToken</function> returns the <type>Tk_TimerToken</type> associated with the timer object. This is the Tcl/Tk token that identifies the timer request to the interpreter. <function>getMsec</function> retrieves the current value of the delay parameter in milliseconds. </para> <para> <programlisting> virtual void operator() () = 0; </programlisting> </para> <para> This function must be overidden and implemented in concrete timer classes. See the example in DESCRIPTION above. </para> <para> <programlisting> void Set () ; void Set(UInt_t nms); Bool_t IsSet() const; </programlisting> </para> <para> <function>Set</function> schedules the object for execution. If <parameter>nms</parameter> is provided it is saved as the scheduling parameter and determines the delay in milliseconds before <function>operator()</function> is next called. If not provided, the most recently used delay will be used again. </para> <para> <function>IsSet</function> returns <literal>kfTRUE</literal> if the timer is currently pending, or <literal>kfFALSE</literal> if no pending timer request is active. </para> <para> <programlisting> void Clear () ; </programlisting> </para> <para> If a Timer request is pending, cancels it. If no timer request is pending, this function does nothing, and does not report an error. </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLInterpreterObject(3) </para> </refsect1> <refsect1> <title>REFERENCES</title> <para> <programlisting> Musser, Derge, Saini: <parameter>STL Tutorial and Reference Guide</parameter> Addison-Wesley Professional Computing Series; 2001 ISBN 0-201-37923-6 See section 2.4 for a description and discussion of function objects. </programlisting> </para> </refsect1> </refentry> </article> </book> --- NEW FILE: CTCLFileHandler.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLFileHandler</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLFileHandler</refname> <refpurpose> Base class for building object oriented Tcl File event handlers. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLFileHandler.h> ... class CTCLFileHandler : public CTCLInterpreterObject { CTCLFileHandler(CTCLInterpreter* pInterp, UInt_t am_nFid = STDIN_FILENO); CTCLFileHandler(CTCLInterpreter* pInterp, FILE* pFile); CTCLFileHandler (const CTCLFileHandler& aCTCLFileHandler ); ~CTCLFileHandler ( ); CTCLFileHandler& operator= (const CTCLFileHandler& aCTCLFileHandler); int operator== (const CTCLFileHandler& aCTCLFileHandler) const; UInt_t getFid() const; virtual void operator() (int mask) = 0; void Set (int mask) ; void Clear () ; }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> Tcl supplies an event loop. It is possible to add events specifications to this loop. One very useful event type is based on readability or writability of a file descriptor. The <classname>CTCLFileHandler</classname> allows you to create an object oriented file handler, and register it with the event loop so that you can gain control when, for example, a file becomes readable. </para> <para> As <classname>CTCLFileHandler</classname> is an abstract base class, it is necessary to create a derived class. The derived class should implement the <function>operator()</function> which will be called when the specific event is fired. An instance of this derived class should be created, and then the <function>Set</function> and <function>Clear</function> members used to establish and remove the event handler. </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLFileHandler</function>(<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>UInt_t</type> <parameter>nFid</parameter> = <literal>STDIN_FILENO</literal>); <function>CTCLFileHandler</function>(<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>FILE</type>* <parameter>pFile</parameter>); <function>CTCLFileHandler</function> (const <type>CTCLFileHandler</type>& <parameter>aCTCLFileHandler</parameter> ); </programlisting> </para> <para> Constructs a file handler object. <parameter>pInterp</parameter> is a pointer to the interpreter on which the file handler will be registered. The file can be specified either by <parameter>nFid</parameter>, a file descriptor, or <parameter>pFile</parameter> an stdio File stream pointer. </para> <para> A copy constructor allows the creation of a copy of the file handler object given <parameter>aCTCLFileHandler</parameter> an existing one. This is normally not useful. </para> <para> <programlisting> <type>CTCLFileHandler</type>& <function>operator=</function> (const <type>CTCLFileHandler</type>& <parameter>aCTCLFileHandler</parameter>); <type>int</type> <function>operator==</function> (const <type>CTCLFileHandler</type>& <parameter>aCTCLFileHandler</parameter>) const; </programlisting> </para> <para> These functions support assignment and equality comparison. Note that these functions are usually not very useful for file handlers. </para> <para> <programlisting> <type>UInt_t</type> <function>getFid()</function> const; </programlisting> </para> <para> Returns the file id that is associated with the event. </para> <para> <programlisting> virtual <type>void</type> <function>operator</function>() (<type>int</type> <parameter>mask</parameter>) = 0; </programlisting> </para> <para> The user's derived class must override this to provide the desired funtionality when event fires. <parameter>mask</parameter> indicates which event fired the function and can be an or of the following: <literal>TCL_READABLE</literal> if the file can be read without blocking, <literal>TCL_WRITABLE</literal> if the file can be written without blocking, or <literal>TCL_EXCEPTION</literal> if some exceptional condition occured on the file. </para> <para> <programlisting> <type>void</type> <function>Set</function> (<type>int</type> <parameter>mask</parameter>) ; <type>void</type> <function>Clear</function> () ; </programlisting> </para> <para> <function>Set</function> establishes the event handler for the set of conditions described in <parameter>mask</parameter>. The valid bits for <parameter>mask</parameter>, are described in the documentation for the <parameter>mask</parameter> parameter to <function>operator()</function>. </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLObject(3), CTCLInterpreter(3) Tcl_CreateFileHandler(3tcl), Tcl_DeleteFileHandler(3tcl) </para> </refsect1> </refentry> </article> </book> --- NEW FILE: ClanguageTraceCallbacks.xml --- --- NEW FILE: CTCLList.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd"> <book> <article> <refentry> <refmeta> <refentrytitle>CTCLList</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLList</refname> <refpurpose> Provide access to Tcl List parsing. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLList.h> ... class CTCLList : public CTCLInterpreterObject { public: CTCLList (CTCLInterpreter* pInterp); CTCLList (CTCLInterpreter* pInterp, const char* am_pList ); CTCLList (CTCLInterpreter* pInterp, const std::string& rList); CTCLList (const CTCLList& aCTCLList ); CTCLList& operator= (const CTCLList& aCTCLList); int operator== (const CTCLList& aCTCLList); int operator!= (const CTCLList& aCTCLList); const char* getList() const; int Split (StringArray& rElements) ; int Split (int& argc, char*** argv); const char* Merge (const StringArray& rElements) ; const char* Merge(int argc, char** argv); }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> Tcl Lists are white space separated words. It is definition of words and quoting issues that makes the parsing of lists less than straightforward. </para> <para> Fortunately, Tcl provides several list processing functions. The concept of a list and access to list processing functions are encapsulated in the <classname>CTCLList</classname> class. </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <type>CTCLList</type> (<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>); <type>CTCLList</type> (<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, const <type>char</type>* <parameter>pList</parameter> ); <type>CTCLList</type> (<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, const <type>std::string</type>& <parameter>rList</parameter>); <type>CTCLList</type> (const <type>CTCLList</type>& <parameter>rhs</parameter>); </programlisting> </para> <para> These four functions provide various ways to create a <classname>CTCLList</classname> object. The first constructor creates an empty list. The next two, create a list that has an initial value given by either the <literal>NULL</literal> terminated string <parameter>pList</parameter>, or the <type>std::string</type> object <parameter>rList</parameter>. The final constructor creates a list that is a duplicate of the list described by the object <parameter>rhs</parameter>. </para> <para> <programlisting> <type>CTCLList</type>& <function>operator=</function> (const <type>CTCLList</type>& <parameter>rhs</parameter>); <type>int</type> <function>operator==</function> (const <type>CTCLList</type>& <parameter>rhs</parameter>); <type>int</type> <function>operator!=</function> (const <type>CTCLList</type>& <parameter>rhs</parameter>); </programlisting> </para> <para> These function provide assignment (<function>operator=</function>), equality comparison (<function>operator==</function>), and inequality comparison (<function>operator!=</function>) with another <classname>CTCLList</classname> object, <parameter>rhs</parameter>. Assignment is defined as copying the string format of the list. Equality comparison is defined as the both interpreter and strings being equal. Inequality is defined as !operator==. </para> <para> <programlisting> const <type>char</type>* <function>getList()</function> const; </programlisting> </para> <para> <function>getList</function> returns an immutable pointer to the string rerpesentation of the list. Note that the const qualfier on the pointer means that attempts to dereference the pointer which would modify the list result in error messages. For Example: <programlisting> CTCLList aList(pInterp, "some list"); const char* pData = aList.getList(); *pData = 'S'; // Compiler error!!!! </programlisting> </para> <para> <programlisting> <type>int</type> <function>Split</function> (<type>StringArray</type>& <parameter>rElements</parameter>) ; <type>int</type> <function>Split</function> (<type>int</type>& <parameter>argc</parameter>, <type>char</type>*** <parameter>argv</parameter>); </programlisting> </para> <para> Splits a list up into its component words. <parameter>relements</parameter> is a <type>std::vector<std::string></type> into which the elements will be split. <parameter>argc</parameter> is a reference to an integer into which the number of elements will be put. <parameter>argv</parameter> is a pointer to a <type>char</type>** into which will be placed a pointer to dynamically allocated storage containing a list of <parameter>argc</parameter> pointers to the words in the string. This storage must be released by the caller with <function>Tcl_Free</function>. For example: <programlisting> CTCLList someList(pInterp, someInitialContents); ... int argc; char** argv; someList.Split(argc, &argv); // // ... do something with the data // ... // // Done with the list elements. // Tcl_Free((char*)argv); </programlisting> </para> <para> <programlisting> const <type>char</type>* <function>Merge</function> (const <type>StringArray</type>& <parameter>rElements</parameter>) ; const <type>char</type>* <function>Merge</function>(<type>int</type> argc, <type>char</type>** <parameter>argv</parameter>); </programlisting> </para> <para> Merges a bunch of words in to a list. If necessary, quoting is performed to ensure that words that have whitespace or other special characters will be correctly formatted into the list. <parameter>rElements</parameter> is a <type>std::vector<std::string></type> of words that will be merged into the string. <parameter>argc</parameter> is a count of the number of words, and <parameter>argv</parameter> is a pointer to an array of pointers to the words stored as <literal>NULL</literal> terminated strings. The return value is the final string representation of the list after the merge operation has been performed. </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLInterpreter(3), CTCLInterpreterObject(3), Tcl_Free(3tcl) </para> </refsect1> </refentry> </article> </book> --- NEW FILE: CTCLHashTableItem.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLHashTableItem</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLHashTableItem</refname> <refpurpose> Encapsulation of an entry in a Tcl Hash table as encapsulated in <classname>CTCLHashTable</classname> </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLHashTableItem.h> ... template <class T> // T Must have copy ctor & Assignment defined. class CTCLHashTableItem { CTCLHashTableItem (T am_Item ); CTCLHashTableItem (const CTCLHashTableItem& aCTCLHashTableItem ); virtual ~CTCLHashTableItem ( ); CTCLHashTableItem operator= (const CTCLHashTableItem& aCTCLHashTableItem); int operator== (const CTCLHashTableItem& aCTCLHashTableItem); T getItem() const; T* operator-> (); } </programlisting> </refsynopsisdiv> <refsect1> <title></title> <para> Provides an object oriented interface to elements of a hash table. See CTCLHashTable(3), and the first REFERENCE below for more information about hash tables. </para> <para> Note that this is a templated class. The template parameter is the type of the item to be stored in the hash table. Suppose, for example, we have a bunch of named calibration parameters (floating point) that are stored in a hash table. A calibration The following code creates the calibration table, and inserts an element named george in it with the initial value of 0.0: <programlisting> CTCLHashTable<float> calibrationTable; CTCLHashTableItem<float> entry(0.0); calibrationTable.Enter(std::string("george"), entry); </programlisting> </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLHashTableItem</function> (<type>T</type> <parameter>Item</parameter> ); <function>CTCLHashTableItem</function> (const <type>CTCLHashTableItem</type>& <parameter>hashItem</parameter> ); </programlisting> </para> <para> Constructs a <classname>CTCLHashTableItem</classname> either from the underlying type (<parameter>Item</parameter>) or from an existing <classname>CTCLHashTableItem</classname> (<parameter>hashItem</parameter>). </para> <para> <programlisting> <type>CTCLHashTableItem</type> <function>operator=</function>(const <type>CTCLHashTableItem</type>& <parameter>rhs</parameter>); <type>int</type> <parameter>operator==</parameter> (const <type>CTCLHashTableItem</type>& <type>rhs</type>); </programlisting> </para> <para> <function>operator=</function> allows you to assign the value of one <classname>CTCLHashTableItem</classname> to another. The underlying templated type must be capable of assignment. </para> <para> <function>operator==</function> allows you to compare two <classname>CTCLHashTableItem</classname>s to each other. The underlying templated type must be capable of equality comparison. </para> <para> <programlisting> <type>T</type> <function>getItem</function>() const; </programlisting> </para> <para> Returns the value of the item wrapped by the <classname>CTCLHashTableItem</classname> The underlying type must be capable of copy construction. </para> <para> <programlisting> <type>T</type>* <function>operator-></function> (); </programlisting> </para> <para> Returns the address of the contents of the <classname>CTCLHashTableItem</classname>. This is most useful if <classname>T</classname> is a structure or class as it can be used to dereference member (data or functions) of the structure or class. For example: <programlisting> struct complex { double real; double imaginary; complex(double r, double i) : real(r), imaginary(i) {} } complex; CTCLHashTableItem<complex> v(1.0, 2.0); double real = v->real; // real = 1.0 double imag = v->imaginary; // imag = 2.0 </programlisting> </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLHashTable(3), CTCLHashTableIterator(3) </para> </refsect1> <refsect1> <title>REFERENCES</title> <para> <programlisting> Niklaus Wirth <parameter>Algorithms + Data Structures = Programs</parameter> Prentice Hall Series in Automatic Computation 1976 See section 4.6 </programlisting> </para> </refsect1> </refentry> </article> </book> Index: TCLInterpreter.cpp =================================================================== RCS file: /cvsroot/nsclspectcl/SpecTcl/TCL/TCLInterpreter.cpp,v retrieving revision 5.3 retrieving revision 5.4 diff -C2 -d -r5.3 -r5.4 *** TCLInterpreter.cpp 10 Mar 2006 14:21:53 -0000 5.3 --- TCLInterpreter.cpp 16 Mar 2006 14:05:15 -0000 5.4 *************** *** 430,434 **** // throws an exception on error. ! int Status = Tcl_RecordAndEval(m_pInterpreter, (char*)pScript, fEvaluate); if(Status != TCL_OK) { CTCLException except(*this, --- 430,437 ---- // throws an exception on error. ! int Status = Tcl_RecordAndEval(m_pInterpreter, (char*)pScript, ! fEvaluate ? TCL_EVAL_GLOBAL : ! TCL_NO_EVAL); ! if(Status != TCL_OK) { CTCLException except(*this, --- NEW FILE: CTCLVariable.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLVariable</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLVariable</refname> <refpurpose> Encapsulate Tcl interpreter variables. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLVariable.h> class CTCLVariable : public CTCLInterpreterObject { public: CTCLVariable (std::string am_sVariable, Bool_t am_fTracing ); CTCLVariable (CTCLInterpreter* pInterp, std::string am_sVariable, Bool_t am_fTracing ); CTCLVariable (const CTCLVariable& aCTCLVariable ); CTCLVariable& operator= (const CTCLVariable& aCTCLVariable); int operator== (const CTCLVariable& aCTCLVariable) const; std::string getVariableName() const; Bool_t IsTracing() const; void setVariableName (const std::string am_sVariable); virtual char* operator() (char* pName, char* pSubscript, int Flags) ; static char* TraceRelay (ClientData pObject, Tcl_Interp* pInterpreter, tclConstCharPtr pName, tclConstCharPtr pIndex, int flags) ; const char* Set (const char* pValue, int flags=TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY) ; const char* Set (const char* pSubscript, char* pValue, int flags=TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY) ; const char* Get (int flags=TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY, char* pIndex=0) ; int Link (void* pVariable, int Type) ; void Unlink () ; int Trace (int flags=TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS, char* pIndex = (char*)kpNULL) ; void UnTrace () ; }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> <classname>CTCLVariable</classname> allows an existing or new Tcl interpreter variable to be encapsulated so that it can be accessed, traced or linked in C++ code. </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLVariable</function>(<type>std::string</type> <parameter>sName</parameter>, <type>Bool_t</type> <parameter>fTracing</parameter> ); <function>CTCLVariable</function> (<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>std::string</type> <parameter>sName</parameter>, <type>Bool_t</type> <parameter>fTracing</parameter> ); <function>CTCLVariable</function> (<type>const CTCLVariable</type>& <parameter>aCTCLVariable</parameter> ); </programlisting> </para> <para> In the first two cases, <parameter>sName</parameter> is the name of the variable that will be wrapped by this object. The variable name can contain namespace qualifications as well as indices. If <parameter>fTracing</parameter> is true, the object is set to record that it is tracing the variable. Normally this parameter should be allowed to default to <literal>kfFALSE</literal>, and the trace member functions used to set explicit traces. For the final form of the constructor (copy constructor), <parameter>aCTCLVariable</parameter> is a <classname>CTCLVariable</classname> that will be copied into this object. </para> <para> In the first form of the constructor, one must later call the <function>Bind</function> function (see CTCLInterpreterObject), to bind the variable to a specific interpreter prior to accessing it. </para> <para> <programlisting> <type>CTCLVariable</type>& <function>operator=</function>(<type>const CTCLVariable</type>& <parameter>rhs</parameter>); </programlisting> </para> <para> Assigns the <parameter>rhs</parameter> object to this one. A reference to the left hand side of the assignment is returned. The semantics of assignment are not that the variable values are assigned, but that the left side of the assignment becomes a functional equivalent of <parameter>rhs</parameter>, that is it stands for the same object and has the same traces (if any) set. Thus, if <parameter>rhs</parameter> wraps the interpreter variable <varname>a</varname> and the object on the left side wraps interpreter variable <varname>b</varname> after the assignment executes, the left side object will be wrapping <varname>a</varname>. A reference to the object on the left hand side of the assignment is returned. </para> <para> <programlisting> <type>int</type> <function>operator==</function>(<type>const CTCLVariable</type>& <parameter>rhs</parameter>) const; </programlisting> </para> <para> Compares this object for functional equality with <parameter>rhs</parameter>. Functional equality is defined as the two objects referring to the same variable, in the same interpreter, and having traces set on the same operations. </para> <para> <programlisting> <type>std::string</type> <function>getVariableName</function>() const; </programlisting> </para> <para> Returns the name of the Tcl variable that is wrapped by this object. </para> <para> <programlisting> <type>int</type> <function>Trace</function>(<type>int</type> <parameter>flags</parameter>=<literal>TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS</literal>, <type>char</type>* <parameter>pIndex</parameter> = (<type>char</type>*)<literal>kpNULL</literal>) ; <type>void</type> <function>UnTrace</function> () ; <type>Bool_t</type> <function>IsTracing</function>() const; virtual <type>char</type>* <function>operator()</function> (<type>char</type>* <parameter>pName</parameter>, <type>char</type>* <parameter>pSubscript</parameter>, <type>int</type> <parameter>Flags</parameter>) ; </programlisting> </para> <para> This set of functions supports variable tracing. In Tcl, a trace is a function that is called when some event of interest occurs on a varialbe. The possible events are read, write, and unset. To effectively use variable tracing, you must create a subclass of <classname>CTCLVariable</classname>, override its <function>operator()</function> member to handle the trace and call <function>Trace</function> to initiate tracing. </para> <para> The <function>Trace</function> member initiates tracing on the variable. <parameter>flags</parameter> describes when the trace should fire. See the manpage for <function>Tcl_TraceVar</function> for information about the legal flag values. </para> <para> <function>Untrace</function> cancels all traces on the variable represented by this object. </para> <para> <function>IsTracing</function> returns <literal>kfTRUE</literal> if tracing is being performed on the variable. </para> <para> When a trace fires, the <function>operator()</function> member will be called. This is why you must override the <classname>CTCLVariable</classname> base class to do anything useful with a trace. The parameters to the call are; <parameter>pName</parameter> is the name of the variable that has been traced. <parameter>pSubscript</parameter> is the array subscript in the event the trace fires on an array or element of an array, and is <literal>NULL</literal> otherwise. <parameter>Flag</parameter> describes why the trace fired. Again, see the <function>Tcl_TraceVar</function> manpage for more information. Note that for write traces, the variable has already been set. Modifying the value of the traced variable within a trace function will not fire any additional traces. The <function>operator()</function> function must return a <literal>NULL</literal> pointer if the trace is successful. It must return a pointer to an error message if the trace is not successful. An example of an unsuccessful trace might be a write trace that ensures that only particular values are assigned to the variable. </para> <para> <programlisting> const <type>char</type>* <function>Set</function>(const <type>char</type>* <parameter>pValue</parameter>, <type>int</type> <parameter>flags</parameter>=<literal>TCL_LEAVE_ERR_MSG</literal> | <literal>TCL_GLOBAL_ONLY</literal>) ; const <type>char</type>* <function>Set</function>(const <type>char</type>* <parameter>pSubscript</parameter>, <type>char</type>* <parameter>pValue</parameter>, <type>int</type> <parameter>flags</parameter>=<literal>TCL_LEAVE_ERR_MSG</literal> | <literal>TCL_GLOBAL_ONLY</literal>) ; </programlisting> </para> <para> Sets the value of the variable to the string pointed to by <parameter>pValue</parameter> The second form of this assumes that the <classname>CTCLVariable</classname> represents an array and the <parameter>pSubscript</parameter> parameter specifies the subscript of the array that is being set. The <parameter>flags</parameter> parameter is fully documented in the Tcl manpage for Tcl_SetVar </para> <para> <programlisting> const <type>char</type>* <function>Get</function>(<type>int</type> <parameter>flags</parameter>=<literal>TCL_LEAVE_ERR_MSG</literal> | <literal>TCL_GLOBAL_ONLY</literal>, <type>char</type>* <parameter>pIndex</parameter>=<literal>0</literal>) ; </programlisting> </para> <para> Retrieves the current value of a variable. If the <parameter>pIndex</parameter> parameter is supplied, the variable wrapped by <classname>CTCLVariable</classname> is assumed to be an array and <parameter>pIndex</parameter> points to the subscript of the element to retrieve. The <parameter>flags</parameter> parameter is fully documented in the Tcl_GetVar manpage. The return value of the function is a null terminated character string that is the current value of the variable. If the variable does not exist, then a <literal>NULL</literal> is returned. </para> <para> <programlisting> <type>int</type> <function>Link</function>(<type>void</type>* <parameter>pVariable</parameter>, <type>int</type> <parameter>Type</parameter>) ; <type>void</type> <function>Unlink</function>() ; </programlisting> </para> <para> <function>Link</function> and <function>Unlink</function> support variable linking. Variable linking is when a Tcl variable is made to track the value of a C/C++ variable or C++ member variable of an object. <function>Link</function> establishes the link. <parameter>pVariable</parameter> points to the C or C++ variable or member variable to link to this <classname>CTCLVariable</classname>. The <parameter>Type</parameter> parameter is one of following values: <literal>TCL_LINK_INT</literal>, <literal>TCL_LINK_DOUBLE</literal>, <literal>TCL_LINK_BOOLEAN</literal>, <literal>TCL_LINK_WIDE_INT</literal>, or <literal>TCL_LINK_STRING</literal> indicating the type of the variable to which <parameter>pVariable</parameter> points. For all but <literal>TCL_LINK_STRING</literal>, <parameter>pVariable</parameter> points to a variable of the type indicated, and that variable will be linked. for <literal>TCL_LINK_STRING</literal>, <parameter>pVariable</parameter> points to a <type>char*</type> which should be initialized to point to <literal>NULL</literal>. The Tcl interpreter will use <function>Tcl_Alloc</function> and <function>Tcl_Free</function> to maintain a dynamically allocated string pointed to by that pointer which reflects the value of the variable. If the C/C++ program modifies this string, it must <function>Tcl_Free</function> the prior value and <function>Tcl_Alloc</function> a new value with the new variable value. </para> </refsect1> <refsect1> <title>DEFECTS</title> <para> No <function>operator!=</function> has been defined. </para> <para> There is no protection against multiple links... the most recent link for an underlying Tcl variable is the one effective. </para> </refsect1> <refsect1> <title>SEE ALSO</title> <para> CTCLInterpreter(3), CTCLInterpreterObject(3), Tcl_GetVar(3tcl), Tcl_LinkVar(3tcl), Tcl_SetVar(3tcl), Tcl_TraceVar(3tcl) </para> </refsect1> </refentry> </article> </book> Index: Makefile.am =================================================================== RCS file: /cvsroot/nsclspectcl/SpecTcl/TCL/Makefile.am,v retrieving revision 5.4 retrieving revision 5.5 diff -C2 -d -r5.4 -r5.5 *** Makefile.am 10 Mar 2006 14:21:53 -0000 5.4 --- Makefile.am 16 Mar 2006 14:05:15 -0000 5.5 *************** *** 1,6 **** DEFS = @WCHAR_T_DEF@ INCLUDES = -I.. -I. @TCL_FLAGS@ -I../Utility -I../NSCLException @XINCLUDES@ LDADD = -ltclPlus -lException -lXt -lX11 $(X11EXTRA_LDFLAGS) ! AM_LDFLAGS = -L. @TCL_LDFLAGS@ lib_LTLIBRARIES = libtclPlus.la --- 1,14 ---- + # Make a man page from xml... note that the + # touch is done just in case the docbook man page creation + # command does not exist. + + .xml.3: + $(MANDOCBOOK) man $< + touch $^ + DEFS = @WCHAR_T_DEF@ INCLUDES = -I.. -I. @TCL_FLAGS@ -I../Utility -I../NSCLException @XINCLUDES@ LDADD = -ltclPlus -lException -lXt -lX11 $(X11EXTRA_LDFLAGS) ! AM_LDFLAGS = -L. @TCL_LDFLAGS@ lib_LTLIBRARIES = libtclPlus.la *************** *** 16,20 **** TCLObject.cpp TCLChannel.cpp TCLTracedVariable.cpp \ CLanguageTraceCallbacks.cpp TCLObjectProcessor.cpp \ ! TCLCompatibilityProcessor.cpp testableObjects = TCLInterpreter.o TCLProcessor.o \ --- 24,28 ---- TCLObject.cpp TCLChannel.cpp TCLTracedVariable.cpp \ CLanguageTraceCallbacks.cpp TCLObjectProcessor.cpp \ ! TCLCompatibilityProcessor.cpp testableObjects = TCLInterpreter.o TCLProcessor.o \ *************** *** 39,45 **** TCLChannel.h TCLVersionHacks.h TCLTracedVariable.h \ VariableTraceCallback.h CLanguageTraceCallbacks.h \ ! TCLObjectProcessor.h TCLCompatibilityProcessor.h if CPPUNIT --- 47,83 ---- TCLChannel.h TCLVersionHacks.h TCLTracedVariable.h \ VariableTraceCallback.h CLanguageTraceCallbacks.h \ ! TCLObjectProcessor.h TCLCompatibilityProcessor.h + XMLMANSRC=CTCLApplication.xml CTCLInterpreterObject.xml \ + CTCLInterpreter.xml CTCLVariable.xml CTCLChannel.xml \ + CTCLCommandPackage.xml CTCLCompatibilityProcessor.xml \ + CTCLException.xml CTCLFileHandler.xml CTCLHashTable.xml \ + CTCLHashTableItem.xml CTCLHashTableIterator.xml CTCLIdleProcess.xml \ + CTCLList.xml CTCLObject.xml CTCLObjectProcessor.xml \ + CTCLPackagedCommand.xml CTCLProcessor.xml CTCLResult.xml \ + CTCLString.xml CTCLTimer.xml TclPlus.xml + + XMLMANS=CTCLApplication.3 CTCLInterpreterObject.3 CTCLInterpreter.3 \ + CTCLVariable.3 CTCLChannel.3 CTCLCommandPackage.3 \ + CTCLCompatibilityProcessor.3 CTCLException.3 CTCLFileHandler.3 \ + CTCLHashTable.3 CTCLHashTableItem.3 CTCLHashTableIterator.3 \ + CTCLIdleProcess.3 \ + CTCLList.3 CTCLObject.3 CTCLObjectProcessor.3 \ + CTCLPackagedCommand.3 CTCLProcessor.3 CTCLResult.3 \ + CTCLString.3 CTCLTimer.3 TclPlus.3 + + manpages: $(XMLMANS) $(XMLMANSRC) + + install-data-local: manpages + $(INSTALL_DATA) $(XMLMANS) @prefix@/man/man3 + + clean-local: + -rm -f $(XMLMANS) + + man_MANS = TracingIntro.3 CTracedVariable.3 CVariableTraceCallback.3 \ + CLanguageTraceCallback.3 + + EXTRA_DIST = TCL.WC TCL.omt tkAppInit.c $(man_MANS) $(XMLMANSRC) if CPPUNIT *************** *** 53,57 **** tracetests_SOURCES = TestRunner.cpp \ ccallbacktest.cpp \ ! tracevartest.cpp tracetests_DEPENDENCIES = $(testableObjects) --- 91,95 ---- tracetests_SOURCES = TestRunner.cpp \ ccallbacktest.cpp \ ! tracevartest.cpp tracetests_DEPENDENCIES = $(testableObjects) *************** *** 76,82 **** endif - - man_MANS = TracingIntro.3 CTracedVariable.3 CVariableTraceCallback.3 \ - CLanguageTraceCallback.3 - - EXTRA_DIST = TCL.WC TCL.omt tkAppInit.c $(man_MANS) \ No newline at end of file --- 114,115 ---- --- NEW FILE: CTCLCommandPackage.xml --- <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD Docbook XML 4.3//EN" "file:///usr/share/xml/docbook/schema/dtd/4.3/docbookx.dtd" > <book> <article> <refentry> <refmeta> <refentrytitle>CTCLCommandPackage</refentrytitle> <manvolnum>3</manvolnum> </refmeta> <refnamediv> <refname>CTCLCommandPackage</refname> <refpurpose> Group several related Tcl command extensions and common services they may require together. </refpurpose> </refnamediv> <refsynopsisdiv> <programlisting> #include <TCLCommandPackage.h> ... typedef std::list <CTCLProcessor*> CommandList; typedef CommandList::iterator CommandListIterator; class CTCLCommandPackage : public CTCLInterpreterObject { public: CTCLCommandPackage (CTCLInterpreter* pInterp, const std::string& rSignon=std::string("Unnamed pkg")); CTCLCommandPackage(CTCLInterpreter* pInterp, const char* pSignon = "Unnamed pkg"); virtual ~ CTCLCommandPackage ( ); CTCLCommandPackage (const CTCLCommandPackage& aCTCLCommandPackage ); CTCLCommandPackage& operator= (const CTCLCommandPackage& aCTCLCommandPackage); int operator== (const CTCLCommandPackage& aCTCLCommandPackage); std::string getSignon() const; CommandList getCommandList() const; protected: void setSignon (std::string am_sSignon); public: void Register () ; void Unregister () ; void AddProcessor (CTCLProcessor* pProcessor); void AddProcessors(CommandList& rList); CommandListIterator begin (); CommandListIterator end (); }; </programlisting> </refsynopsisdiv> <refsect1> <title>DESCRIPTION</title> <para> Extensions to Tcl often come in a set of related commands. These commands may require access to a common set of services. The <classname>CTCLCommandPackage</classname> along with the <classname>CTCLPackagedCommand</classname> provide a pair of base classes that facilitate the construction of such commands. </para> <para> The pattern to follow to derive class from <classname>CTCLCommandPackage</classname> This class defines and implements common services for the related commands. The constructor of the derived class will also create instances of classes derived from <classname>CTCLPackagedCommand</classname>. These objects define and implement the related commands. These command processors will be added to the package via <function>AddProcessor</function>, and <function>AddProcessors</function>. </para> <para> When the <classname>CTCLCommandPackage</classname>::<function>Register</function> function is called, all of the commands added to the package will be registered as well. When a command processor is invoked, it can call its <function>getMyPackage</function> member function to obtain a pointer to the owning package and therefore access to the services this package provides. </para> </refsect1> <refsect1> <title>METHODS</title> <para> <programlisting> <function>CTCLCommandPackage</function>(<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>const std::string</type>& <parameter>rSignon</parameter>=<type>std::string</type>(<literal>"Unnamed pkg"</literal>)); <function>CTCLCommandPackage</function>(<type>CTCLInterpreter</type>* <parameter>pInterp</parameter>, <type>const char</type>* <parameter>pSignon</parameter> = <literal>"Unnamed pkg"</literal>); <function>CTCLCommandPackage</function> (<type>const CTCLCommandPackage</type>& <parameter>aCTCLCommandPackage</parameter> ); </programlisting> </para> <para> Constructs instances of the package. <parameter>pInterp</parameter> is a pointer to the interpreter object on which these commands will be registered. <parameter>signon</parameter> is a text string that will be emitted to <literal>stderr</literal> when the package is asked to register its commands. This string is typically a credit or copyright notice for the package. It can be empty if the user desires. </para> <para> The first and second form of the constructor only differ in how the signon message is passed. The final form of the constructor is a copy constructor. While copy construction is legal it is anticipated that this will not normally be used as command packages are usually <firstterm>singleton</firstterm> objects. </para> <para> <programlisting> <type>std::string</type> <function>getSignon</function>() const; </programlisting> </para> <para> Retrieves the signon string from the current object. </para> <para> <programlisting> <type>CommandList</type> <function>getCommandList</function>() const; </programlisting> </para> <para> Retrieves the list of commands that are managed by this package. </para> <para> <programlisting> <type>void</type> <function>setSignon</function> (<type>std::string</type> <parameter>am_sSignon</parameter>); </programlisting> </para> <para> ... [truncated message content] |