\fBopcua endpoints\fR ?\fIurl\fR?
.
Queries the local OPC/UA server \fBopc.tcp://localhost:4840\fR or the server
specified by the \fIurl\fR parameter for endpoints and returns a list of
deserialized dictionaries based on the \fBUA_EndpointDescription\fR structure.
Consult the \fBopen62541\fR documentation for more information.
.TP
\fBopcua genstubs\fR \fIhandle\fR ?\fIstrip substs ...\fR?
.
Generates stubs for methods in the handle specific address space derived
from the client or server object \fIhandle\fR. The address space
is traversed and browse paths and node class paths are accumulated. The
resulting browse paths optionally get the prefix \fIstrip\fR stripped off
from the beginning and optionally filtered using the glob patterns following
the \fIsubsts\fR parameter. If \fIsubsts\fR is not empty it specifies 
pairwise regexps and substitutions which are applied on the browse paths
for the final procedure names. For all nodes matching the node class
path pattern \fIObject/Method\fR the optional \fIInputArguments\fR and
\fIOutputArguments\fR child nodes are retrieved and stub procedures
are written using the browse path and argument information.
.TP
\fBopcua gentypes\fR \fIhandle\fR
.
Generates custom data type mappings using information obtained from analyzing

	    break
	}
	return $ret
    }

    # Generate stubs for methods in sub-namespace derived from
    # client or server name. Argument "strip" is cut off from the begin
    # of browse paths. Argument "substs" is a list of regexp/substitution
    # elements which are applied in order on the browse path. All following
    # arguments are glob patterns for matching in browse paths before the
    # substitutions are applied. The entire address space is processed
    # by using the root node as base for retrieving the tree of names.
    # Example:
    #
    #   opcua::new client Pumps
    #   opcua::connect Pumps ...
    #   opcua::genstubs Pumps /Root/Objects/2:Pumps/2:
    #
    # writes these procs (assuming there are Pump_1 and Pump_2 objects
    # each having a Start and a Stop method with zero input arguments):
    #
    #   proc opcua::Pumps::Pump_1/Start {} ...
    #   proc opcua::Pumps::Pump_1/Stop {} ...
    #   proc opcua::Pumps::Pump_2/Start {} ...
    #   proc opcua::Pumps::Pump_2/Stop {} ...

    proc genstubs {handle {strip {}} {substs {}} args} {
	::namespace eval ::opcua::$handle {}
	set all [expr {[llength $args] == 0}]
	set root [root]
	if {$all && ([string first /Root/Objects $strip] == 0)} {
	    # speed up for common place
	    set strip [string range $strip 5 end]
	    set root [lindex [translate $handle $root / Objects] 0]

		    if {[string match $pat $b]} {
			set found 1
			break
		    }
		}
	    }
	    if {$found} {
		# procname will be method path with prefix stripped ...
		set b [string range $b [string length $strip] end]
		# ... and mangled by substitutions
		set st {}
		foreach {re st} $substs {
		    regsub -all -- $re $b $st b
		}
		# the opcua::call object is the method's parent
		set o [parent $handle $n]
		# parameter list for proc
		set plist {}
		# arguments (type and name pairs) for opcua::call
		set alist {}
		if {![catch {translate $handle $n / InputArguments} ia]} {

    #   namespaces  { prefix uri ... }
    #   enums       { enumname { bit-width itemname value ... } ... }
    #   structs     { structname { type fieldname ... } ... }
    #
    # This function needs tDOM for XML processing!

    proc _readbsd {string} {
	dict set out namespaces {}
	dict set out enums {}
	dict set out structs {}
	if {[catch {
	    package require tdom
	    set doc [dom parse $string]
	}]} {
	    return $out
	}
	set root [$doc documentElement]
	# process namespaces
	array set ns {}
	foreach attr [$root attributes] {
	    if {[llength $attr] == 3} {
		lassign $attr loc pfx uri
	    }

		# must be ua:ExtensionObject, otherwise skip
		if {[$struct getAttribute BaseType] ne "ua:ExtensionObject"} {
		    continue
		}
	    }
	    set stf {}
	    foreach field [$struct childNodes] {
		if {[$field nodeName] ne "opc:Field"} {
		    continue
		}
		if {[$field hasAttribute SwitchField]} {
		    # cannot process this struct
		    set stf {}
		    break
		}
		# TBD: handle attribute LengthField
		if {![$field hasAttribute TypeName]} {
		    # cannot process this struct
		    set stf {}
		    break
		}
		set nstype [$field getAttribute TypeName]
		lassign [split $nstype :] fns type
		if {$type ne ""} {
		    switch -- $fns {
			opc - ua {
			    lappend stf $type
			}
			tns {
			    lappend stf $nstype
			}
			default {
			    # cannot process this struct
			    set stf {}
			    break
			}
		    }
		} else {
		    lappend stf $nstype
		}
		if {![$field hasAttribute Name]} {
		    # cannot process this struct
		    set stf {}
		    break
		}
		lappend stf [$field getAttribute Name]
	    }
	    if {[llength $stf] && [$struct hasAttribute Name]} {
		set st([$struct getAttribute Name]) $stf
	    }
	}
	# structs need further checking later
	set stl [array names st]
	# process enums
	array set en {}
	foreach enum [$typedict selectNodes opc:EnumeratedType] {
	    set enf {}
	    foreach value [$enum childNodes] {
		if {[$value nodeName] ne "opc:EnumeratedValue"} {
		    continue
		}
		if {[$value hasAttribute Name] && [$value hasAttribute Value]} {
		    lappend enf \
			[$value getAttribute Name] \
			[$value getAttribute Value]
		}
	    }
	    if {[llength $enf] && [$enum hasAttribute Name] &&
		[$enum hasAttribute LengthInBits]} {
		set en([$enum getAttribute Name]) \
		    [concat [$enum getAttribute LengthInBits] $enf]
	    }
	}
	dict set out enums [array get en]
	set enl [array names en]
	# cross check type names in structs

				    void *ctx,
				    UA_StatusChangeNotification *ntf);
static void		ReleaseSubs(UAH *uah);
static void		ReleaseMethodsEtc(UAH *uah, int killProcs);
static void		ReleaseTypes(UAH *uah, int all);
static void		DisconnectClient(UAH *uah);
static void		FreeHandle(char *clientData);
static const UA_DataType *FindType(UAI *uai, UAH *uah, int inDef,
				   const char *name);
static UA_NodeId *	ParseNodeId(Tcl_Interp *interp, UA_NodeId *nodein,
				    const char *string);
static UA_NodeId *	ParseTypeOrNodeId(Tcl_Interp *interp,
					  UAH *uah, UA_NodeId *nodein,
					  const char *string);
static UA_NodeId *	ParseRefTypeOrNodeId(Tcl_Interp *interp,
					     UAI *uai, UA_NodeId *nodein,

 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

static const UA_DataType *
FindType(UAI *uai, UAH *uah, int inDef, const char *name)
{
    size_t j;
    Tcl_HashEntry *hPtr;
    const UA_DataType *type = NULL;

    hPtr = Tcl_FindHashEntry(&uai->types, name);
    if (hPtr != NULL) {
	type = (UA_DataType *) Tcl_GetHashValue(hPtr);
    } else {
	for (j = 0; j < UA_TYPES_COUNT; j++) {
	    if (strcmp(UA_TYPES[j].typeName, name) == 0) {
		type = &UA_TYPES[j];
		break;
	    }
	}
	if ((type == NULL) && (uah != NULL)) {
	    size_t typesSize;
	    UA_DataType *types;

	    if (inDef) {
		types = uah->types;
		typesSize = uah->typesSize;
	    } else {
#if (UA_OPEN62541_VER_MAJOR < 1)
		if (uah->client != NULL) {
		    UA_Client_getCustomDataTypes(uah->client,
						 &types, &typesSize);
		} else {
		    UA_Server_getCustomDataTypes(uah->server,
						 &types, &typesSize);
		}
#else
		types = (UA_DataType *) uah->typesArray.types;
		typesSize = uah->typesArray.typesSize;
#endif
	    }
	    for (j = 0; j < typesSize; j++) {
		if ((types[j].typeName != NULL) &&
		    (strcmp(types[j].typeName, name) == 0)) {
		    type = &types[j];
		    break;
		}
	    }

static UA_NodeId *
ParseTypeOrNodeId(Tcl_Interp *interp, UAH *uah, UA_NodeId *nodein,
		  const char *string)
{
    if ((strchr(string, ';') == NULL) &&
	(strchr(string, '=') == NULL)) {
	const UA_DataType *type = FindType(uah->uai, uah, 0, string);

	if (type != NULL) {
	    *nodein = type->typeId;
	    return nodein;
	}
    }
    return ParseNodeId(interp, nodein, string);

	errstr = "no result buffer";
	goto error;
    }
    namein->name = UA_STRING_NULL;
    if (len > 2) {
	char *p = NULL, *q = strchr(string, ':');

	if ((q != NULL) && (q != string)) {
	    nsindex = strtol(string, &p, 10);
	    if ((p == q) && (p - string < len)) {
		string = p + 1;
	    } else {
		nsindex = 0;
	    }
	}

	}
	if (n == 1) {
	    Tcl_SetResult(interp, "zero, two, or more elements required",
			  TCL_STATIC);
	    goto error;
	}
	if (n) {
	    vtype = FindType(uai, uah, 0, Tcl_GetString(elem[0]));
	    if ((vtype == NULL) || (vtype == &UA_TYPES[UA_TYPES_VARIANT])) {
		Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
		goto error;
	    }
	    /* Now skip type element. */
	    elem += 1;
	    n -= 1;

		    value = NULL;
		    goto error;
		}
		UA_delete(subval, subtype);
		data = (char *) data + subtype->memSize;
	    }
	}
#if (UA_OPEN62541_VER_MAJOR >= 1)
    } else if ((type->membersSize == 0) &&
	       (type->typeKind == UA_DATATYPEKIND_ENUM) &&
	       (type->typeIndex == UA_TYPES_INT32)) {
	/* Map scalar enum types to wide integer. */
	Tcl_WideInt v;

	if (Tcl_GetWideIntFromObj(interp, obj, &v) != TCL_OK) {
	    goto error;
	}
	value = UA_new(type);
	((UA_Int64 *) value)[0] = v;
#endif
    } else {
	Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
    }
error:
    return value;
}


	    goto error;
	} else if (n < 2) {
	    Tcl_SetResult(interp, "need two or more elements, type and data",
			  TCL_STATIC);
	    ret = TCL_ERROR;
	    goto error;
	}
	type = FindType(uai, uah, 0, Tcl_GetString(elem[0]));
	if (type == NULL) {
	    Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
	    ret = TCL_ERROR;
	    goto error;
	}
	if (n > 2) {
	    Tcl_SetObjResult(interp, Tcl_NewListObj(n - 1, &elem[1]));

	attr += 1;
	idx = 4;
    } else {
	/* By default, write the "value" attribute. */
	attr = UA_ATTRIBUTEID_VALUE;
	idx = 3;
    }
    type = FindType(uai, uah, 0, Tcl_GetString(objv[idx]));
    if (type == NULL) {
	Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
	goto error;
    }
    idx++;
    value = EncodeFromObj(interp, uai, uah, type, NULL, objv[idx], 0);
    if (value == NULL) {

    }
    nInArgs = (objc - 4) / 2;
    inArgs = (UA_Variant *) UA_Array_new(nInArgs, &UA_TYPES[UA_TYPES_VARIANT]);
    for (i = 0; i < nInArgs; i++) {
	int idx = i * 2 + 4;
	void *value;

	type = FindType(uai, uah, 0, Tcl_GetString(objv[idx]));
	if (type == NULL) {
	    Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
	    goto argsError;
	}
	idx++;
	if (objv[idx]->typePtr == uai->listObjType)  {
	    int j, n;

{
    UAI *uai = (UAI *) clientData;
    UAH *uah;
    Tcl_HashEntry *hPtr;
    UA_StatusCode uaret;
    int flag;

    if (objc != 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "handle");
	return TCL_ERROR;
    }
    hPtr = Tcl_FindHashEntry(&uai->handles, Tcl_GetString(objv[1]));
    if (hPtr == NULL) {
	Tcl_SetResult(interp, "handle not found", TCL_STATIC);
	ReportError(interp, uai, NULL, 0);

{
    UAI *uai = (UAI *) clientData;
    UAH *uah;
    Tcl_HashEntry *hPtr;
    UA_NodeId nodeid, encid;
    int cmd, i, j;
    Tcl_Obj *obj;
    const UA_DataType *type;
    size_t max;
    static const char *cmdNames[] = {
	"begin", "commit", "enum", "struct", NULL
    };
    enum cmdTag {
	CMD_begin, CMD_commit, CMD_enum, CMD_struct
    };

	}
	if ((nodeid.identifierType != UA_NODEIDTYPE_NUMERIC) ||
	    (encid.identifierType != UA_NODEIDTYPE_NUMERIC)) {
	    Tcl_SetResult(interp, "need numeric node identifier", TCL_STATIC);
	    ReportError(interp, uai, NULL, 0);
	    return TCL_ERROR;
	}
	type = FindType(uai, uah, 1, Tcl_GetString(objv[6]));
	if (type == NULL) {
	    Tcl_SetResult(interp, "unsupported type for enum", TCL_STATIC);
	    ReportError(interp, uai, NULL, 0);
	    return TCL_ERROR;
	}
	if (
#if (UA_OPEN62541_VER_MAJOR < 1)
	    (type->membersSize != 1) || !type->pointerFree
#else
	    (type->membersSize != 0) || !type->pointerFree
#endif
	) {
	    Tcl_SetResult(interp, "unsupported type for enum", TCL_STATIC);
	    ReportError(interp, uai, NULL, 0);
	    return TCL_ERROR;
	}
	max = nodeid.identifier.numeric;
	if (max < encid.identifier.numeric) {
	    max = encid.identifier.numeric;

	}
	obj = GetSymObj(uai, Tcl_GetString(objv[3]),
			(char **) &uah->types[i].typeName);
	Tcl_IncrRefCount(obj);
	uah->types[i].typeId = nodeid;
	uah->types[i].memSize = type->memSize;
	uah->types[i].typeIndex = i;






	uah->types[i].pointerFree = 1;
	uah->types[i].overlayable = UA_BINARY_OVERLAYABLE_INTEGER;
	uah->types[i].binaryEncodingId = 0;
#if (UA_OPEN62541_VER_MAJOR < 1)
	uah->types[i].builtin = 0;
	uah->types[i].membersSize = 1;
	uah->types[i].members = ckalloc(sizeof(UA_DataTypeMember));
	uah->types[i].members[0] = type->members[0];
	obj = GetSymObj(uai, "",
			(char **) &uah->types[i].members[0].memberName);
	Tcl_IncrRefCount(obj);
#else
	uah->types[i].typeKind = UA_DATATYPEKIND_ENUM;
	uah->types[i].membersSize = 0;
	uah->types[i].members = NULL;
#endif
	break;

    case CMD_struct:
	if ((objc < 8) || (objc % 2 != 0)) {
	    Tcl_WrongNumArgs(interp, 1, objv,
		"handle struct name nodeid encid type member ...");
	    return TCL_ERROR;
	}
	if (ParseNodeId(interp, &nodeid, Tcl_GetString(objv[4])) == NULL) {
	    return TCL_ERROR;
	}
	if (ParseNodeId(interp, &encid, Tcl_GetString(objv[5])) == NULL) {
	    return TCL_ERROR;
	}
	/* Validate member types. */
	for (i = 6; i < objc; i += 2) {
	    type = FindType(uai, uah, 1, Tcl_GetString(objv[i]));


	    if (type == NULL) {




















		Tcl_SetResult(interp, "unknown type in struct", TCL_STATIC);
		ReportError(interp, uai, NULL, 0);
		return TCL_ERROR;
	    }		
	}
	max = nodeid.identifier.numeric;
	if (max < encid.identifier.numeric) {
	    max = encid.identifier.numeric;
	}
	max += 64;
	if (uah->types == NULL) {

	uah->types[i].pointerFree = 1;
	uah->types[i].overlayable = 0;
	uah->types[i].binaryEncodingId = encid.identifier.numeric;
	j = sizeof(UA_DataTypeMember) * uah->types[i].membersSize;
	uah->types[i].members = ckalloc(j);
	memset(uah->types[i].members, 0, j);
	for (j = 6; j < objc; j += 2) {
	    int k, isZero;


	    type = FindType(uai, uah, 1, Tcl_GetString(objv[j]));

	    if ((type >= &UA_TYPES[0]) && (type < &UA_TYPES[UA_TYPES_COUNT])) {
		isZero = 1;

	    } else {












		isZero = 0;




	    }
	    k = (j - 6) / 2;
	    obj = GetSymObj(uai, Tcl_GetString(objv[j + 1]),
			    (char **) &uah->types[i].members[k].memberName);
	    Tcl_IncrRefCount(obj);
	    uah->types[i].members[k].memberTypeIndex = type->typeIndex;
	    uah->types[i].members[k].padding =