-contents of an object are going to change immediately, so the

-execute, file, global, object, result, script

-object-based procedures \fBTcl_ExprLongObj\fR, \fBTcl_ExprDoubleObj\fR,

-Those object-based procedures evaluate an expression held in a Tcl object

-The object argument can retain an internal representation

-boolean, double, evaluate, expression, integer, object, string

-Pointer to an object containing the expression to evaluate.

-Pointer to location in which to store a pointer to the object

-it stores a pointer to the Tcl object

-\fBTcl_DecrRefCount\fR to decrement the object's reference count

-when it is finished with the object.

-boolean, double, evaluate, expression, integer, object, string

-The path represented by this object is used for the operation in

-question. If the object does not already have an internal \fBpath\fR

-The native description of the path object to create.

-The first of two path objects to compare. The object may be converted

-The second of two path objects to compare. The object may be converted

-In the case of an error, filled with an object containing the name of

-Filled with an object containing the result of the operation.

-Pre-allocated object in which to store (using

-The \fBTcl_FS\fR API is objectified and may cache internal

-directory). One side-effect of this is that one must not pass in objects

-to retain a reference to the passed in object, and so one must not assume

-that after any of these calls return, the object still has a reference count of

-due to the object being freed part way through the complex object

-decrementing it. For this reason, objects with a reference count of zero are

-function with such an object will result in no action being taken.

-by the caller, which should call Tcl_DecrRefCount when the result is no

-If the result is \fBTCL_OK\fR, then an object was placed in

-filesystem should ensure it retains a reference count to the object.

-object given by considering the first \fIelements\fR elements as valid path

-It is possible that the returned object is actually an element

-The returned object, typically with a reference count of zero (but it

-add a reference count to the object before using it. In particular, the

-returned object could be an element of the given list, so freeing the

-list might free the object prematurely if no reference count has been taken.

-If the number of elements is zero, then the returned object will be

-and returns a Tcl list object containing each segment of that path as

-It returns a list object with a reference count of zero. If the

-It returns the normalized path object, owned by Tcl, or NULL if the path

-object may be freed any time the cwd changes) - the caller can of

-course increment the refCount if it wishes to maintain a copy for longer.

-\fBTcl_FSJoinToPath\fR takes the given object, which should usually be a

-Returns object, typically with refCount of zero (but it could be shared

-add a refCount to the object before using it. If any of the objects

-passed into this function (pathPtr or path elements) have a refCount

-even if this object is already supposedly of the correct type.

-If the conversion succeeds (i.e.\ the object is a valid path in one of

-path object, in the given filesystem. If the path object belongs to a

-If the translation succeeds (i.e.\ the object is a valid path), then it is

-representation in the filesystem). The object returned is owned by the

-caller, which must store it or call Tcl_DecrRefCount to ensure memory is

-efficient way of creating the appropriate path object type.

-The resulting object is a pure

-object, which will only receive

-A valid list object is returned, unless the path object is not

-which is called to determine whether a given path object belongs to this

-which will be cached inside the path object, and may be retrieved

-called when Tcl needs to duplicate a path object. If NULL, Tcl will

-required if the filesystem creates pure path objects with no string/path

-representation. The return value is a Tcl object whose string

-Function to take a path object, and calculate an internal

-object. May be NULL if paths have no internal representation, or if

-path object. In Tcl, every

-link, it should not be converted into the object it points to (but

-increment the refCount of that object if it wishes to retain a reference

-return value should be an object with refCount of zero.

-added to the \fIresultPtr\fR object given (which can be assumed to be a

-should call Tcl_DecrRefCount on this result when it is no longer needed.

-NULL (or an empty list) if no volumes are provided. The result object

-should be given a refCount for Tcl. Tcl will use the contents of the

-list and then decrement that refCount. This allows filesystems to

-with a refCount of 1 and then forget about the list, if yes, then

-they simply increment the refCount of their master list and pass it

-filesystem should ensure it returns an object with a reference count

-The string value of this object is used to search through \fItablePtr\fR.

-switch names, option names, and similar things where the value of

-an object must be one of a predefined set of values.

-index, object, table lookup

-If this is NULL then Tcl_Alloc is used to allocate enough space for a

-object.

-If this is NULL then Tcl_Free is used to free the space for the entry.

-object.

-Tcl_NewIntObj, Tcl_NewLongObj, Tcl_NewWideIntObj, Tcl_SetIntObj, Tcl_SetLongObj, Tcl_SetWideIntObj, Tcl_GetIntFromObj, Tcl_GetLongFromObj, Tcl_GetWideIntFromObj, Tcl_NewBignumObj, Tcl_SetBignumObj, Tcl_GetBignumFromObj, Tcl_TakeBignumFromObj \- manipulate Tcl objects as integer values

-Integer value used to initialize or set a Tcl object.

-Long integer value used to initialize or set a Tcl object.

-Wide integer value used to initialize or set a Tcl object.

-and \fBTcl_SetBignumObj\fR, this points to the object in which to store an

-\fBTcl_TakeBignumFromObj\fR, this refers to the object from which

-These procedures are used to create, modify, and read Tcl objects

-Tcl object initialized to the integral value of the argument. The

-returned Tcl object is unshared.

-Tcl object pointed to by \fIobjPtr\fR to the integral value provided

-unshared Tcl object. Any attempt to set the value of a shared Tcl object

-or internal representation in the unshared Tcl object will be freed

-value of the appropriate type from the Tcl object \fIobjPtr\fR. If the

-\fBTcl_TakeBignumFromObj\fR may set the content of the Tcl object

-integer, integer object, integer type, internal representation, object, object type, string representation

-Tcl_ListObjAppendList, Tcl_ListObjAppendElement, Tcl_NewListObj, Tcl_SetListObj, Tcl_ListObjGetElements, Tcl_ListObjLength, Tcl_ListObjIndex, Tcl_ListObjReplace \- manipulate Tcl objects as lists

-If an error occurs while converting an object to be a list object,

-an error message is left in the interpreter's result object

-Points to the list object to be manipulated.

-If \fIlistPtr\fR does not already point to a list object,

-For \fBTcl_ListObjAppendList\fR, this points to a list object

-does not already point to a list object,

-points to the Tcl object that will be appended to \fIlistPtr\fR.

-this points to the Tcl object that will be converted to a list object

-stores the number of element objects in \fIlistPtr\fR.

-of pointers to the element objects of \fIlistPtr\fR.

-The number of Tcl objects that \fBTcl_NewListObj\fR

-will insert into a new list object,

-the number of Tcl objects to insert into \fIobjPtr\fR.

-An array of pointers to objects.

-\fBTcl_NewListObj\fR will insert these objects into a new list object

-Each object will become a separate list element.

-a pointer to the resulting list element object.

-Tcl list objects have an internal representation that supports

-create, modify, index, and append to Tcl list objects from C code.

-both add one or more objects

-to the end of the list object referenced by \fIlistPtr\fR.

-\fBTcl_ListObjAppendList\fR appends each element of the list object

-\fBTcl_ListObjAppendElement\fR appends the single object

-Both procedures will convert the object referenced by \fIlistPtr\fR

-to a list object if necessary.

-in the interpreter's result object if \fIinterp\fR is not NULL.

-Similarly, if \fIelemListPtr\fR does not already refer to a list object,

-and leave an error message in the interpreter's result object

-and, if it was converted to a list object,

-of \fIelemListPtr\fR if it converts it to a list object.

-the two procedures return \fBTCL_OK\fR after appending the objects.

-create a new object or modify an existing object to hold

-where each element is a pointer to a Tcl object.

-they return an empty object.

-The new object's string representation is left invalid.

-of the elements in \fIobjc\fR since the list object now refers to them.

-The new list object returned by \fBTcl_NewListObj\fR

-the elements in a list object. It returns the count by storing it in the

-If \fIlistPtr\fR is not already a list object, \fBTcl_ListObjGetElements\fR

-object if \fIinterp\fR is not NULL.

-\fBTcl_ListObjLength\fR returns the number of elements in the list object

-If the object is not already a list object,

-and leaves an error message in the interpreter's result object

-The procedure \fBTcl_ListObjIndex\fR returns a pointer to the object

-It returns this object by storing a pointer to it

-If \fIlistPtr\fR does not already refer to a list object,

-and leaves an error message in the interpreter's result object

-object pointer.

-with the \fIobjc\fR objects in the array referenced by \fIobjv\fR.

-If \fIlistPtr\fR does not point to a list object,

-and leaves an error message in the interpreter's result object

-Otherwise, it returns \fBTCL_OK\fR after replacing the objects.

-Similarly, the reference counts for any replaced objects are decremented.

-For example, the following code inserts the \fIobjc\fR objects

-referenced by the array of object pointers \fIobjv\fR

-Similarly, the following code appends the \fIobjc\fR objects

-append, index, insert, internal representation, length, list, list object, list type, object, object type, replace, string representation

-Pointer to an array of Tcl objects. Each object holds the value of a

-\fBTcl_Command\fR object (returned from \fBTcl_CreateObjCommand\fR or

-stackless, nonrecursive, execute, command, global, object, result, script

-A reference to an unshared object to which the function output will be

-Tcl_NewObj, Tcl_DuplicateObj, Tcl_IncrRefCount, Tcl_DecrRefCount, Tcl_IsShared, Tcl_InvalidateStringRep \- manipulate Tcl objects

-Points to an object;

-This man page presents an overview of Tcl objects and how they are used.

-It also describes generic procedures for managing Tcl objects.

-These procedures are used to create and copy objects,

-and increment and decrement the count of references (pointers) to objects.

-that operate on specific types of objects such as

-Tcl's \fIdual-ported\fR objects provide a general-purpose mechanism

-Tcl objects behave like strings but also hold an internal representation

-For example, a Tcl list is now represented as an object

-as well as an array of pointers to the objects for each list element.

-Dual-ported objects avoid most runtime type conversions.

-The compiler itself uses Tcl objects to

-Although objects contain an internal representation,

-and any change to the object will be reflected in that string

-when the object's string representation is fetched.

-Objects are allocated on the heap

-Objects are shared as much as possible.

-because some objects such as long lists are very large.

-reclaim an object's storage.

-Tcl objects are typed.

-An object's internal representation is controlled by its type.

-Each Tcl object is represented by a \fBTcl_Obj\fR structure

-an object's UTF-8 string representation,

-an object's string representation.

-An object's type manages its internal representation.

-an object's internal representation.

-needed by the object's type to represent the object, a Tcl_WideInt

-an object's storage.

-It holds the count of active references to the object.

-in the section \fBSTORAGE MANAGEMENT OF OBJECTS\fR.

-A key property of Tcl objects is that they hold two representations.

-An object typically starts out containing only a string representation:

-An object containing an empty string or a copy of a specified string

-An object's string value is gotten with

-If the object is later passed to a procedure like \fBTcl_GetIntFromObj\fR

-the procedure will create one and set the object's \fItypePtr\fR.

-An object's two representations are duals of each other:

-For example, \fBTcl_ListObjReplace\fR will modify an object's

-Programmers that implement their own object types

-to mark an object's string representation invalid and to

-Objects usually remain one type over their life,

-but occasionally an object must be converted from one type to another.

-For example, a C program might build up a string in an object

-the object.

-The same object holding the same string value

-Extension writers can also force an object to be converted from one type

-Only programmers that create new object types need to be concerned

-A procedure defined as part of the object type's implementation

-creates a new internal representation for an object

-to see how to create a new object type.

-.SH "EXAMPLE OF THE LIFETIME OF AN OBJECT"

-As an example of the lifetime of an object,

-This assigns to \fIx\fR an untyped object whose

-The object's \fItypePtr\fR member is NULL.

-The \fBincr\fR command first gets an integer from \fIx\fR's object

-This procedure checks whether the object is already an integer object.

-Since it is not, it converts the object

-by setting the object's \fIinternalRep.longValue\fR member

-and setting the object's \fItypePtr\fR

-\fBincr\fR increments the object's integer internal representation

-The string representation of \fIx\fR's object is needed

-.SH "STORAGE MANAGEMENT OF OBJECTS"

-Tcl objects are allocated on the heap and are shared as much as possible

-Reference counting is used to determine when an object is

-An object just created by \fBTcl_NewObj\fR or \fBTcl_NewStringObj\fR

-when a new reference to the object is created.

-if the object's reference count drops to zero, frees its storage.

-An object shared by different code or data structures has

-Incrementing an object's reference count ensures that

-As an example, the bytecode interpreter shares argument objects

-between calling and called Tcl procedures to avoid having to copy objects.

-It assigns the call's argument objects to the procedure's

-When an object's reference count drops less than or equal to zero,

-reference counting since they use an object's value immediately

-and do not retain a pointer to the object after they return.

-However, if they do retain a pointer to an object in a data structure,

-Command procedures that directly modify objects

-copy a shared object before changing it.

-They must first check whether the object is shared

-If the object is shared they must copy the object

-this returns a new duplicate of the original object

-If the object is not shared,

-the object and can safely modify it directly.

-This procedure modifies the list object passed to it in \fIobjv[1]\fR

-must check whether the variable's object is shared before

-If it is shared, it needs to duplicate the object

-internal representation, object, object creation, object type, reference counting, string representation, type conversion

-Tcl_RegisterObjType, Tcl_GetObjType, Tcl_AppendAllObjTypes, Tcl_ConvertToType \- manipulate Tcl object types

-Points to the structure containing information about the Tcl object type.

-The name of a Tcl object type that \fBTcl_GetObjType\fR should look up.

-For \fBTcl_AppendAllObjTypes\fR, this points to the object onto which

-it appends the name of each object type as a list element.

-For \fBTcl_ConvertToType\fR, this points to an object that

-The procedures in this man page manage Tcl object types.

-They are used to register new object types, look up types,

-\fBTcl_RegisterObjType\fR registers a new Tcl object type

-in the table of all object types that \fBTcl_GetObjType\fR

-can look up by name. There are other object types supported by Tcl

-choose to register the object types they create or not.

-\fBTcl_AppendAllObjTypes\fR appends the name of each registered object type

-as a list element onto the Tcl object referenced by \fIobjPtr\fR.

-converting \fIobjPtr\fR to a list object;

-\fBTcl_ConvertToType\fR converts an object from one type to another

-and leaves an error message in the result object for \fIinterp\fR

-Extension writers can define new object types by defining four

-called by the generic Tcl object code:

-from an object's string representation.

-describing the error in the result object for \fIinterp\fR

-from an object's internal representation.

-called to copy an internal representation from one object to another.

-\fIsrcPtr\fR's object type determines what

-that is called when an object is freed.

-for the object's internal representation

-and do other type-specific processing necessary when an object is freed.

-so that it only frees storage when the last object sharing it

-\fIbytes\fR member of the object, since Tcl makes its own internal

-uses of that field during object deletion. The defined tasks for

-internal representation, object, object type, string representation, type conversion

-A pointer to a Tcl Object in which to store the characters read from the

-If non-zero, data read from the channel will be appended to the object.

-Otherwise, the data will replace the existing contents of the object.

-A pointer to a Tcl object in which to store the line read from the

-object.

-A pointer to a Tcl Object whose contents will be output to the channel.

-As of Tcl 8.4, the object-based API \fBTcl_FSOpenFileChannel\fR should

-list object. \fBTcl_GetChannelNamesEx\fR will filter these names

-byte-array object. The string representation of this object will only be

-\fIlineRead\fR rather than a Tcl object.

-accepts a Tcl object whose contents will be output to the channel. The

-byte-array object are written to the channel. The byte-array representation

-of the object will be constructed if it is needed. In this way,

-\fIobjPtr\fR is the object that represents the following argument or NULL if

-to the lifetime of the string representation of the argument object that it

-The reference count of the object returned as result has been

-invoke \fBTcl_DecrRefCount\fR when it is finished with the object.

-Points to a Tcl object containing a command (or sequence of commands)

-as well as a result object containing additional information

-command, event, execute, history, interpreter, object, record

-object-based procedure \fBTcl_RecordAndEvalObj\fR.

-That object-based procedure records and optionally executes

-a command held in a Tcl object instead of a string.

-Refers to the object from which to get the text to search. The

-internal representation of the object may be converted to a form that

-Refers to the object from which to get a regular expression. The

-compiled regular expression is cached in the object.

-operates on the Tcl objects \fItextObj\fR and \fIpatObj\fR instead of

-\fBTcl_RegExpGetInfo\fR are object interfaces that provide the most

-through caching in the pattern and string objects.

-expression from the \fIpatObj\fR. If the object does not already

-from the string in the object and assign it to the internal

-\fBTcl_SaveResult\fR moves the string and object results

-\fBTcl_RestoreResult\fR moves the string and object results from

-specified channel. The number of references to the \fBmsg\fR object goes up by

-the specified interpreter. The number of references to the \fBmsg\fR object

-that reference when it is done with the object.

-the object.

-Object value to become result for \fIinterp\fR.

-The interpreter result may be either a Tcl object or a string.

-set the interpreter result to, respectively, an object and a string.

-return the interpreter result as an object and as a string.

-The procedures always keep the string and object forms

-the result to an object,

-it will return the object's string value.

-The result is left pointing to the object

-The reference count for any old result object

-is decremented and the old result object is freed if no

-\fBTcl_GetObjResult\fR returns the result for \fIinterp\fR as an object.

-The object's reference count is not incremented;

-if the caller needs to retain a long-term pointer to the object

-If the result was set to an object by a \fBTcl_SetObjResult\fR call,

-the object form will be converted to a string and returned.

-If the object's string representation contains null bytes,

-write their code to use the new object API procedures

-If the result is an object,

-pointing to an unshared object representing an empty string.

-that manipulate the result as an object

-append, command, element, list, object, result, return value, interpreter

-Points to a Tcl object containing the new value for the variable.

-Points to a Tcl object containing the variable's name.

-If non-NULL, points to an object containing the name of an element

-array, get variable, interpreter, object, scalar, set, unset, variable