of the reference between the parent and the new node. \fIBrname\fR is
the browse name (see section \fBQUALIFIED NAMES\fR) of the new node.
The optional \fIattrs\fR parameter specifies attributes for the new node
in form of a dictionary (see \fBopcua attr default\fR). If it is omitted,
default values are used. The \fIDisplayName\fR attribute if left empty
is preset to the name part of the browse name parameter.
.TP
\fBopcua add\fR \fIhandle\fR \fBMethod|SimpleMethod\fR \fInodeid parent reftype outargs brname inargs cmd\fR ?\fIattrs\fR?
.
Adds an new node of node class \fIMethod\fR in the server object \fIhandle\fR
and returns the node identifer. In the \fBSimpleMethod\fR command form the
parameter \fIoutargs\fR describes the output arguments of the method as a
list of zero or more pairs of data type and argument names. Likewise,
\fIinargs\fR describes the input arguments of the method. In the \fBMethod\fR
command form, both \fIoutargs\fR and \fIinargs\fR must be provided as lists
of dicts with the template obtained from \fBopcua types empty\fR
\fIArgument\fR. The parameter \fIcmd\fR is the Tcl callback to handle the
method invocation, see section \fBMETHOD CALLBACKS\fR for more information.
For the other parameters, refer to \fBopcua add DataType\fR.
.TP
\fBopcua add\fR \fIhandle\fR \fBNamespace\fR \fIname\fR
.
Adds the new namespace \fIname\fR to the server object \fIhandle\fR and
returns a numeric identifier for this namespace.

.SH "QUALIFIED NAMES"
.PP
Qualified names are used for example in the \fBopcua browse\fR and
\fBopcua translate\fR operations as so called browse names. These
are made up of an optional numeric namespace prefix (a number followed
by a colon) and a name, e.g. \fI2:MyObject\fR. The namespace prefix is
left out if the name refers to namespace zero.
.SH "LOCALIZED TEXT"
.PP
The data type \fBLocalizedText\fR is represented as a dict with the
keys \fIlocale\fR and \fItext\fR. When converting a Tcl value to
a \fBLocalizedText\fR item, these keys are tried to be associated.
If this operation fails, the Tcl value is used as the \fItext\fR
part of the \fBLocalizedText\fR item and the \fIlocale\fR part is
left empty.
.SH "SUPPORTED DATA TYPES"
.PP
Currently, most of the data types of namespace zero are supported
and can be mapped to/from Tcl, i.e. integral and floating point numbers,
strings, GUIDs, and interal extension objects (similar to structures).
For the latter, dictionaries are used in both directions, i.e. for
encoding, a dictionary is searched for the respective member names,
for decoding, a dictionary is created from the internal representation
using the member names of the data type, see \fBopcua attrs default\fR
for example. To represent arrays, Tcl lists are used, e.g. an array
of structures will yield a list of dicts when expressed as Tcl value.
Support for custom data types is highly experimental and underdocumented
(see \fBopcua gentypes\fR).
.SH "MONITOR CALLBACKS"
.PP
Monitor callbacks are invoked when a monitored item (data or event)
is received. The callback parameter given in \fBopcua monitor new\fR
must have proper list format and gets a single value (data) or
a list of values (event) appended prior to invocation.
.SH "DATA SOURCE CALLBACKS"

set OF [lindex [opcua translate S [opcua root] / Objects] 0]

# create an object in our namespace in Objects folder
set obj [opcua add S Object "ns=$ns;s=MyObject" $OF Organizes \\
             "$ns:MyObject"]

# create methods on object
set meth [opcua add S SimpleMethod "ns=$ns;s=Reverse" \\
              $obj HasComponent \\
              {String out} "$ns:Reverse" {String in} \\
              ::opcua::S::_reverse]
set meth [opcua add S SimpleMethod "ns=$ns;s=WordSplit" \\
              $obj HasComponent \\
              {String out} "$ns:WordSplit" {String in} \\
              ::opcua::S::_wordsplit]
set meth [opcua add S SimpleMethod "ns=$ns;s=Exit" \\
              $obj HasComponent \\
              {} "$ns:Exit" {} \\
              ::opcua::S::_exit]

# create a variable in our namespace in Objects folder
set var [opcua add S Variable "ns=$ns;s=ItsTclTime" \\
              $OF Organizes \\

# get Objects folder
set OF [lindex [opcua translate S [opcua root] / Objects] 0]

# create an object in our namespace in Objects folder
set obj [opcua add S Object "ns=$ns;s=MyObject" $OF Organizes "$ns:MyObject"]

# create methods on object
set meth [opcua add S SimpleMethod "ns=$ns;s=Reverse" $obj HasComponent \
	      {String out} "$ns:Reverse" {String in} ::opcua::S::_reverse]
set meth [opcua add S SimpleMethod "ns=$ns;s=WordSplit" $obj HasComponent \
	      {String out} "$ns:WordSplit" {String in} ::opcua::S::_wordsplit]
set meth [opcua add S SimpleMethod "ns=$ns;s=Exit" $obj HasComponent \
	      {} "$ns:Exit" {} ::opcua::S::_exit]

# create a variable in our namespace in Objects folder
set var [opcua add S Variable "ns=$ns;s=ItsTclTime" $OF Organizes \
	     "$ns:ItsTclTime" {} {} ::opcua::S::_its_tcl_time]

# dump methods

# get Objects folder
set OF [lindex [opcua translate S [opcua root] / Objects] 0]

# create an object in our namespace in Objects folder
set obj [opcua add S Object "ns=$ns;s=MyObject" $OF Organizes "$ns:MyObject"]

# create methods on object
set meth [opcua add S SimpleMethod "ns=$ns;s=Reverse" $obj HasComponent \
	      {String out} "$ns:Reverse" {String in} ::opcua::S::_reverse]
set meth [opcua add S SimpleMethod "ns=$ns;s=WordSplit" $obj HasComponent \
	      {String out} "$ns:WordSplit" {String in} ::opcua::S::_wordsplit]
set meth [opcua add S SimpleMethod "ns=$ns;s=Exit" $obj HasComponent \
	      {} "$ns:Exit" {} ::opcua::S::_exit]

# create a variable in our namespace in Objects folder
set var [opcua add S Variable "ns=$ns;s=ItsTclTime" $OF Organizes \
	     "$ns:ItsTclTime" {} {} ::opcua::S::_its_tcl_time]

# dump methods

set OF [lindex [opcua translate S [opcua root] / Objects] 0]

# create an object in our namespace in Objects folder
set obj [opcua add S Object "ns=${ns};s=TclIsCool" $OF Organizes \
	    "${ns}:TclIsCool"]

# create method on object
set meth [opcua add S SimpleMethod "ns=${ns};s=GetPlatform" $obj HasComponent \
	    {KVPair out} "${ns}:GetPlatform" {} ::opcua::S::_platform]

# create a variable with platform data
set att [opcua attrs default VariableAttributes]
if {[opcua version] < 1.0} {
    dict set att DataType [opcua types nodeid S KVPair]
    dict set att Value [concat KVPair [opcua::S::_platform {} {}]]

	return $rgb
    }
}

# make an object with some methods
set obj [opcua add S Object "ns=${nsidx};s=MyObject" $OF \
	     Organizes "${nsidx}:MyObject"]
set meth [opcua add S SimpleMethod "ns=${nsidx};s=platform" $obj \
	      HasComponent {KVPair out} "${nsidx}:platform" {} \
	      ::opcua::S::_platform]
set meth [opcua add S SimpleMethod "ns=${nsidx};s=flip_red_blue" $obj \
	      HasComponent {RGB out} "${nsidx}:flip_red_blue" {RGB in} \
	      ::opcua::S::_flip_red_blue]

# generate stubs
opcua genstubs S /Root/Objects/${nsidx}:MyObject/${nsidx}:

# local test
set var "ns=${nsidx};s=X1"

	    }
	}
	# keep only the nodeid
	set type [lindex $type 0]
	# read BrowseName attribute yields QualifiedName
	set bname [read $handle $root BrowseName]
	# read DisplayName attribute yields LocalizedText
	# but we want the text part only here
	set dname [dict get [read $handle $root DisplayName] text]
	_walk $handle $root $bname $dname Object $org $type ret
	# remove duplicates by path
	array set x {}
	set nodup {}
	foreach {l n b d c r t path} $ret {
	    if {[::info exists x($path)]} {
		continue

		    set ia [read $handle $ia]
		} else {
		    # no arguments
		    set ia {}
		}
		# go over the arguments
		foreach in $ia {
		    if {![dict exists $in Name] ||
			![dict exists $in DataType]} {
			# should not happen
			continue
		    }
		    set name [dict get $in Name]
		    set typeid [dict get $in DataType]
		    lappend plist $name
		    # caution: type name can have a namespace index
		    set type [read $handle $typeid BrowseName]
		    if {[string match "*:*" $type]} {
			set short \
			    [string range $type [string first ":" $type]+1 end]
			if {$short in [types list $handle]} {

	    set doc [dom parse $string]
	}]} {
	    return $out
	}
	set root [$doc documentElement]
	# process namespaces
	array set ns {}
	foreach att [$root attributes] {
	    if {[llength $att] == 3} {
		lassign $att loc pfx uri
	    }
	    if {$uri ne ""} continue
	    set nsx "xmlns:$loc"
	    if {[$root hasAttribute $nsx]} {
		set ns($pfx) [$root getAttribute $nsx]
	    }
	}

		    continue
		}
		if {[$field hasAttribute SwitchField]} {
		    # cannot process this struct
		    set stf {}
		    break
		}

		if {![$field hasAttribute TypeName]} {
		    # cannot process this struct
		    set stf {}
		    break
		}
		set nstype [$field getAttribute TypeName]
		lassign [split $nstype :] fns type

		    lappend stf $nstype
		}
		if {![$field hasAttribute Name]} {
		    # cannot process this struct
		    set stf {}
		    break
		}
		set fn [$field getAttribute Name]
		# handle attribute LengthField, it makes the field
		# into an array, if not empty; the field's name is
		# set to 'field' for scalar, and '*field' for array
		if {[$field hasAttribute LengthField] &&
		    [$field getAttribute LengthField] ne ""} {
		    set fn "*${fn}"
		}
		lappend stf $fn
	    }
	    if {[llength $stf] && [$struct hasAttribute Name]} {
		set st([$struct getAttribute Name]) $stf
	    }
	}
	# structs need further checking later
	set stl [array names st]

	    }
	}
	foreach n $todo {
	    _resolve $n have need later defs
	}
    }

    # Generate ExtensionObject defs for enums and structs.
    # Method information of a server handle must be saved
    # and restored, since the "gentypes" proc recreates
    # type mappings.

    proc gentypes {handle} {
	if {[info $handle] ne "server"} {
	    tailcall _gentypes $handle
	}
	set msaved [methods $handle]
	set ret [catch {_gentypes $handle} err]
	foreach {m t cb} $msaved {
	    # try to restore method output types
	    catch {methods $handle $m $t}
	}
	if {$ret} {
	    return -code $ret $err
	}
    }

    proc _gentypes {handle} {
	foreach {name nodeid encid bsdname} [_getstructs $handle] {
	    set stn($name) $nodeid
	    set enc($name) $encid
	    set bsn($bsdname) $name
	}
	if {![array exists stn]} {
	    return

		set id [lindex $id 0]
		if {[catch {
		    translate $handle $id HasEncoding {Default Binary}
		} eid]} {
		    set eid $id
		}
		set eid [lindex $eid 0]
		if {![catch {types nodeid $handle $en}]} {
		    # already defined, skip
		    continue
		}
		lappend defs [list typedef $handle enum \
				  $en $id $eid $type \
				  {*}[lrange $ed 1 end]]
	    }
	    foreach {sn sd} [dict get $data structs] {
		if {![::info exists bsn($sn)]} {
		    # no mapping from *.bsd to address space

		    # verify namespace index
		    if {[scan $stn($sn) "ns=%d;i=%d" ns id] != 2} {
			continue
		    }
		    if {$ns != $nsindex} {
			continue
		    }
		}
		if {![catch {types nodeid $handle $sn}]} {
		    # already defined, skip
		    continue
		}
		set def [list typedef $handle struct $sn $stn($bn) $enc($bn)]
		foreach {type member} $sd {
		    if {[regsub -- ^tns: $type ${nsindex}: type]} {
			# enums have two elements
			scan [lindex $type 0] "%d:%s" tns ttype
			if {![::info exists have($ttype)]} {

	    # add reference to encoding object
	    add $handle Reference $te HasDescription $tx 1
	}
	append bsd "</opc:TypeDictionary>\n"
	# store *.bsd type defs into node
	write $handle $tt ByteString $bsd
    }

    # Internal helper: get boolean XML attribute.

    proc _ld_getboolatt {node att def} {
	set ret $def
	if {[$node hasAttribute $att]} {
	    set ret [expr {[$node getAttribute $att] ? 1 : 0}]
	}
	return $ret
    }

    # Internal helper: set node reference info from XML dom node.

    proc _ld_noderefs {node dict} {
	upvar $dict d
	set ret {}
	foreach ref [$node selectNodes References/Reference] {
	    dict set r forward [_ld_getboolatt $ref IsForward 1]
	    dict set r type [$ref getAttribute ReferenceType]
	    dict set r nodeid [[$ref firstChild] data]
	    lappend ret $r
	    unset r
	}
	dict set d refs $ret
    }

    # Internal helper: set node's browse/display names etc. from XML dom node.

    proc _ld_nodenames {node dict} {
	upvar $dict d
	set brname [$node getAttribute BrowseName]
	if {[$node hasAttribute DisplayName]} {
	    set dname [$node getAttribute DisplayName]
	} else {
	    set n [string first ":" $brname]
	    if {$n >= 0} {
		set dname [string range $brname $n+1 end]
	    } else {
		set dname $brname
	    }
	}
	dict set d brname $brname
	dict set d dname $dname
	if {[$node hasAttribute ParentNodeId]} {
	    dict set d parent [$node getAttribute ParentNodeId]
	}
    }

    # Internal helper: add parent to node dict if needed,
    # sets the first reverse reference as parent node and
    # adds dict key "refid" with the node id of the reference.

    proc _ld_fixparent {handle dict} {
	upvar $dict d
	if {![dict exists $d parent]} {
	    foreach r [dict get $d refs] {
		if {![dict get $r forward]} {
		    # Use only hierarchical references as parent,
		    # otherwise leave key "parent" empty.
		    if {[dict get $r type] ni {HasModellingRule
			HasTypeDefinition HasEncoding HasDescription
			GeneratesEvent NonHierarchicalReferences}} {
			dict set d parent [dict get $r nodeid]
			break
		    }
		}
	    }
	    if {![dict exists $d parent]} {
		dict set d parent {}
	    }
	}
	if {![dict exists $d refid]} {
	    set parent [dict get $d parent]
	    foreach r [dict get $d refs] {
		if {[dict get $r nodeid] eq $parent &&
		    ![dict get $r forward]} {
		    set type [dict get $r type]
		    if {![catch {reftype $type} rtype]} {
			set type $rtype
		    }
		    dict set d refid $type
		    break
		}
	    }
	    if {![dict exists $d refid]} {
		dict set d refid {}
	    }
	}
	if {![dict exists $d type]} {
	    switch -- [dict get $d kind] {
		Object - VariableType {
		    foreach r [dict get $d refs] {
			if {[dict get $r type] eq "HasTypeDefinition"} {
			    dict set d type [dict get $r nodeid]
			    break
			}
		    }
		}
	    }
	}
    }

    # Internal helper: fix namespace indices in node info dicts.
    #  vn:    name of dict with node info
    #  vm:    array with from->to mapping
    #  nkeys: list of nodeid fields to fix
    #  pkeys: list of qualified names to fix

    proc _ld_fixns {vn vm nkeys pkeys} {
	upvar $vn n
	upvar $vm m
	foreach k $nkeys {
	    if {[dict exists $n $k]} {
		set v [dict get $n $k]
		foreach mm [array names m] {
		    if {[string match "ns=$mm;*" $v]} {
			regsub -- "ns=$mm;" $v "ns=$m($mm);" v
			dict set n $k $v
			break
		    }
		}
	    }
	}
	foreach k $pkeys {
	    if {[dict exists $n $k]} {
		set v [dict get $n $k]
		foreach mm [array names m] {
		    if {[string match "$mm:*" $v]} {
			regsub -- "$mm:" $v "$m($mm):" v
			dict set n $k $v
			break
		    }
		}
	    }
	}
	# special case for values of ExtensionObjects
	if {[dict exists $n value] && [dict exists $n fixnsv]} {
	    set v [dict get $n value]
	    if {[dict get $n fixnsv] < 0} {
		# scalar
		set t [dict get $v DataType]
		foreach mm [array names m] {
		    if {[string match "ns=$mm;*" $t]} {
			regsub -- "ns=$mm;" $t "ns=$m($mm);" t
			dict set v DataType $t
			dict set n value $v
			break
		    }
		}
	    } else {
		# list
		set nv {}
		foreach el $v {
		    set t [dict get $el DataType]
		    foreach mm [array names m] {
			if {[string match "ns=$mm;*" $t]} {
			    regsub -- "ns=$mm;" $t "ns=$m($mm);" t
			    dict set el DataType $t
			    break
			}
		    }
		    lappend nv $el
		}
		dict set n value $nv
	    }
	}
    }

    # Internal helper: recursively convert XML node to given dict variable.

    proc _ld_xn2d {node dict} {
	upvar $dict d
	if {[$node hasChildNodes]} {
	    set val {}
	    foreach child [$node childNodes] {
		if {[$child nodeType] eq "TEXT_NODE"} {
		    dict set d [$node nodeName] [$child nodeValue]
		    return
		}
		_ld_xn2d $child val
	    }
	} elseif {[$node nodeType] eq "TEXT_NODE"} {
	    set val [$node nodeValue]
	} else {
	    set val {}
	}
	dict set d [$node nodeName] $val
    }

    # Internal helper: fix dictionary for missing stuff in
    # Argument and EnumValueType structures.

    proc _ld_x2d_fix {dict} {
	upvar $dict d
	if {[dict exists $d DataType]} {
	    catch {
		dict set d DataType [dict get $d DataType Identifier]
	    }
	}
	foreach key {Description DisplayName} {
	    set nd {}
	    set lcl ""
	    set txt ""
	    catch {set lcl [dict get $d $key Locale]}
	    catch {set txt [dict get $d $key Text]}
	    dict set nd locale $lcl
	    dict set nd text $txt
	    dict set d $key $nd
	}
    }

    # Internal helper: convert XML string to dict whose value is returned.

    proc _ld_x2d {xml} {
	set d {}
	set doc [dom parse -ignorexmlns -- $xml]
	set root [$doc documentElement]
	set item [$root selectNodes {/ExtensionObject/Body[1]}]
	set item [$item firstChild]
	_ld_xn2d $item d
	set d [dict get $d [dict keys $d]]
	_ld_x2d_fix d
	$doc delete
	return $d
    }

    # Internal helper: like _ld_x2d but processing a list of items.

    proc _ld_x2d_list {xml} {
	set dl {}
	set doc [dom parse -ignorexmlns -- $xml]
	set root [$doc documentElement]
	foreach child [$root selectNodes {ExtensionObject/Body[1]}] {
	    set child [$child firstChild]
	    set d {}
	    _ld_xn2d $child d
	    set d [dict get $d [dict keys $d]]
	    _ld_x2d_fix d
	    lappend dl $d
	}
	$doc delete
	return $dl
    }

    # Internal helper: convert value according to type.

    proc _ld_convval {type node data} {
	switch -glob -- $type {
	    *ByteString {
		# try to convert from base64
		if {![catch {binary decode base64 $data} ndata]} {
		    set data $ndata
		}
	    }
	    *LocalizedText {
		if {$node ne {}} {
		    set lcl ""
		    set txt ""
		    foreach n [$node childNodes] {
			switch -glob -- [$n nodeName] {
			    *Locale {
				catch {
				    set lcl [string trim [[$n firstChild] data]]
				}
			    }
			    *Text {
				catch {
				    set txt [string trim [[$n firstChild] data]]
				}
			    }
			}
		    }
		    dict set dd locale $lcl
		    dict set dd text $txt
		    set data $dd
		}
	    }
	}
	return $data
    }

    # Internal helper: write value attribute into node,
    # on error recursively try super types, if any.

    proc _ld_wrvalue {handle nodeid type value} {
	if {[catch {write $handle $nodeid Value $type $value} err]} {
	    foreach {n b d c r t} [browse $handle $type Inverse HasSubtype] {
		if {![catch {_ld_wrvalue $handle $nodeid $n $value}]} {
		    return
		}
	    }
	    return -code error $err
	}
    }

    # Internal helper: create a node given handle and node dict.

    proc _ld_mknode {handle nsindex dict {mvar {}}} {
	upvar $dict d
	dict with d {
	    set att [attrs default ${kind}Attributes]
	    if {[::info exists dname]} {
		dict set att DisplayName locale {}
		dict set att DisplayName text $dname
	    }
	    if {[::info exists descr]} {
		dict set att Description locale {}
		dict set att Description text $descr
	    }
	    switch -- $kind {
		Object {
		    if {![::info exists type]} {
			set type {}
		    }
		    add $handle Object \
			$nodeid $parent $refid $brname $type $att
		}
		Method {
		    # TBD: in/out args
		    set mname ::opcua::${handle}::impl${nsindex}_${dname}
		    add $handle Method $nodeid $parent $refid \
			{} $brname {} $mname $att
		    if {$mvar ne {}} {
			upvar $mvar mnames
			lappend mnames($mname) $nodeid
		    }
		}
		ReferenceType {
		    dict set att IsAbstract $abstract
		    dict set att Symmetric $symmetric
		    add $handle ReferenceType \
			$nodeid $parent $refid $brname $att
		}
		Variable {
		    if {[::info exists type]} {
			dict set att DataType $type
		    }
		    add $handle Variable $nodeid $parent $refid $brname {} $att
		    # TBD: ArrayDimensions
		    write $handle $nodeid ValueRank Int32 $rank
		    # TBD: more complex values
		    if {[::info exists type] && [::info exists value]} {
			_ld_wrvalue $handle $nodeid $type $value
		    }
		}
		ObjectType {
		    dict set att IsAbstract $abstract
		    add $handle $kind $nodeid $parent $refid $brname $att
		}
		DataType {
		    dict set att IsAbstract $abstract
		    add $handle $kind $nodeid $parent $refid $brname $att
		    # TBD: handle XML <Definition>
		}
		VariableType {
		    if {![::info exists type]} {
			set type {}
		    }
		    dict set att IsAbstract $abstract
		    add $handle VariableType \
			$nodeid $parent $refid $brname $type $att
		}
	    }
	}
    }

    # Load nodeset from XML into a opcua server handle.
    # Optional error reports are written to the caller's variables
    # "evar" (for node information) and "rvar" (for references).
    # Function returns a pairwise list of method names and
    # sublist of nodeids for the respective method name.

    proc loader {xml handle {evar {}} {rvar {}}} {
	if {[info $handle] ne "server"} {
	    return -code error "server handle required"
	}
	if {[catch {
	    package require tdom
	    dom parse -ignorexmlns -- $xml
	} doc]} {
	    return -code error "XML parse failed: $doc"
	}
	set root [$doc documentElement]
	# load XML namespaces
	array set ns {}
	set nscount 1
	foreach nsuri [$root selectNodes /UANodeSet/NamespaceUris/Uri/text()] {
	    set nsuri [$nsuri data]
	    set ns($nscount) $nsuri
	    incr nscount
	}
	# find out our namespace
	set mainns 1
	foreach node [$root selectNodes /UANodeSet/Models/Model] {
	    set uri [$node getAttribute ModelUri]
	    foreach nscount [array names ns] {
		if {$ns($nscount) eq $uri} {
		    set mainns $nscount
		    break
		}
	    }
	    break
	}
	if {![::info exists ns($mainns)]} {
	    $doc delete
	    return -code error "main XML namespace not found"
	}

	set mainnsuri $ns($mainns)
	# load aliases
	array set alias {}
	foreach node [$root selectNodes /UANodeSet/Aliases/Alias] {
	    set an [$node getAttribute Alias]
	    set alias($an) [[$node firstChild] data]
	    unset an
	}
	# provide alias for Argument typically used in InputArguments
	# and OutputArguments
	if {![::info exists alias(Argument)]} {
	    set alias(Argument) [types nodeid Argument]
	}
	# load node information from XML
	array set nodes {}
	foreach {kinds code} {
	    {Object Method} {
	    }
	    ReferenceType {
		dict set n symmetric [_ld_getboolatt $node Symmetric 0]
		dict set n abstract [_ld_getboolatt $node IsAbstract 0]
	    }
	    Variable {
		set vr -2
		if {[$node hasAttribute ValueRank]} {
		    set vr [$node getAttribute ValueRank]
		    set dim 0
		    if {$vr >= 0 && [$node hasAttribute ArrayDimensions]} {
			set dim [$node getAttribute ArrayDimensions]
		    }
		    dict set n dim $dim
		}
		dict set n rank $vr
		if {[$node hasAttribute DataType]} {
		    set type [$node getAttribute DataType]
		    set uty $type
		    if {[::info exists alias($type)]} {
			set uty $alias($type)
		    }
		    dict set n type $uty
		    if {![catch {$node selectNodes Value} v] &&
			![catch {$v firstChild} v]} {
			switch -glob -- [$v nodeName] {
			    *ListOfExtensionObject {
				set xml [$v asXML]
				# Mangle XML to have no namespace prefixes.
				set nn [split [$v nodeName] :]
				set nnn ""
				lassign $nn nns $nnn
				if {$nnn eq ""} {
				    regsub -all "<$nns:" $xml "<" xml
				    regsub -all "</$nns:" $xml "</" xml
				}
				set vd {}
				set nnn 0
				foreach el [_ld_x2d_list $xml] {
				    lappend vd $el
				    if {[dict exists $el DataType]} {
					incr nnn
				    }
				}
				dict set n value $vd
				if {$nnn > 0} {
				    dict set n fixnsv $nnn
				}
			    }
			    *ExtensionObject {
				set xml [$v asXML]
				# Mangle XML to have no namespace prefixes.
				set nn [split [$v nodeName] :]
				set nnn ""
				lassign $nn nns $nnn
				if {$nnn eq ""} {
				    regsub -all "<$nns:" $xml "<" xml
				    regsub -all "</$nns:" $xml "</" xml
				}
				set vd [_ld_x2d $xml]
				if {$vr >= 0} {
				    dict set n value [list $vd]
				    if {[dict exists $vd DataType]} {
					set set n fixnsv 1
				    }
				} else {
				    dict set n value $vd
				    if {[dict exists $vd DataType]} {
					set set n fixnsv -1
				    }
				}
			    }
			    *ListOf* {
				set lv {}
				foreach vv [$v childNodes] {
				    set vtype [$vv nodeName]
				    if {![catch {$vv firstChild} vvv]} {
					if {[catch {$vvv data} data]} {
					    set data {}
					}
					lappend lv \
					    [_ld_convval $vtype $vv $data]
				    } else {
					lappend lv {}
				    }
				}
				dict set n value $lv
			    }
			    default {
				if {![catch {$v firstChild} vv]} {
				    if {[catch {$vv data} data]} {
					set data {}
				    }
				    set vvv [_ld_convval $type $vv $data]
				    if {$vr >= 0} {
					dict set n value [list $vvv]
				    } else {
					dict set n value $vvv
				    }
				}
			    }
			}
		    }
		}
	    }
	    {ObjectType VariableType DataType} {
		dict set n abstract [_ld_getboolatt $node IsAbstract 0]
	    }
	} {
	    foreach kind $kinds {
		foreach node [$root selectNodes /UANodeSet/UA$kind] {
		    dict set n kind $kind
		    set ni [$node getAttribute NodeId]
		    dict set n nodeid $ni
		    if {[$node hasAttribute Description]} {
			dict set n descr [$node getAttribute Description]
		    }
		    _ld_noderefs $node n
		    _ld_nodenames $node n
		    eval $code
		    _ld_fixparent $handle n
		    set nodes($ni) $n
		    unset n ni
		}
	    }
	}
	# done with XML
	$doc delete

	# done with aliases
	unset alias

	# create and find out namespaces
	array set sns {}
	foreach {nscount nsuri} [namespace $handle] {
	    set sns($nsuri) $nscount
	}
	if {[::info exists sns($mainnsuri)]} {
	    return -code error "namespace $mainnsuri exists"
	}
	foreach nscount [array names ns] {
	    set nn $ns($nscount)
	    if {$nscount != $mainns && ![::info exists sns($nn)]} {
		return -code error "namespace $nn is not defined"
	    }
	    unset nn
	}
	set mainns [add S Namespace $mainnsuri]

	# fix namespace indices in nodes array
	foreach {nscount nsuri} [namespace $handle] {
	    set sns($nsuri) $nscount
	}
	array set nsmap {}
	foreach nscount [array names ns] {
	    set nn $ns($nscount)
	    if {$sns($nn) != $nscount} {
		set nsmap($nscount) $sns($nn)
	    }
	    unset nn
	}

	foreach nodeid [array names nodes] {
	    _ld_fixns nodes($nodeid) nsmap {nodeid parent refid type} brname
	    set refs [dict get $nodes($nodeid) refs]
	    set nrefs {}
	    foreach ref $refs {
		_ld_fixns ref nsmap {type nodeid} {}
		lappend nrefs $ref
	    }
	    dict set nodes($nodeid) refs $nrefs
	    unset refs nrefs
	}

	# fix array names of nodes
	array set nnodes {}
	foreach nodeid [array names nodes] {
	    set node $nodes($nodeid)
	    unset nodes($nodeid)
	    set nodeid [dict get $node nodeid]
	    set nnodes($nodeid) $node
	    unset node
	}
	array set nodes [array get nnodes]
	unset nnodes

	# prime cache of existing nodeids
	array set exists {}
	foreach type [reftype] {
	    set exists([reftype $type]) 1
	}
	foreach type [types basic] {
	    set exists([types nodeid $type]) 1
	}

	# create nodes
	set max [array size nodes]
	set count 0
	array set refs {}
	array set errnodes {}
	array set meths {}
	while {$count < $max} {
	    foreach nodeid [array names nodes] {
		set node $nodes($nodeid)
		set parent [dict get $node parent]
		set nopaskip 1
		if {$parent ne {} && ![::info exists exists($parent)]} {
		    # Query server for parent nodeid.
		    if {![catch {read $handle $parent NodeClass}]} {
			set exists($parent) 1
		    } else {
			set nopaskip 0
		    }
		}
		set noreskip 1
		if {[dict exists $node refid]} {
		    set refid [dict get $node refid]
		    if {$refid ne {} && ![::info exists exists($refid)]} {
			# Query server for reference nodeid.
			if {![catch {read $handle $refid NodeClass}]} {
			    set exists($refid) 1
			} else {
			    set noreskip 0
			}
		    }
		}
		set notyskip 1
		if {[dict exists $node type]} {
		    set typeid [dict get $node type]
		    if {![::info exists exists($typeid)]} {
			# Query server for type nodeid.
			if {![catch {read $handle $typeid NodeClass}]} {
			    set exists($typeid) 1
			} else {
			    set notyskip 0
			}
		    }
		}
		if {$nopaskip && $noreskip && $notyskip} {
		    # Create node.
		    if {[catch {
			_ld_mknode $handle $mainns nodes($nodeid) meths
		    } err]} {
			set errnodes($nodeid) $nodes($nodeid)
			dict set errnodes($nodeid) error $err
			# Check and record node's existence.
			set nex [catch {read $handle $nodeid NodeClass}]
			dict set errnodes($nodeid) exists [expr {!$nex}]
			if {!$nex} {
			    set exists($nodeid) 1
			}
		    } else {
			set exists($nodeid) 1
		    }
		    unset nodes($nodeid)
		    # Create list of references to be made later.
		    set nrefs {}
		    foreach ref [dict get $node refs] {
			if {[dict get $ref nodeid] eq $parent} {
			    continue
			}
			lappend nrefs $ref
		    }
		    if {[llength $nrefs]} {
			set refs($nodeid) $nrefs
		    }
		}
	    }
	    incr count
	}

	foreach nodeid [array names nodes] {
	    set errnodes($nodeid) $nodes($nodeid)
	    dict set errnodes($nodeid) error {some required node does not exist}
	    unset nodes($nodeid)
	}

	# create references
	array set unrefs {}
	foreach nodeid [array names refs] {
	    foreach ref $refs($nodeid) {
		set refid [dict get $ref nodeid]
		if {![::info exists exists($refid)]} {
		    # Query server for reference nodeid.
		    if {![catch {read $handle $refid NodeClass}]} {
			set exists($refid) 1
		    }
		}
		if {[::info exists exists($refid)] &&
		    ![::info exists nodes($refid)] &&
		    [::info exists exists($nodeid)]} {
		    # Create reference.
		    if {[catch {add $handle Reference $nodeid \
				    [dict get $ref type] \
				    $refid [dict get $ref forward]} err]} {
			if {![string match "*already defined" $err]} {
			    return -code error $err
			}
		    }
		} else {
		    set unrefs($refid) $ref
		}
	    }
	    unset refs($nodeid)
	}

	# TBD: retry failed "opcua write" operations with
	# generated types, however better fix would be to
	# process XML <Definition> in DataType XML nodes.
	gentypes $handle
	foreach nodeid [array names errnodes] {
	    if {[::info exists exists($nodeid)]} {
		set node $errnodes($nodeid)
		if {[dict exists $node type] && [dict exists $node value]} {
		    if {![catch {
			_ld_wrvalue $handle $nodeid [dict get $node type] \
			    [dict get $node value]
		    } err]} {
			unset errnodes($nodeid)
		    }
		}
	    }
	}

	# leave error reports for caller, if requested
	if {$evar ne {}} {
	    upvar $evar ev
	    set ev [array get errnodes]
	}
	if {$rvar ne {}} {
	    upvar $rvar rv
	    set rv [array get unrefs]
	}

	# cleanup namespace folder, it seems that open62541 makes
	# own dynamic nodes on "opcua add Namespace".
	catch {
	    set nsf [translate $handle [root] / Objects / Server / \
			 Namespaces / ${mainns}:${mainnsuri}]
	    foreach nodeid [children $handle [lindex $nsf 0]] {
		if {![::info exists exists($nodeid)]} {
		    delete $handle Node $nodeid 1
		}
	    }
	}

	# try to add method output types to newly created methods
	foreach mn [array names meths] {
	    foreach nodeid $meths($mn) {
		catch {
		    set oa [translate $handle $nodeid \
				HasProperty OutputArguments]
		    set oid [lindex $oa 0]
		    # currently only the first element can be handled
		    set rfield [lindex [read $handle $oid] 0]
		    methods $handle $nodeid [dict get $rfield DataType]
		}
	    }
	}

	# return method names and nodeids
	return [array get meths]
    }

    # Make some procs visible in opcua ensemble.

    apply [list ns {
	set cmds [::namespace ensemble configure $ns -subcommands]
	lappend cmds tree ptree children parent genstubs gentypes deftypes
	lappend cmds loader
	::namespace ensemble configure $ns -subcommands $cmds
    } [::namespace current]] [::namespace current]

}

} UAM;

/*
 * Structure representing a method invocation. This is used for
 * both method callbacks and data source callbacks.
 */

typedef struct UAQ {
    struct UAH *uah;			/* Containing server handle. */
    const UA_DataType *outType;		/* Output data type or NULL. */
    int nCmdObjs;			/* For the Tcl callback. */
    Tcl_Obj **cmdObjs;			/* Ditto. */
    int nSavedCmdObjs;			/* Ditto. */
    Tcl_Obj **savedCmdObjs;		/* Ditto. */
    struct UAQ **backRef;		/* For delete within callback. */
} UAQ;

/*
 * Structure representing an OPC/UA client or server.
 */

typedef struct UAH {

					  UA_ReferenceDescription *ref);
static Tcl_Obj *	DecodeToObj(UAI *uai, const UA_DataType *type,
				    const void *data, int depth);
static void *		EncodeFromObj(Tcl_Interp *interp, UAI *uai, UAH *uah,
				      const UA_DataType *type,
				      const void *preset, Tcl_Obj *obj,
				      int depth);
static UA_Argument *	GetMethodArgs(Tcl_Interp *interp, UAH *uah, int simple,
				      Tcl_Obj *obj, int *numRet);
static UA_StatusCode	MethodInvoke(UA_Server *server,
				     const UA_NodeId *sessionId,
				     void *sessionContext,
				     const UA_NodeId *methodId,
				     void *methodContext,
				     const UA_NodeId *objectId,

 */

static void
ReleaseMethodsEtc(UAH *uah, int killProcs)
{
    Tcl_HashEntry *hPtr;
    Tcl_HashSearch search;

    int i;

    hPtr = Tcl_FirstHashEntry(&uah->meths, &search);
    while (hPtr != NULL) {
	UAQ *meth = (UAQ *) Tcl_GetHashValue(hPtr);

	if (meth->backRef != NULL) {
	    *(meth->backRef) = NULL;
	    meth->backRef = NULL;
	}
	Tcl_DeleteHashEntry(hPtr);
	if (killProcs) {
	    Tcl_Obj *objs[4];

	    /*
	     * Evaluates to "::namespace eval NS { ::rename P {} }"
	     * ignoring errors.

	    for (i = 0; i < 4; i++) {
		Tcl_DecrRefCount(objs[i]);
	    }
	}
	for (i = 0; i < meth->nCmdObjs; i++) {
	    Tcl_DecrRefCount(meth->cmdObjs[i]);
	}
	if (meth->cmdObjs != NULL) {
	    ckfree((char *) meth->cmdObjs);
	}
	ckfree((char *) meth);
	hPtr = Tcl_NextHashEntry(&search);
    }
    hPtr = Tcl_FirstHashEntry(&uah->dsrcs, &search);
    while (hPtr != NULL) {
	UAQ *dsrc = (UAQ *) Tcl_GetHashValue(hPtr);

	if (dsrc->backRef != NULL) {
	    *(dsrc->backRef) = NULL;
	    dsrc->backRef = NULL;
	}
	Tcl_DeleteHashEntry(hPtr);
	for (i = 0; i < dsrc->nCmdObjs; i++) {
	    Tcl_DecrRefCount(dsrc->cmdObjs[i]);
	}
	if (dsrc->cmdObjs != NULL) {
	    ckfree((char *) dsrc->cmdObjs);
	}
	ckfree((char *) dsrc);
	hPtr = Tcl_NextHashEntry(&search);
    }
}

/*
 *-------------------------------------------------------------------------

ReleaseTypes(UAH *uah, int all)
{
    UAI *uai = uah->uai;
    size_t i, j;
    Tcl_Obj *obj;

    if (uah->types != NULL) {
	Tcl_HashEntry *hPtr;
	Tcl_HashSearch search;

	hPtr = Tcl_FirstHashEntry(&uah->meths, &search);
	while (hPtr != NULL) {
	    UAQ *uaq = (UAQ *) Tcl_GetHashValue(hPtr);

	    if (uaq->outType != NULL) {
		j = uaq->outType - uah->types;
		if ((j >= 0) && (j < uah->typesSize)) {
		    uaq->outType = NULL;
		}
	    }
	    hPtr = Tcl_NextHashEntry(&search);
	}
	for (i = 0; i < uah->typesSize; i++) {
	    for (j = 0; j < uah->types[i].membersSize; j++) {
		if (uah->types[i].members[j].memberName != NULL) {
		    obj = GetSymObj(uai, uah->types[i].members[j].memberName,
				    NULL);
		    Tcl_DecrRefCount(obj);
		}

 */

static Tcl_Obj *
GetSymObj(UAI *uai, const char *string, char **keyRet)
{
    Tcl_Obj *obj;
    Tcl_HashEntry *hPtr;
    int isNew;

    hPtr = Tcl_CreateHashEntry(&uai->syms, string, &isNew);
    if (isNew) {
	obj = Tcl_NewStringObj(string, -1);
	Tcl_IncrRefCount(obj);
	Tcl_SetHashValue(hPtr, (ClientData) obj);
    } else {
	obj = (Tcl_Obj *) Tcl_GetHashValue(hPtr);
    }
    if (keyRet != NULL) {

    }
    if (type == &UA_TYPES[UA_TYPES_UINT64]) {
	return Tcl_NewWideIntObj(((Tcl_WideInt *) data)[0]);
    }
    if (type == &UA_TYPES[UA_TYPES_FLOAT]) {
	return Tcl_NewDoubleObj(((float *) data)[0]);
    }
    if ((type == &UA_TYPES[UA_TYPES_DOUBLE]) ||
	(type == &UA_TYPES[UA_TYPES_DURATION])) {
	return Tcl_NewDoubleObj(((double *) data)[0]);
    }
    if ((type == &UA_TYPES[UA_TYPES_STRING]) ||
	(type == &UA_TYPES[UA_TYPES_LOCALEID])) {
	UA_String *v = (UA_String *) data;

	if (v->data != NULL) {
	    return Tcl_NewStringObj((char *) v->data, v->length);
	}
	return Tcl_NewObj();
    }
    if ((type == &UA_TYPES[UA_TYPES_DATETIME]) ||
	(type == &UA_TYPES[UA_TYPES_UTCTIME])) {
	UA_DateTime t = ((UA_DateTime *) data)[0];

	return Tcl_NewWideIntObj((Tcl_WideInt) t);
    }
    if (type == &UA_TYPES[UA_TYPES_GUID]) {
	UA_Guid *v = (UA_Guid *) data;
	char buffer[64];

	obj = Tcl_NewStringObj(PrintQualifiedName(v, &ds), -1);
	Tcl_DStringFree(&ds);
	return obj;
    }
    if (type == &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]) {
	UA_LocalizedText *v = (UA_LocalizedText *) data;
	Tcl_Obj *obj, *dict = Tcl_NewDictObj();

	if (v->locale.data != NULL) {
	    obj = Tcl_NewStringObj((char * ) v->locale.data,
				   v->locale.length);
	} else {
	    obj = Tcl_NewObj();
	}
	Tcl_DictObjPut(NULL, dict, GetSymObj(uai, "locale", NULL), obj);
	if (v->text.data != NULL) {
	    obj = Tcl_NewStringObj((char * ) v->text.data,
				   v->text.length);
	} else {
	    obj = Tcl_NewObj();
	}






	Tcl_DictObjPut(NULL, dict, GetSymObj(uai, "text", NULL), obj);











	return dict;
    }
    if (type == &UA_TYPES[UA_TYPES_DATAVALUE]) {
	UA_DataValue *v = (UA_DataValue *) data;
	Tcl_Obj *dict = Tcl_NewDictObj();

	if (v->hasValue || empty) {
	    Tcl_Obj *vv;

	double v;

	if (Tcl_GetDoubleFromObj(interp, obj, &v) != TCL_OK) {
	    goto error;
	}
	value = UA_new(type);
	((UA_Float *) value)[0] = v;
    } else if ((type == &UA_TYPES[UA_TYPES_DOUBLE]) ||
	       (type == &UA_TYPES[UA_TYPES_DURATION])) {
	double v;

	if (Tcl_GetDoubleFromObj(interp, obj, &v) != TCL_OK) {
	    goto error;
	}
	value = UA_new(type);
	((UA_Double *) value)[0] = v;
    } else if ((type == &UA_TYPES[UA_TYPES_STRING]) ||
	       (type == &UA_TYPES[UA_TYPES_LOCALEID])) {
	UA_String s = UA_String_fromChars(Tcl_GetString(obj));

	value = UA_new(type);
	UA_String_copy(&s, (UA_String *) value);
    } else if ((type == &UA_TYPES[UA_TYPES_DATETIME]) ||
	       (type == &UA_TYPES[UA_TYPES_UTCTIME])) {
	Tcl_WideInt v;
#if (UA_OPEN62541_VER_MAJOR >= 1)
	int x[6];
	char ch;

	if ((sscanf(Tcl_GetString(obj), "%4d-%2d-%2dT%2d:%2d:%2d%c",
		    x + 0, x + 1, x + 2, x + 4, x + 5, x + 6, &ch) == 7) &&
	    (ch == 'Z')) {
	    UA_DateTimeStruct dts;
	    UA_DateTime dt;

	    memset(&dts, 0, sizeof(dts));
	    dts.year = x[0];
	    dts.month = x[1];
	    dts.day = x[2];
	    dts.hour = x[3];
	    dts.min = x[4];
	    dts.sec = x[5];
	    dt = UA_DateTime_fromStruct(dts);
	    v = dt;
	    goto haveDateTime;
	}
#endif
	if (Tcl_GetWideIntFromObj(interp, obj, &v) != TCL_OK) {
	    goto error;
	}
#if (UA_OPEN62541_VER_MAJOR >= 1)
haveDateTime:
#endif
	value = UA_new(type);
	((UA_DateTime *) value)[0] = (UA_DateTime) v;
    } else if (type == &UA_TYPES[UA_TYPES_GUID]) {
	UA_Guid *g;
	int d[11];

	if (sscanf(Tcl_GetString(obj),

	if (ParseQualifiedName(interp, (UA_QualifiedName *) value,
			       Tcl_GetString(obj)) == NULL) {
	    UA_delete(value, type);
	    value = NULL;
	    goto error;
	}
    } else if (type == &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]) {
	UA_String s;
	Tcl_Obj *locale = NULL, *text = NULL;

	Tcl_DictObjGet(NULL, obj, GetSymObj(uai, "locale", NULL), &locale);
	Tcl_DictObjGet(NULL, obj, GetSymObj(uai, "text", NULL), &text);

	if (text == NULL) {


	    text = obj;
	}
	value = UA_new(type);


	if (locale != NULL) {
	    s = UA_String_fromChars(Tcl_GetString(locale));
	    UA_String_copy(&s, &((UA_LocalizedText *) value)->locale);
	}
	s = UA_String_fromChars(Tcl_GetString(text));
	UA_String_copy(&s, &((UA_LocalizedText *) value)->text);

    } else if (type == &UA_TYPES[UA_TYPES_VARIANT]) {
	int n, j;
	Tcl_Obj **elem;
	const UA_DataType *vtype = NULL;
	void *vdata = NULL;

	if (Tcl_ListObjGetElements(interp, obj, &n, &elem) != TCL_OK) {
	    goto error;
	}
	if (n == 1) {
	    /* Fallback to String type. */
	    vtype = FindType(uai, uah, 0, "String");
	    goto writeSingle;
	}
	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;
	    if (n == 1) {
writeSingle:
		vdata = EncodeFromObj(interp, uai, uah, vtype,
				      NULL, elem[0], depth + 1);
	    } else {
		vdata = UA_Array_new(n, vtype);
		if (vdata == NULL) {
		    Tcl_SetResult(interp, "out of memory", TCL_STATIC);
		    goto error;

	if (vtype != NULL) {
	    if (n == 1) {
		UA_Variant_setScalar(value, vdata, vtype);
	    } else if (n > 1) {
		UA_Variant_setArray(value, vdata, n, vtype);
	    }
	}



































    } else if (type->membersSize > 0) {
	int i;
	void *data;

	value = UA_new(type);
	if (preset != NULL) {
	    UA_copy(preset, value, type);

 * Side effects:
 *	Allocates memory for UA_Argument array.
 *
 *-------------------------------------------------------------------------
 */

static UA_Argument *
GetMethodArgs(Tcl_Interp *interp, UAH *uah, int simple,
	      Tcl_Obj *obj, int *numRet)
{
    UAI *uai = uah->uai;
    int i, n;
    Tcl_Obj **elem;
    UA_Argument *a;
    char *p;

    *numRet = -1;	/* Preset to error. */
    if (Tcl_ListObjGetElements(interp, obj, &n, &elem) != TCL_OK) {
	return NULL;
    }
    if (n == 0) {
	*numRet = 0;	/* Good case. */
	return NULL;
    }
    if (!simple) {
	a = UA_Array_new(n / 2, &UA_TYPES[UA_TYPES_ARGUMENT]);
	for (i = 0, p = (char *) a; i < n; i++) {
	    UA_Argument *v;

	    v = EncodeFromObj(interp, uai, uah, &UA_TYPES[UA_TYPES_ARGUMENT],
			      NULL, elem[i], 0);
	    if (v == NULL) {
		UA_Array_delete(a, n, &UA_TYPES[UA_TYPES_ARGUMENT]);
		return NULL;
	    }
	    UA_copy(v, p, &UA_TYPES[UA_TYPES_ARGUMENT]);
	    p += UA_TYPES[UA_TYPES_ARGUMENT].memSize;
	}
	*numRet = n;
	return a;
    }
    if (n % 2 != 0) {
	Tcl_SetResult(interp, "need even number of elements", TCL_STATIC);
	return NULL;
    }
    a = UA_Array_new(n / 2, &UA_TYPES[UA_TYPES_ARGUMENT]);
    for (i = 0, p = (char *) a; i < n; i += 2) {
	UA_Argument *v;
	Tcl_HashEntry *hPtr;
	char *tn;
	UA_String s;

	v = (UA_Argument *) p;
	v->valueRank = -2;	/* Allow scalar or array. */

	/* Abbrevation: allow names from types hash table. */
	tn = Tcl_GetString(elem[0]);
	if (*tn == '*') {
	    v->valueRank = 0;	/* Force to array. */
	    tn++;
	}
	hPtr = Tcl_FindHashEntry(&uai->types, tn);
	if (hPtr != NULL) {
	    UA_DataType *type = (UA_DataType *) Tcl_GetHashValue(hPtr);

	    UA_NodeId_copy(&type->typeId, &v->dataType);
	} else if (ParseTypeOrNodeId(interp, uah, &v->dataType, tn) == NULL) {
	    UA_Array_delete(a, n / 2, &UA_TYPES[UA_TYPES_ARGUMENT]);
	    return NULL;
	}
	s = UA_String_fromChars(Tcl_GetString(elem[1]));
	UA_String_copy(&s, &v->name);
	p += UA_TYPES[UA_TYPES_ARGUMENT].memSize;
    }
    *numRet = n / 2;
    return a;
}

/*
 *-------------------------------------------------------------------------

    Tcl_DStringFree(&ds);
    for (i = 0; i < inputSize; i++) {
	const UA_Variant *v = &input[i];

	Tcl_ListObjAppendElement(NULL, list,
	    DecodeToObj(uai, &UA_TYPES[UA_TYPES_VARIANT], v, 0));
    }
    meth->backRef = &meth;
    Tcl_IncrRefCount(list);
    ret = Tcl_GlobalEvalObj(interp, list);
    Tcl_DecrRefCount(list);
    if (meth == NULL) {
	/*
	 * Node was deleted, we're finished.
	 */
	goto done;
    }
    meth->backRef = NULL;

    /*
     * Special cases:
     *   TCL_BREAK makes into an array result.
     *   When there's no output type, the result is void.
     */
    if ((meth->outType == NULL) && ((ret == TCL_BREAK) || (ret == TCL_OK))) {
	/* Void result. */

	    Tcl_DecrRefCount(cmdObjs[i]);
	}
	ckfree((char *) cmdObjs);
    } else {
	meth->nCmdObjs = nCmdObjs;
	meth->cmdObjs = cmdObjs;
    }
done:
    Tcl_RestoreInterpState(interp, state);
    Tcl_Release(interp);
    Tcl_Release(uah);
    Tcl_Release(uai);
    return uaret;
}


    dsrc->nCmdObjs = 0;
    dsrc->cmdObjs = NULL;
    list = Tcl_NewListObj(nCmdObjs, cmdObjs);
    p = PrintNodeId(nodeId, &ds);
    Tcl_ListObjAppendElement(NULL, list, Tcl_NewStringObj(p, -1));
    Tcl_DStringFree(&ds);
    Tcl_ListObjAppendElement(NULL, list, Tcl_NewStringObj("read", -1));

    dsrc->backRef = &dsrc;
    Tcl_IncrRefCount(list);
    ret = Tcl_GlobalEvalObj(interp, list);
    Tcl_DecrRefCount(list);
    if (dsrc == NULL) {
	/*
	 * Node was deleted, we're finished.
	 */
	goto done;
    }
    dsrc->backRef = NULL;

    if ((ret == TCL_BREAK) || (ret == TCL_OK)) {
	if (Tcl_ListObjGetElements(interp, Tcl_GetObjResult(interp),
				   &n, &elem) != TCL_OK) {
	    ret = TCL_ERROR;
	    goto error;
	}
	/*

	    Tcl_DecrRefCount(cmdObjs[i]);
	}
	ckfree((char *) cmdObjs);
    } else {
	dsrc->nCmdObjs = nCmdObjs;
	dsrc->cmdObjs = cmdObjs;
    }
done:
    Tcl_RestoreInterpState(interp, state);
    Tcl_Release(interp);
    Tcl_Release(uah);
    Tcl_Release(uai);
    return uaret;
}

	  int objc, Tcl_Obj * const objv[])
{
    UAI *uai = (UAI *) clientData;
    UAH *uah;
    UA_Client *cl = NULL;
    UA_Server *sv = NULL;
    Tcl_HashEntry *hPtr = NULL;
    int isNew, isServer = 0, port;
    char *pname, name[16];
    Tcl_DString ds;
    UA_ServerConfig *svcfg = NULL;
    static const char *typeNames[] = { "client", "server", NULL };

    if ((objc != 1) && (objc != 3) && (objc > 4)) {
	Tcl_WrongNumArgs(interp, 1, objv, "?type ?port? name?");

		Tcl_WrongNumArgs(interp, 1, objv, "server port name");
		return TCL_ERROR;
	    }
	    if (Tcl_GetIntFromObj(interp, objv[2], &port) != TCL_OK) {
		return TCL_ERROR;
	    }
	    hPtr = Tcl_CreateHashEntry(&uai->handles,
				       Tcl_GetString(objv[3]), &isNew);
	} else if (objc != 3) {
	    Tcl_WrongNumArgs(interp, 1, objv, "client name");
	    return TCL_ERROR;
	} else {
	    hPtr = Tcl_CreateHashEntry(&uai->handles,
				       Tcl_GetString(objv[2]), &isNew);
	}
	if (!isNew) {
	    Tcl_SetResult(interp, "name already in use", TCL_STATIC);
	    ReportError(interp, uai, NULL, 0);
	    return TCL_ERROR;
	}
    }
    if (isServer) {
#if (UA_OPEN62541_VER_MAJOR >= 1)

    memset(&uah->typesArray, 0, sizeof(uah->typesArray));
#endif
    Tcl_InitHashTable(&uah->subs, TCL_ONE_WORD_KEYS);
    Tcl_InitHashTable(&uah->meths, TCL_STRING_KEYS);
    Tcl_InitHashTable(&uah->dsrcs, TCL_STRING_KEYS);
    if (hPtr == NULL) {
	sprintf(name, "ua%d", uai->idCount++);
	hPtr = Tcl_CreateHashEntry(&uai->handles, name, &isNew);
	if (!isNew) {
	    UAH *oldh = (UAH *) Tcl_GetHashValue(hPtr);

	    ReleaseTypes(oldh, 1);
	    ReleaseMethodsEtc(oldh, 1);
	    if (oldh->client != NULL) {
		DisconnectClient(oldh);
		if (oldh->client != NULL) {

    UAH *uah;
    Tcl_HashEntry *hPtr;
    UA_StatusCode uaret;
    UA_NodeId nodeid;
    const UA_DataType *type;
    UA_WriteValue wv;
    void *value;
    int attr, idx, n, j;
    UA_Int32 vr;

    if ((objc < 5) || (objc > 6)) {
	Tcl_WrongNumArgs(interp, 1, objv,
			 "handle nodeid ?attr? type value");
	return TCL_ERROR;
    }
    hPtr = Tcl_FindHashEntry(&uai->handles, Tcl_GetString(objv[1]));
    if (hPtr != NULL) {
	uah = (UAH *) Tcl_GetHashValue(hPtr);
    } else {
	Tcl_SetResult(interp, "handle not found", TCL_STATIC);
	ReportError(interp, uai, NULL, 0);
	return TCL_ERROR;
    }
    if (ParseNodeId(interp, &nodeid, Tcl_GetString(objv[2])) == NULL) {
	return TCL_ERROR;
    }
    if (objc > 5) {
	if (Tcl_GetIndexFromObj(interp, objv[3], attrNames, "attr", 0,
				&attr) != TCL_OK) {
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}
	/* UA_AttributeId is 1-based */
	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;
    }
    if (attr == UA_ATTRIBUTEID_VALUE) {
	if (uah->client != NULL) {
	    uaret = UA_Client_readValueRankAttribute(uah->client, nodeid, &vr);
	} else {
	    uaret = UA_Server_readValueRank(uah->server, nodeid, &vr);
	}
	if (uaret != UA_STATUSCODE_GOOD) {
	    Tcl_SetResult(interp, "cannot get value rank", TCL_STATIC);
	    ReportError(interp, uai, "ReadValueRank", uaret);
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}
    } else {
	vr = -2;
    }
    idx++;
    if (vr >= 0) {
	/* An array, thus process a list. */
	void *vdata;
	Tcl_Obj **elem;

	if (Tcl_ListObjGetElements(interp, objv[idx], &n, &elem) != TCL_OK) {
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}
	vdata = UA_Array_new(n, type);
	if (vdata == NULL) {
	    Tcl_SetResult(interp, "out of memory", TCL_STATIC);
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}
	for (j = 0; j < n; j++) {
	    void *vv = EncodeFromObj(interp, uai, uah, type, NULL, elem[j], 0);

	    if (vv == NULL) {
		UA_Array_delete(vdata, n, type);
		goto error;
	    }
	    if (UA_copy(vv, (char *) vdata + j * type->memSize, type)
		!= UA_STATUSCODE_GOOD) {
		Tcl_SetResult(interp, "copy operation failed", TCL_STATIC);
		UA_Array_delete(vdata, n, type);
		goto error;
	    }
	}
	if (uah->client != NULL) {
	    const UA_DataType *vtype = &UA_TYPES[UA_TYPES_VARIANT];

	    value = UA_new(vtype);
	    if (value == NULL) {
		UA_Array_delete(vdata, n, type);
		Tcl_SetResult(interp, "out of memory", TCL_STATIC);
		UA_NodeId_deleteMembers(&nodeid);
		return TCL_ERROR;
	    }
	    UA_Variant_setArray(value, vdata, n, type);
	    type = vtype;
	} else {
	    value = vdata;
	}
    } else {
	value = EncodeFromObj(interp, uai, uah, type, NULL, objv[idx], 0);
	if (value == NULL) {
error:
	    ReportError(interp, uai, NULL, 0);
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}
    }
    if (uah->client != NULL) {
	uaret = __UA_Client_writeAttribute(uah->client, &nodeid,
					   (UA_AttributeId) attr,
					   value, type);
    } else {
	UA_WriteValue_init(&wv);
	wv.nodeId = nodeid;
	wv.attributeId = (UA_AttributeId) attr;
	wv.value.hasValue = 1;
	if (vr >= 0) {
	    UA_Variant_setArray(&wv.value.value, value, n, type);
	} else {
	    UA_Variant_setScalar(&wv.value.value, value, type);
	}
	uaret = UA_Server_write(uah->server, &wv);
    }
    if (uaret != UA_STATUSCODE_GOOD) {
	ReportError(interp, uai, "WriteAttribute", uaret);
    }
    if (uah->client != NULL) {
	UA_NodeId_deleteMembers(&nodeid);

	    sub->prio = prio;
	    sub->enable = csrq.publishingEnabled;
	    Tcl_InitHashTable(&sub->monitors, TCL_ONE_WORD_KEYS);
	    csr = UA_Client_Subscriptions_create(uah->client, csrq, sub,
						 ChangeSubCB, ReleaseSubCB);
	    uaret = csr.responseHeader.serviceResult;
	    if (uaret == UA_STATUSCODE_GOOD) {
		int isNew;

		sub->subid = csr.subscriptionId;
		sub->interval = csr.revisedPublishingInterval;
		sub->ltCount = csr.revisedLifetimeCount;
		sub->kaCount = csr.revisedMaxKeepAliveCount;
		hPtr = Tcl_CreateHashEntry(&uah->subs,
					   INT2PTR(sub->subid), &isNew);
		if (!isNew) {
		    UAS *oldsub = (UAS *) Tcl_GetHashValue(hPtr);
		    Tcl_HashEntry *hPtr2;
		    Tcl_HashSearch search;

		    hPtr2 = Tcl_FirstHashEntry(&oldsub->monitors, &search);
		    while (hPtr2 != NULL) {
			UAM *mon = (UAM *) Tcl_GetHashValue(hPtr2);

	    if (mon->cmdObjs != NULL) {
		ckfree((char *) mon->cmdObjs);
	    }
	    ckfree((char *) mon);
	    ReportError(interp, uai, "CreateMonitor", uaret);
	    return TCL_ERROR;
	} else {
	    int isNew;

	    mon->interval = mon->interval;
	    mon->monid = mr.monitoredItemId;
	    hPtr = Tcl_CreateHashEntry(&sub->monitors,
				       INT2PTR(mon->monid), &isNew);
	    if (!isNew) {
		UAM *oldmon = (UAM *) Tcl_GetHashValue(hPtr);

		DeleteMonCB(uah->client, subid, sub, oldmon->monid, oldmon);
	    }
	    Tcl_SetHashValue(hPtr, mon);
	    Tcl_SetObjResult(interp, Tcl_NewIntObj(mon->monid));
	}

    UA_StatusCode uaret;
    char *p;
    static const char *kindNames[] = {
	"Namespace",
	"Variable", "VariableType", "Object",
	"View", "ObjectType", "DataType", "ReferenceType",
	"Reference", "Method",
	"SimpleMethod",
	NULL
    };
    enum NodeKind {
	NK_Namespace,
	NK_Variable, NK_VariableType, NK_Object,
	NK_View, NK_ObjectType, NK_DataType, NK_ReferenceType,
	NK_Reference, NK_Method,
	NK_SimpleMethod
    };

    if (objc < 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "handle kind ...");
	return TCL_ERROR;
    }
    hPtr = Tcl_FindHashEntry(&uai->handles, Tcl_GetString(objv[1]));

	/* At least preset the DisplayName attribute from browse name. */
	if (a->displayName.text.length == 0) {
	    UA_deleteMembers(&a->displayName.text,
			     &UA_TYPES[UA_TYPES_STRING]);
	    UA_String_copy(&qn.name, &a->displayName.text);
	}
	if (objc > 9) {
	    int nCmdObjs, i, isNew;
	    Tcl_Obj **cmdObjs;
	    UAQ *uaq;
	    static const UA_DataSource dsrc = {
		DataSourceRead, DataSourceWrite
	    };

	    if (Tcl_ListObjGetElements(interp, objv[9], &nCmdObjs, &cmdObjs)

	     */
	    uaq = (UAQ *) ckalloc(sizeof(UAQ));
	    memset(uaq, 0, sizeof(UAQ));
	    uaq->uah = NULL;
	    uaq->outType = NULL;
	    uaq->nCmdObjs = uaq->nSavedCmdObjs = 0;
	    uaq->cmdObjs = uaq->savedCmdObjs = NULL;
	    uaq->backRef = NULL;
	    uaret = UA_Server_addDataSourceVariableNode(uah->server,
			nodeid, parent, refid, qn, typeid,
			*((const UA_VariableAttributes *) a), dsrc, uaq,
			&retid);
	    if (uaret != UA_STATUSCODE_GOOD) {



		ckfree((char *) uaq);
	    } else {
		Tcl_DString ds;
		char *p;

		p = PrintNodeId(&retid, &ds);
		hPtr = Tcl_CreateHashEntry(&uah->dsrcs, p, &isNew);
		Tcl_DStringFree(&ds);
		if (!isNew) {
		    UAQ *oldq = (UAQ *) Tcl_GetHashValue(hPtr);

		    if (oldq->backRef != NULL) {
			*(oldq->backRef) = NULL;
			oldq->backRef = NULL;
		    }
		    if (oldq->cmdObjs != NULL) {
			for (i = 0; i < oldq->nSavedCmdObjs; i++) {
			    Tcl_DecrRefCount(oldq->savedCmdObjs[i]);
			}
			ckfree((char *) oldq->cmdObjs);
		    }
		    if ((oldq->savedCmdObjs != NULL) &&
			(oldq->savedCmdObjs != oldq->cmdObjs)) {
			for (i = 0; i < oldq->nSavedCmdObjs; i++) {
			    Tcl_DecrRefCount(oldq->savedCmdObjs[i]);
			}
			oldq->nSavedCmdObjs = 0;
			oldq->savedCmdObjs = NULL;
		    }
		    oldq->nCmdObjs = 0;
		    oldq->cmdObjs = NULL;
		    ckfree((char *) oldq);
		}
		Tcl_SetHashValue(hPtr, (ClientData) uaq);
		/*
		 * Initialize the callback information.
		 */
		uaq->uah = uah;

refError:
	UA_NodeId_deleteMembers(&nodeid);
	UA_NodeId_deleteMembers(&refid);
	UA_NodeId_deleteMembers(&destid);
	break;
    }

    case NK_Method:
    case NK_SimpleMethod: {
	UA_NodeId nodeid, parent, refid, retid;
	UA_QualifiedName qn;
	const UA_MethodAttributes *a0 = &UA_MethodAttributes_default;
	UA_MethodAttributes *a = NULL;
	int ian, oan, nCmdObjs;
	Tcl_Obj **cmdObjs;
	UA_Argument *ia = NULL, *oa = NULL;

	    goto methError;
	}
	p = Tcl_GetString(objv[5]);
	if ((*p != '\0') &&
	    (ParseRefTypeOrNodeId(interp, uai, &refid, p) == NULL)) {
	    goto methError;
	}
	oa = GetMethodArgs(interp, uah, kind == NK_SimpleMethod, objv[6], &oan);
	if (oan < 0) {
	    goto methError;
	}
	if (ParseQualifiedName(interp, &qn, Tcl_GetString(objv[7])) == NULL) {
	    goto methError;
	}
	ia = GetMethodArgs(interp, uah, kind == NK_SimpleMethod, objv[8], &ian);
	if (ian < 0) {
	    goto methError;
	}
	if (Tcl_ListObjGetElements(interp, objv[9], &nCmdObjs, &cmdObjs)
	    != TCL_OK) {
	    goto methError;
	}

	}
	/* At least preset the DisplayName attribute from browse name. */
	if (a->displayName.text.length == 0) {
	    UA_deleteMembers(&a->displayName.text,
			     &UA_TYPES[UA_TYPES_STRING]);
	    UA_String_copy(&qn.name, &a->displayName.text);
	}
	if ((kind == NK_SimpleMethod) && (oan > 1)) {
	    Tcl_SetResult(interp, "only one output argument supported",
			  TCL_STATIC);
	    goto methError;
	}
	if (oan > 0) {
	    oatype = NULL;
	    if ((oa[0].dataType.namespaceIndex != 0) &&

		Tcl_SetResult(interp, "unsupported output argument type",
			      TCL_STATIC);
		goto methError;
	    }
	}
	uaq = (UAQ *) ckalloc(sizeof(UAQ));
	memset(uaq, 0, sizeof(UAQ));
	uaq->uah = NULL;
	uaq->outType = NULL;
	uaq->nCmdObjs = uaq->nSavedCmdObjs = 0;
	uaq->cmdObjs = uaq->savedCmdObjs = NULL;
	uaq->backRef = NULL;
	uaret = UA_Server_addMethodNode(uah->server, nodeid, parent,
					refid, qn, *a, MethodInvoke, ian, ia,
					oan, oa, uaq, &retid);
	if (uaret != UA_STATUSCODE_GOOD) {
	    ReportError(interp, uai, "AddMethod", uaret);
	} else {
	    Tcl_DString ds;
	    char *p;
	    int i, isNew;

	    p = PrintNodeId(&retid, &ds);
	    Tcl_SetObjResult(interp, Tcl_NewStringObj(p, -1));
	    hPtr = Tcl_CreateHashEntry(&uah->meths, p, &isNew);
	    if (!isNew) {
		UAQ *oldq = (UAQ *) Tcl_GetHashValue(hPtr);

		if (oldq->backRef != NULL) {
		    *(oldq->backRef) = NULL;
		    oldq->backRef = NULL;
		}
		if (oldq->cmdObjs != NULL) {
		    for (i = 0; i < oldq->nSavedCmdObjs; i++) {
			Tcl_DecrRefCount(oldq->savedCmdObjs[i]);
		    }
		    ckfree((char *) oldq->cmdObjs);
		}
		if ((oldq->savedCmdObjs != NULL) &&
		    (oldq->savedCmdObjs != oldq->cmdObjs)) {
		    for (i = 0; i < oldq->nSavedCmdObjs; i++) {
			Tcl_DecrRefCount(oldq->savedCmdObjs[i]);
		    }
		    oldq->nSavedCmdObjs = 0;
		    oldq->savedCmdObjs = NULL;
		}
		oldq->nCmdObjs = 0;
		oldq->cmdObjs = NULL;
		ckfree((char *) oldq);
	    }
	    Tcl_SetHashValue(hPtr, (ClientData) uaq);
	    uaq->uah = uah;
	    uaq->outType = oatype;
	    uaq->nCmdObjs = nCmdObjs;
	    uaq->cmdObjs = (Tcl_Obj **) ckalloc(nCmdObjs * sizeof(Tcl_Obj *));

	    UA_NodeId_deleteMembers(&destid);
	    return TCL_ERROR;
	}
	UA_NodeId_deleteMembers(&nodeid);
	UA_NodeId_deleteMembers(&refid);
	UA_NodeId_deleteMembers(&destid);
    } else {
	int i, withRefs = UA_FALSE;
	Tcl_DString ds;
	char *p;

	if (objc > 5) {
	    Tcl_WrongNumArgs(interp, 1, objv, "handle Node id ?withrefs?");
	    return TCL_ERROR;
	}
	UA_NodeId_init(&nodeid);
	if (ParseNodeId(interp, &nodeid, Tcl_GetString(objv[3])) == NULL) {
	    goto nodeError;
	}
	if ((objc > 4) &&
	    (Tcl_GetBooleanFromObj(interp, objv[4], &withRefs) != TCL_OK)) {
	    goto nodeError;
	}
	uaret = UA_Server_deleteNode(uah->server, nodeid, withRefs);
	if (uaret != UA_STATUSCODE_GOOD) {
	    ReportError(interp, uai, "DeleteNode", uaret);
nodeError:
	    UA_NodeId_deleteMembers(&nodeid);
	    return TCL_ERROR;
	}

	/*
	 * Cleanup callbacks, if any.
	 */
	p = PrintNodeId(&nodeid, &ds);
	hPtr = Tcl_FindHashEntry(&uah->meths, p);
	if (hPtr != NULL) {
	    UAQ *meth = (UAQ *) Tcl_GetHashValue(hPtr);

	    if (meth->backRef != NULL) {
		*(meth->backRef) = NULL;
		meth->backRef = NULL;
	    }
	    Tcl_DeleteHashEntry(hPtr);
	    for (i = 0; i < meth->nCmdObjs; i++) {
		Tcl_DecrRefCount(meth->cmdObjs[i]);
	    }
	    if (meth->cmdObjs != NULL) {
		ckfree((char *) meth->cmdObjs);
	    }
	    ckfree((char *) meth);
	}
	hPtr = Tcl_FindHashEntry(&uah->dsrcs, p);
	if (hPtr != NULL) {
	    UAQ *dsrc = (UAQ *) Tcl_GetHashValue(hPtr);

	    if (dsrc->backRef != NULL) {
		*(dsrc->backRef) = NULL;
		dsrc->backRef = NULL;
	    }
	    Tcl_DeleteHashEntry(hPtr);
	    for (i = 0; i < dsrc->nCmdObjs; i++) {
		Tcl_DecrRefCount(dsrc->cmdObjs[i]);
	    }
	    if (dsrc->cmdObjs != NULL) {
		ckfree((char *) dsrc->cmdObjs);
	    }
	    ckfree((char *) dsrc);
	}
	Tcl_DStringFree(&ds);

	UA_NodeId_deleteMembers(&nodeid);
    }
    return TCL_OK;
}

/*
 *-------------------------------------------------------------------------

static int
MethodsObjCmd(ClientData clientData, Tcl_Interp *interp,
	      int objc, Tcl_Obj * const objv[])
{
    UAI *uai = (UAI *) clientData;
    UAH *uah;
    UAQ *uaq = NULL;
    Tcl_HashEntry *hPtr;
    Tcl_HashSearch search;
    char *p;

    if ((objc < 2) || (objc > 4)) {
	Tcl_WrongNumArgs(interp, 1, objv, "handle ?nodeid? ?outtype?");
	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);
	return TCL_ERROR;
    }
    uah = (UAH *) Tcl_GetHashValue(hPtr);
    hPtr = Tcl_FirstHashEntry(&uah->meths, &search);
    if (objc == 2) {
	Tcl_Obj *list = Tcl_NewListObj(0, NULL);
	Tcl_DString ds;
	char *p;

	while (hPtr != NULL) {
	    uaq = (UAQ *) Tcl_GetHashValue(hPtr);

	    Tcl_ListObjAppendElement(NULL, list,
		Tcl_NewStringObj(Tcl_GetHashKey(&uah->meths, hPtr), -1));
	    if (uaq->outType == NULL) {
		Tcl_ListObjAppendElement(NULL, list, Tcl_NewObj());
	    } else if (uaq->outType->typeId.namespaceIndex == 0) {
		Tcl_ListObjAppendElement(NULL, list,
		    Tcl_NewStringObj(uaq->outType->typeName, -1));
	    } else {
		p = PrintNodeId(&uaq->outType->typeId, &ds);
		Tcl_ListObjAppendElement(NULL, list, Tcl_NewStringObj(p, -1));
		Tcl_DStringFree(&ds);
	    }
	    Tcl_ListObjAppendElement(NULL, list,
		Tcl_NewListObj(uaq->nSavedCmdObjs, uaq->savedCmdObjs));
	    /* TBD: add input argument list */
	    hPtr = Tcl_NextHashEntry(&search);
	}
	Tcl_SetObjResult(interp, list);
	return TCL_OK;
    }
    p = Tcl_GetString(objv[2]);
    while (hPtr != NULL) {
	uaq = (UAQ *) Tcl_GetHashValue(hPtr);
	if (strcmp(p, Tcl_GetHashKey(&uah->meths, hPtr)) == 0) {
	    break;
	}
	hPtr = Tcl_NextHashEntry(&search);
    }
    if (hPtr == NULL) {
	Tcl_SetResult(interp, "method node not found", TCL_STATIC);
	ReportError(interp, uai, NULL, 0);
	return TCL_ERROR;
    }
    if (objc == 3) {
	Tcl_Obj *objs[3];
	Tcl_DString ds;
	char *p;

	objs[0] = Tcl_NewStringObj(Tcl_GetHashKey(&uah->meths, hPtr), -1);
	if (uaq->outType == NULL) {
	    objs[1] = Tcl_NewObj();
	} else if (uaq->outType->typeId.namespaceIndex == 0) {
	    objs[1] = Tcl_NewStringObj(uaq->outType->typeName, -1);
	} else {
	    p = PrintNodeId(&uaq->outType->typeId, &ds);
	    objs[1] = Tcl_NewStringObj(p, -1);
	    Tcl_DStringFree(&ds);
	}
	objs[2] = Tcl_NewListObj(uaq->nSavedCmdObjs, uaq->savedCmdObjs);
	/* TBD: add input argument list */
	Tcl_SetObjResult(interp, Tcl_NewListObj(3, objs));
    } else {
	p = Tcl_GetString(objv[3]);
	if (*p == '\0') {
	    uaq->outType = NULL;
	} else {
	    const UA_DataType *type = FindType(uai, uah, 0, p);

	    if (type == NULL) {
		Tcl_SetResult(interp, "unsupported type", TCL_STATIC);
		ReportError(interp, uai, NULL, 0);
		return TCL_ERROR;
	    }
	    uaq->outType = type;
	}
    }
    return TCL_OK;
}

/*
 *-------------------------------------------------------------------------
 *
 * DataSourcesObjCmd --

	} else {
	    size_t typesSize = uah->typesSize;
	    UA_DataType *types = uah->types;

	    uah->typesSize = 0;
	    uah->types = NULL;
	    ReleaseTypes(uah, 1);

#if (UA_OPEN62541_VER_MAJOR < 1)
	    if (uah->client != NULL) {
		UA_Client_setCustomDataTypes(uah->client, types, typesSize);
	    } else {
		UA_Server_setCustomDataTypes(uah->server, types, typesSize);
	    }
#else

	    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) {
	    char *p;

	    p = Tcl_GetString(objv[i]);
	    if (*p == '*') {
		++p;
	    }
	    type = FindType(uai, uah, 1, p);
	    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, isArray = 0;
	    char *p;

	    p = Tcl_GetString(objv[j]);
	    if (*p == '*') {
		++p;
		isArray = 1;
	    }
	    type = FindType(uai, uah, 1, p);
	    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 =
		sizeof(double) - (uah->types[i].memSize % sizeof(double));
	    if (uah->types[i].members[k].padding == sizeof(double)) {
		uah->types[i].members[k].padding = 0;
	    }
	    uah->types[i].members[k].namespaceZero = isZero;
	    uah->types[i].members[k].isArray = isArray;
	    if (!type->pointerFree) {
		uah->types[i].pointerFree = 0;
	    }
	    uah->types[i].memSize +=
		type->memSize + uah->types[i].members[k].padding;
	}
	break;

 *-------------------------------------------------------------------------
 */

int DLLEXPORT
Topcua_Init(Tcl_Interp *interp)
{
    UAI *uai;
    int i, skip, isNew;
    Tcl_HashEntry *hPtr;
    Tcl_Namespace *nsPtr;
    Tcl_Obj *cmdList;
    Tcl_Command cmd;

    /*
     * UA data types for which a mapping is provided.
     *
     * CAUTION: must be adjusted with EncodeFromObj()/DecodeToObj().
     */
    static const int types[] = {
	UA_TYPES_BOOLEAN, UA_TYPES_SBYTE, UA_TYPES_BYTE,
	UA_TYPES_INT16, UA_TYPES_UINT16, UA_TYPES_INT32,
	UA_TYPES_UINT32, UA_TYPES_INT64, UA_TYPES_UINT64,
	UA_TYPES_FLOAT, UA_TYPES_DOUBLE, UA_TYPES_STRING,
	UA_TYPES_DATETIME, UA_TYPES_GUID, UA_TYPES_BYTESTRING,
	UA_TYPES_XMLELEMENT, UA_TYPES_NODEID, UA_TYPES_EXPANDEDNODEID,
	UA_TYPES_STATUSCODE, UA_TYPES_QUALIFIEDNAME,
	UA_TYPES_LOCALIZEDTEXT, UA_TYPES_EXTENSIONOBJECT,
	UA_TYPES_DATAVALUE, UA_TYPES_VARIANT, UA_TYPES_DIAGNOSTICINFO,
#if (UA_OPEN62541_VER_MAJOR >= 1)
	UA_TYPES_UTCTIME, UA_TYPES_LOCALEID, UA_TYPES_DURATION,
#endif
    };

#if (UA_OPEN62541_VER_MAJOR < 1)
    /*
     * Aliased types as found with
     *   grep "#define.*UA_TYPES_.*UA_TYPES_" open62541/open62541.h
     */
    static const struct {
	const char *name;
	int type;
    } typeAliases[] = {
	{ "UtcTime", UA_TYPES_DATETIME },
	{ "LocaleId", UA_TYPES_STRING },
	{ "Duration", UA_TYPES_DOUBLE }
    };
#endif

    /*
     * Namespace commands to create.
     */
    static const struct {
	const char *name;
	Tcl_ObjCmdProc *proc;

    /*
     * Basic (scalar) types we can map.
     */
    Tcl_InitHashTable(&uai->types, TCL_STRING_KEYS);
    for (i = 0; i < sizeof(types) / sizeof(types[0]); i++) {
	hPtr = Tcl_CreateHashEntry(&uai->types,
				   UA_TYPES[types[i]].typeName, &isNew);
	Tcl_SetHashValue(hPtr, &UA_TYPES[i]);
    }
#if (UA_OPEN62541_VER_MAJOR < 1)
    for (i = 0; i < sizeof(typeAliases) / sizeof(typeAliases[0]); i++) {
	hPtr = Tcl_CreateHashEntry(&uai->types,
				   typeAliases[i].name, &isNew);
	Tcl_SetHashValue(hPtr, &UA_TYPES[typeAliases[i].type]);
    }
#endif

    /*
     * Reference types.
     */
    Tcl_InitHashTable(&uai->refTypes, TCL_STRING_KEYS);
    for (i = 0; i < sizeof(refTypes) / sizeof(refTypes[0]); i++) {
	hPtr = Tcl_CreateHashEntry(&uai->refTypes, refTypes[i].name, &isNew);
	Tcl_SetHashValue(hPtr, INT2PTR(refTypes[i].ns0id));
    }

    /*
     * Map of symbols used e.g. in data represented as dict.
     */
    Tcl_InitHashTable(&uai->syms, TCL_STRING_KEYS);