# Functionality covered: this file contains a collection of tests for the
# procedures in tclNamesp.c and tclEnsemble.c that implement Tcl's basic
# support for namespaces.  Other namespace-related tests appear in
# variable.test.
#
# Sourcing this file into Tcl runs the tests and generates output for errors.
# No output means no errors were found.
#
# Copyright (c) 1997 Sun Microsystems, Inc.
# Copyright (c) 1998-2000 by Scriptics Corporation.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.

package require tcltest 2
namespace import -force ::tcltest::*
testConstraint memory [llength [info commands memory]]

#
# REMARK: the tests for 'namespace upvar' are not done here. They are to be
# found in the file 'upvar.test'.
#

# Clear out any namespaces called test_ns_*
catch {namespace delete {*}[namespace children :: test_ns_*]}

proc fq {ns} {
    if {[string match ::* $ns]} {return $ns}
    set current [uplevel 1 {namespace current}]
    return [string trimright $current :]::[string trimleft $ns :]
}

test namespace-1.1 {TclInitNamespaces, GetNamespaceFromObj, NamespaceChildrenCmd} {
    namespace children :: test_ns_*
} {}

catch {unset l}
test namespace-2.1 {Tcl_GetCurrentNamespace} {
    list [namespace current] [namespace eval {} {namespace current}] \
        [namespace eval {} {namespace current}]
} {:: :: ::}
test namespace-2.2 {Tcl_GetCurrentNamespace} {
    set l {}
    lappend l [namespace current]
    namespace eval test_ns_1 {
        lappend l [namespace current]
        namespace eval foo {
            lappend l [namespace current]
        }
    }
    lappend l [namespace current]
} {:: ::test_ns_1 ::test_ns_1::foo ::}

test namespace-3.1 {Tcl_GetGlobalNamespace} {
    namespace eval test_ns_1 {namespace eval foo {namespace eval bar {} } }
    # namespace children uses Tcl_GetGlobalNamespace 
    namespace eval test_ns_1 {namespace children foo b*}
} {::test_ns_1::foo::bar}

test namespace-4.1 {Tcl_PushCallFrame with isProcCallFrame=1} {
    namespace eval test_ns_1 {
        variable v 123
        proc p {} {
            variable v
            return $v
        }
    }
    test_ns_1::p    ;# does Tcl_PushCallFrame to push p's namespace
} {123}
test namespace-4.2 {Tcl_PushCallFrame with isProcCallFrame=0} {
    namespace eval test_ns_1::baz {}  ;# does Tcl_PushCallFrame to create baz
    proc test_ns_1::baz::p {} {
        variable v
        set v 789
        set v}
    test_ns_1::baz::p
} {789}

test namespace-5.1 {Tcl_PopCallFrame, no vars} {
    namespace eval test_ns_1::blodge {}  ;# pushes then pops frame
} {}
test namespace-5.2 {Tcl_PopCallFrame, local vars must be deleted} {
    proc test_ns_1::r {} {
        set a 123
    }
    test_ns_1::r   ;# pushes then pop's r's frame
} {123}

test namespace-6.1 {Tcl_CreateNamespace} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [lsort [namespace children :: test_ns_*]] \
        [namespace eval test_ns_1 {namespace current}] \
	[namespace eval test_ns_2 {namespace current}] \
	[namespace eval ::test_ns_3 {namespace current}] \
	[namespace eval ::test_ns_4 \
            {namespace eval foo {namespace current}}] \
	[namespace eval ::test_ns_5 \
            {namespace eval ::test_ns_6 {namespace current}}] \
        [lsort [namespace children :: test_ns_*]]
} {{} ::test_ns_1 ::test_ns_2 ::test_ns_3 ::test_ns_4::foo ::test_ns_6 {::test_ns_1 ::test_ns_2 ::test_ns_3 ::test_ns_4 ::test_ns_5 ::test_ns_6}}
test namespace-6.2 {Tcl_CreateNamespace, odd number of :'s in name is okay} {
    list [namespace eval :::test_ns_1::::foo {namespace current}] \
         [namespace eval test_ns_2:::::foo {namespace current}]
} {::test_ns_1::foo ::test_ns_2::foo}
test namespace-6.3 {Tcl_CreateNamespace, trailing ::s in ns name are ignored} {
    list [catch {namespace eval test_ns_7::: {namespace current}} msg] $msg 
} {0 ::test_ns_7}
test namespace-6.4 {Tcl_CreateNamespace, trailing ::s in ns name are ignored} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1:: {
        namespace eval test_ns_2:: {}
        namespace eval test_ns_3:: {}
    }
    lsort [namespace children ::test_ns_1]
} [lsort {::test_ns_1::test_ns_2 ::test_ns_1::test_ns_3}]
test namespace-6.5 {Tcl_CreateNamespace, relative ns names now only looked up in current ns} {
    set trigger {
        namespace eval test_ns_2 {namespace current}
    }
    set l {}
    lappend l [namespace eval test_ns_1 $trigger]
    namespace eval test_ns_1::test_ns_2 {}
    lappend l [namespace eval test_ns_1 $trigger]
} {::test_ns_1::test_ns_2 ::test_ns_1::test_ns_2}

test namespace-7.1 {Tcl_DeleteNamespace, active call frames in ns} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1 {
        proc p {} {
            namespace delete [namespace current]
            return [namespace current]
        }
    }
    list [test_ns_1::p] [catch {test_ns_1::p} msg] $msg
} {::test_ns_1 1 {invalid command name "test_ns_1::p"}}
test namespace-7.2 {Tcl_DeleteNamespace, no active call frames in ns} {
    namespace eval test_ns_2 {
        proc p {} {
            return [namespace current]
        }
    }
    list [test_ns_2::p] [namespace delete test_ns_2]
} {::test_ns_2 {}}
test namespace-7.3 {recursive Tcl_DeleteNamespace, active call frames in ns} {
    # [Bug 1355942]
    namespace eval test_ns_2 {
        set x 1
	trace add variable x unset "namespace delete [namespace current];#"
	namespace delete [namespace current]
    }
} {}
test namespace-7.4 {recursive Tcl_DeleteNamespace, active call frames in ns} {
    # [Bug 1355942]
    namespace eval test_ns_2 {
        proc x {} {}
	trace add command x delete "namespace delete [namespace current];#"
	namespace delete [namespace current]
    }
} {}
test namespace-7.5 {recursive Tcl_DeleteNamespace, no active call frames in ns} {
    # [Bug 1355942]
    namespace eval test_ns_2 {
        set x 1
	trace add variable x unset "namespace delete [namespace current];#"
    }
    namespace delete test_ns_2
} {}
test namespace-7.6 {recursive Tcl_DeleteNamespace, no active call frames in ns} {
    # [Bug 1355942]
    namespace eval test_ns_2 {
        proc x {} {}
	trace add command x delete "namespace delete [namespace current];#"
    }
    namespace delete test_ns_2
} {}
test namespace-7.7 {Bug 1655305} -setup {
    interp create slave
    # Can't invoke through the ensemble, since deleting the global namespace
    # (indirectly, via deleting ::tcl) deletes the ensemble.
    slave eval {rename ::tcl::info::commands ::infocommands}
    slave hide infocommands
    slave eval {
	proc foo {} {
	    namespace delete ::
	}
    }
} -body {
    slave eval foo
    slave invokehidden infocommands
} -cleanup {
    interp delete slave
} -result {}


test namespace-8.1 {TclTeardownNamespace, delete global namespace} {
    catch {interp delete test_interp}
    interp create test_interp
    interp eval test_interp {
        namespace eval test_ns_1 {
            namespace export p
            proc p {} {
                return [namespace current]
            }
        }
        namespace eval test_ns_2 {
            namespace import ::test_ns_1::p
            variable v 27
            proc q {} {
                variable v
                return "[p] $v"
            }
        }
        set x [test_ns_2::q]
        catch {set xxxx}
    }
    list [interp eval test_interp {test_ns_2::q}] \
         [interp eval test_interp {namespace delete ::}] \
         [catch {interp eval test_interp {set a 123}} msg] $msg \
         [interp delete test_interp]
} {{::test_ns_1 27} {} 1 {invalid command name "set"} {}}
test namespace-8.2 {TclTeardownNamespace, remove deleted ns from parent} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1::test_ns_2::test_ns_3a {proc p {} {}}
    namespace eval test_ns_1::test_ns_2::test_ns_3b {proc q {} {}}
    list [namespace children test_ns_1] \
         [namespace delete test_ns_1::test_ns_2] \
         [namespace children test_ns_1]
} {::test_ns_1::test_ns_2 {} {}}
test namespace-8.3 {TclTeardownNamespace, delete child namespaces} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1::test_ns_2::test_ns_3a {proc p {} {}}
    namespace eval test_ns_1::test_ns_2::test_ns_3b {proc q {} {}}
    list [namespace children test_ns_1] \
         [namespace delete test_ns_1::test_ns_2] \
         [namespace children test_ns_1] \
         [catch {namespace children test_ns_1::test_ns_2} msg] $msg \
         [info commands test_ns_1::test_ns_2::test_ns_3a::*]
} {::test_ns_1::test_ns_2 {} {} 1 {namespace "test_ns_1::test_ns_2" not found in "::"} {}}
test namespace-8.4 {TclTeardownNamespace, cmds imported from deleted ns go away} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_export {
        namespace export cmd1 cmd2
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_import {
        namespace import ::test_ns_export::*
        proc p {} {return foo}
    }
    list [lsort [info commands test_ns_import::*]] \
         [namespace delete test_ns_export] \
         [info commands test_ns_import::*]
} [list [lsort {::test_ns_import::p ::test_ns_import::cmd1 ::test_ns_import::cmd2}] {} ::test_ns_import::p]
test namespace-8.5 {TclTeardownNamespace: preserve errorInfo; errorCode values} {
    interp create slave
    slave eval {trace add execution error leave {namespace delete :: ;#}}
    catch {slave eval error foo bar baz}
    interp delete slave
    set ::errorInfo
} {bar
    invoked from within
"slave eval error foo bar baz"}
test namespace-8.6 {TclTeardownNamespace: preserve errorInfo; errorCode values} {
    interp create slave 
    slave eval {trace add variable errorCode write {namespace delete :: ;#}}
    catch {slave eval error foo bar baz}
    interp delete slave
    set ::errorInfo
} {bar
    invoked from within
"slave eval error foo bar baz"}
test namespace-8.7 {TclTeardownNamespace: preserve errorInfo; errorCode values} {
    interp create slave
    slave eval {trace add execution error leave {namespace delete :: ;#}}
    catch {slave eval error foo bar baz}
    interp delete slave
    set ::errorCode
} baz

test namespace-9.1 {Tcl_Import, empty import pattern} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace eval test_ns_import {namespace import {}}} msg] $msg
} {1 {empty import pattern}}
test namespace-9.2 {Tcl_Import, unknown namespace in import pattern} {
    list [catch {namespace eval test_ns_import {namespace import fred::x}} msg] $msg
} {1 {unknown namespace in import pattern "fred::x"}}
test namespace-9.3 {Tcl_Import, import ns == export ns} {
    list [catch {namespace eval test_ns_import {namespace import ::test_ns_import::puts}} msg] $msg
} {1 {import pattern "::test_ns_import::puts" tries to import from namespace "test_ns_import" into itself}}
test namespace-9.4 {Tcl_Import, simple import} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_export {
        namespace export cmd1
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_import {
        namespace import ::test_ns_export::*
        proc p {} {return [cmd1 123]}
    }
    test_ns_import::p
} {cmd1: 123}
test namespace-9.5 {Tcl_Import, can't redefine cmd unless allowOverwrite!=0} {
    list [catch {namespace eval test_ns_import {namespace import ::test_ns_export::*}} msg] $msg
} {0 {}}
test namespace-9.6 {Tcl_Import, cmd redefinition ok if allowOverwrite!=0} {
    namespace eval test_ns_import {
        namespace import -force ::test_ns_export::*
        cmd1 555
    }
} {cmd1: 555}
test namespace-9.7 {Tcl_Import, links are preserved if cmd is redefined} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_export {
        namespace export cmd1
        proc cmd1 {args} {return "cmd1: $args"}
    }
    namespace eval test_ns_import {
        namespace import -force ::test_ns_export::*
    }
    list [test_ns_import::cmd1 a b c] \
         [test_ns_export::cmd1 d e f] \
         [proc test_ns_export::cmd1 {args} {return "new1: $args"}] \
         [namespace origin test_ns_import::cmd1] \
         [namespace origin test_ns_export::cmd1] \
         [test_ns_import::cmd1 g h i] \
         [test_ns_export::cmd1 j k l]
} {{cmd1: a b c} {cmd1: d e f} {} ::test_ns_export::cmd1 ::test_ns_export::cmd1 {new1: g h i} {new1: j k l}}

test namespace-9.8 {Tcl_Import: Bug 1017299} -setup {
    namespace eval one {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval two {
	namespace export cmd
	proc other args {}
    }
    namespace eval two \
	    [list namespace import [namespace current]::one::cmd]
    namespace eval three \
	    [list namespace import [namespace current]::two::cmd]
    namespace eval three {
	rename cmd other
	namespace export other
    }
} -body {
    namespace eval two [list namespace import -force \
	    [namespace current]::three::other]
    namespace origin two::other
} -cleanup {
    namespace delete one two three
} -match glob -result *::one::cmd

test namespace-9.9 {Tcl_Import: Bug 1017299} -setup {
    namespace eval one {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval two namespace export cmd
    namespace eval two \
	    [list namespace import [namespace current]::one::cmd]
    namespace eval three namespace export cmd
    namespace eval three \
	    [list namespace import [namespace current]::two::cmd]
} -body {
    namespace eval two [list namespace import -force \
	    [namespace current]::three::cmd]
    namespace origin two::cmd
} -cleanup {
    namespace delete one two three
} -returnCodes error -match glob -result {import pattern * would create a loop*}

test namespace-10.1 {Tcl_ForgetImport, check for valid namespaces} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace forget xyzzy::*} msg] $msg
} {1 {unknown namespace in namespace forget pattern "xyzzy::*"}}
test namespace-10.2 {Tcl_ForgetImport, ignores patterns that don't match} {
    namespace eval test_ns_export {
        namespace export cmd1
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_import {
        namespace forget ::test_ns_export::wombat
    }
} {}
test namespace-10.3 {Tcl_ForgetImport, deletes matching imported cmds} {
    namespace eval test_ns_import {
        namespace import ::test_ns_export::*
        proc p {} {return [cmd1 123]}
        set l {}
        lappend l [lsort [info commands ::test_ns_import::*]]
        namespace forget ::test_ns_export::cmd1
        lappend l [info commands ::test_ns_import::*]
        lappend l [catch {cmd1 777} msg] $msg
    }
} [list [lsort {::test_ns_import::p ::test_ns_import::cmd1}] ::test_ns_import::p 1 {invalid command name "cmd1"}]

test namespace-10.4 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval unrelated {
	proc cmd {} {}
    }
    namespace eval my \
	    [list namespace import [namespace current]::origin::cmd]
} -body {
    namespace eval my \
	    [list namespace forget [namespace current]::unrelated::cmd]
    my::cmd
} -cleanup {
    namespace delete origin unrelated my
}

test namespace-10.5 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval my \
	    [list namespace import [namespace current]::origin::cmd]
    namespace eval my rename cmd newname
} -body {
    namespace eval my \
	    [list namespace forget [namespace current]::origin::cmd]
    my::newname
} -cleanup {
    namespace delete origin my
} -returnCodes error -match glob -result *

test namespace-10.6 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval my \
	    [list namespace import [namespace current]::origin::cmd]
    namespace eval your {}
    namespace eval my \
	    [list rename cmd [namespace current]::your::newname]
} -body {
    namespace eval your namespace forget newname
    your::newname
} -cleanup {
    namespace delete origin my your
} -returnCodes error -match glob -result *

test namespace-10.7 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval link namespace export cmd
    namespace eval link \
	    [list namespace import [namespace current]::origin::cmd]
    namespace eval link2 namespace export cmd
    namespace eval link2 \
	    [list namespace import [namespace current]::link::cmd]
    namespace eval my \
	    [list namespace import [namespace current]::link2::cmd]
} -body {
    namespace eval my \
	    [list namespace forget [namespace current]::origin::cmd]
    my::cmd
} -cleanup {
    namespace delete origin link link2 my
} -returnCodes error -match glob -result *

test namespace-10.8 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval link namespace export cmd
    namespace eval link \
	    [list namespace import [namespace current]::origin::cmd]
    namespace eval link2 namespace export cmd
    namespace eval link2 \
	    [list namespace import [namespace current]::link::cmd]
    namespace eval my \
	    [list namespace import [namespace current]::link2::cmd]
} -body {
    namespace eval my \
	    [list namespace forget [namespace current]::link::cmd]
    my::cmd
} -cleanup {
    namespace delete origin link link2 my
}

test namespace-10.9 {Tcl_ForgetImport: Bug 560297} -setup {
    namespace eval origin {
	namespace export cmd
	proc cmd {} {}
    }
    namespace eval link namespace export cmd
    namespace eval link \
	    [list namespace import [namespace current]::origin::cmd]
    namespace eval link2 namespace export cmd
    namespace eval link2 \
	    [list namespace import [namespace current]::link::cmd]
    namespace eval my \
	    [list namespace import [namespace current]::link2::cmd]
} -body {
    namespace eval my \
	    [list namespace forget [namespace current]::link2::cmd]
    my::cmd
} -cleanup {
    namespace delete origin link link2 my
} -returnCodes error -match glob -result *

test namespace-11.1 {TclGetOriginalCommand, check if not imported cmd} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_export {
        namespace export cmd1
        proc cmd1 {args} {return "cmd1: $args"}
    }
    list [namespace origin set] [namespace origin test_ns_export::cmd1]
} {::set ::test_ns_export::cmd1}
test namespace-11.2 {TclGetOriginalCommand, directly imported cmd} {
    namespace eval test_ns_import1 {
        namespace import ::test_ns_export::*
        namespace export *
        proc p {} {namespace origin cmd1}
    }
    list [test_ns_import1::p] [namespace origin test_ns_import1::cmd1]
} {::test_ns_export::cmd1 ::test_ns_export::cmd1}
test namespace-11.3 {TclGetOriginalCommand, indirectly imported cmd} {
    namespace eval test_ns_import2 {
        namespace import ::test_ns_import1::*
        proc q {} {return [cmd1 123]}
    }
    list [test_ns_import2::q] [namespace origin test_ns_import2::cmd1]
} {{cmd1: 123} ::test_ns_export::cmd1}

test namespace-12.1 {InvokeImportedCmd} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_export {
        namespace export cmd1
        proc cmd1 {args} {namespace current}
    }
    namespace eval test_ns_import {
        namespace import ::test_ns_export::*
    }
    list [test_ns_import::cmd1]
} {::test_ns_export}

test namespace-13.1 {DeleteImportedCmd, deletes imported cmds} {
    namespace eval test_ns_import {
        set l {}
        lappend l [info commands ::test_ns_import::*]
        namespace forget ::test_ns_export::cmd1
        lappend l [info commands ::test_ns_import::*]
    }
} {::test_ns_import::cmd1 {}}

test namespace-14.1 {TclGetNamespaceForQualName, absolute names} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    variable v 10
    namespace eval test_ns_1::test_ns_2 {
        variable v 20
    }
    namespace eval test_ns_2 {
        variable v 30
    }
    namespace eval test_ns_1 {
        list $::v $::test_ns_2::v $::test_ns_1::test_ns_2::v \
		[lsort [namespace children :: test_ns_*]]
    }
} [list 10 30 20 [lsort {::test_ns_1 ::test_ns_2}]]
test namespace-14.2 {TclGetNamespaceForQualName, invalid absolute names} {
    namespace eval test_ns_1 {
        list [catch {set ::test_ns_777::v} msg] $msg \
             [catch {namespace children test_ns_777} msg] $msg
    }
} {1 {can't read "::test_ns_777::v": no such variable} 1 {namespace "test_ns_777" not found in "::test_ns_1"}}
test namespace-14.3 {TclGetNamespaceForQualName, relative names} {
    namespace eval test_ns_1 {
        list $v $test_ns_2::v
    }
} {10 20}
test namespace-14.4 {TclGetNamespaceForQualName, relative ns names looked up only in current ns} {
    namespace eval test_ns_1::test_ns_2 {
        namespace eval foo {}
    }
    namespace eval test_ns_1 {
        list [namespace children test_ns_2] \
             [catch {namespace children test_ns_1} msg] $msg
    }
} {::test_ns_1::test_ns_2::foo 1 {namespace "test_ns_1" not found in "::test_ns_1"}}
test namespace-14.5 {TclGetNamespaceForQualName, relative ns names looked up only in current ns} {
    namespace eval ::test_ns_2 {
        namespace eval bar {}
    }
    namespace eval test_ns_1 {
        list [catch {namespace delete test_ns_2::bar} msg] $msg
    }
} {1 {unknown namespace "test_ns_2::bar" in namespace delete command}}
test namespace-14.6 {TclGetNamespaceForQualName, relative ns names looked up only in current ns} {
    namespace eval test_ns_1::test_ns_2 {
        namespace eval foo {}
    }
    namespace eval test_ns_1 {
        list [namespace children test_ns_2] \
             [catch {namespace children test_ns_1} msg] $msg
    }
} {::test_ns_1::test_ns_2::foo 1 {namespace "test_ns_1" not found in "::test_ns_1"}}
test namespace-14.7 {TclGetNamespaceForQualName, ignore extra :s if ns} {
    namespace children test_ns_1:::
} {::test_ns_1::test_ns_2}
test namespace-14.8 {TclGetNamespaceForQualName, ignore extra :s if ns} {
    namespace children :::test_ns_1:::::test_ns_2:::
} {::test_ns_1::test_ns_2::foo}
test namespace-14.9 {TclGetNamespaceForQualName, extra ::s are significant for vars} {
    set l {}
    lappend l [catch {set test_ns_1::test_ns_2::} msg] $msg
    namespace eval test_ns_1::test_ns_2 {variable {} 2525}
    lappend l [set test_ns_1::test_ns_2::]
} {1 {can't read "test_ns_1::test_ns_2::": no such variable} 2525}
test namespace-14.10 {TclGetNamespaceForQualName, extra ::s are significant for vars} {
    catch {unset test_ns_1::test_ns_2::}
    set l {}
    lappend l [catch {set test_ns_1::test_ns_2::} msg] $msg
    set test_ns_1::test_ns_2:: 314159
    lappend l [set test_ns_1::test_ns_2::]
} {1 {can't read "test_ns_1::test_ns_2::": no such variable} 314159}
test namespace-14.11 {TclGetNamespaceForQualName, extra ::s are significant for commands} {
    catch {rename test_ns_1::test_ns_2:: {}}
    set l {}
    lappend l [catch {test_ns_1::test_ns_2:: hello} msg] $msg
    proc test_ns_1::test_ns_2:: {args} {return "\{\}: $args"}
    lappend l [test_ns_1::test_ns_2:: hello]
} {1 {invalid command name "test_ns_1::test_ns_2::"} {{}: hello}}
test namespace-14.12 {TclGetNamespaceForQualName, extra ::s are significant for vars} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1 {
        variable {}
        set test_ns_1::(x) y
    }
    set test_ns_1::(x)
} y
test namespace-14.13 {TclGetNamespaceForQualName, namespace other than global ns can't have empty name} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace eval test_ns_1 {proc {} {} {}; namespace eval {} {}; {}}} msg] $msg
} {1 {can't create namespace "": only global namespace can have empty name}}

test namespace-15.1 {Tcl_FindNamespace, absolute name found} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_delete {
        namespace eval test_ns_delete2 {}
        proc cmd {args} {namespace current}
    }
    list [namespace delete ::test_ns_delete::test_ns_delete2] \
         [namespace children ::test_ns_delete]
} {{} {}}
test namespace-15.2 {Tcl_FindNamespace, absolute name not found} {
    list [catch {namespace delete ::test_ns_delete::test_ns_delete2} msg] $msg
} {1 {unknown namespace "::test_ns_delete::test_ns_delete2" in namespace delete command}}
test namespace-15.3 {Tcl_FindNamespace, relative name found} {
    namespace eval test_ns_delete {
        namespace eval test_ns_delete2 {}
        namespace eval test_ns_delete3 {}
        list [namespace delete test_ns_delete2] \
             [namespace children [namespace current]]
    }
} {{} ::test_ns_delete::test_ns_delete3}
test namespace-15.4 {Tcl_FindNamespace, relative name not found} {
    namespace eval test_ns_delete2 {}
    namespace eval test_ns_delete {
        list [catch {namespace delete test_ns_delete2} msg] $msg
    }
} {1 {unknown namespace "test_ns_delete2" in namespace delete command}}

test namespace-16.1 {Tcl_FindCommand, absolute name found} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1 {
        proc cmd {args} {return "[namespace current]::cmd: $args"}
        variable v "::test_ns_1::cmd"
        eval $v one
    }
} {::test_ns_1::cmd: one}
test namespace-16.2 {Tcl_FindCommand, absolute name found} {
    eval $test_ns_1::v two
} {::test_ns_1::cmd: two}
test namespace-16.3 {Tcl_FindCommand, absolute name not found} {
    namespace eval test_ns_1 {
        variable v2 "::test_ns_1::ladidah"
        list [catch {eval $v2} msg] $msg
    }
} {1 {invalid command name "::test_ns_1::ladidah"}}

# save the "unknown" proc, which is redefined by the following two tests
catch {rename unknown unknown.old}
proc unknown {args} {
    return "unknown: $args"
}
test namespace-16.4 {Tcl_FindCommand, absolute name and TCL_GLOBAL_ONLY} {
    ::test_ns_1::foobar x y z
} {unknown: ::test_ns_1::foobar x y z}
test namespace-16.5 {Tcl_FindCommand, absolute name and TCL_GLOBAL_ONLY} {
    ::foobar 1 2 3 4 5
} {unknown: ::foobar 1 2 3 4 5}
test namespace-16.6 {Tcl_FindCommand, relative name and TCL_GLOBAL_ONLY} {
    test_ns_1::foobar x y z
} {unknown: test_ns_1::foobar x y z}
test namespace-16.7 {Tcl_FindCommand, relative name and TCL_GLOBAL_ONLY} {
    foobar 1 2 3 4 5
} {unknown: foobar 1 2 3 4 5}
# restore the "unknown" proc saved previously
catch {rename unknown {}}
catch {rename unknown.old unknown}

test namespace-16.8 {Tcl_FindCommand, relative name found} {
    namespace eval test_ns_1 {
        cmd a b c
    }
} {::test_ns_1::cmd: a b c}
test namespace-16.9 {Tcl_FindCommand, relative name found} -body {
    proc cmd2 {args} {return "[namespace current]::cmd2: $args"}
    namespace eval test_ns_1 {
       cmd2 a b c
    }
} -cleanup {
    catch {rename cmd2 {}}
} -result {::::cmd2: a b c}
test namespace-16.10 {Tcl_FindCommand, relative name found, only look in current then global ns} -body {
    proc cmd2 {args} {return "[namespace current]::cmd2: $args"}
    namespace eval test_ns_1 {
        proc cmd2 {args} {
            return "[namespace current]::cmd2 in test_ns_1: $args"
        }
        namespace eval test_ns_12 {
            cmd2 a b c
        }
    }
} -cleanup {
    catch {rename cmd2 {}}
} -result {::::cmd2: a b c}
test namespace-16.11 {Tcl_FindCommand, relative name not found} {
    namespace eval test_ns_1 {
       list [catch {cmd3 a b c} msg] $msg
    }
} {1 {invalid command name "cmd3"}}

catch {unset x}
test namespace-17.1 {Tcl_FindNamespaceVar, absolute name found} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    set x 314159
    namespace eval test_ns_1 {
        set ::x
    }
} {314159}
test namespace-17.2 {Tcl_FindNamespaceVar, absolute name found} {
    namespace eval test_ns_1 {
        variable x 777
        set ::test_ns_1::x
    }
} {777}
test namespace-17.3 {Tcl_FindNamespaceVar, absolute name found} {
    namespace eval test_ns_1 {
        namespace eval test_ns_2 {
            variable x 1111
        }
        set ::test_ns_1::test_ns_2::x
    }
} {1111}
test namespace-17.4 {Tcl_FindNamespaceVar, absolute name not found} {
    namespace eval test_ns_1 {
        namespace eval test_ns_2 {
            variable x 1111
        }
        list [catch {set ::test_ns_1::test_ns_2::y} msg] $msg
    }
} {1 {can't read "::test_ns_1::test_ns_2::y": no such variable}}
test namespace-17.5 {Tcl_FindNamespaceVar, absolute name and TCL_GLOBAL_ONLY} {
    namespace eval test_ns_1 {
        namespace eval test_ns_3 {
            variable ::test_ns_1::test_ns_2::x 2222
        }
    }
    set ::test_ns_1::test_ns_2::x
} {2222}
test namespace-17.6 {Tcl_FindNamespaceVar, relative name found} {
    namespace eval test_ns_1 {
        set x
    }
} {777}
test namespace-17.7 {Tcl_FindNamespaceVar, relative name found} {
    namespace eval test_ns_1 {
        unset x
        set x  ;# must be global x now
    }
} {314159}
test namespace-17.8 {Tcl_FindNamespaceVar, relative name not found} {
    namespace eval test_ns_1 {
        list [catch {set wuzzat} msg] $msg
    }
} {1 {can't read "wuzzat": no such variable}}
test namespace-17.9 {Tcl_FindNamespaceVar, relative name and TCL_GLOBAL_ONLY} {
    namespace eval test_ns_1 {
        variable a hello
    }
    set test_ns_1::a
} {hello}
test namespace-17.10 {Tcl_FindNamespaceVar, interference with cached varNames} {
    namespace eval test_ns_1 {}
    proc test_ns {} {
	set ::test_ns_1::a 0
    }
    test_ns
    rename test_ns {}
    namespace eval test_ns_1 unset a
    set a 0
    namespace eval test_ns_1 set a 1
    namespace delete test_ns_1
    return $a
} 1
catch {unset a}
catch {unset x}

catch {unset l}
catch {rename foo {}}
test namespace-18.1 {TclResetShadowedCmdRefs, one-level check for command shadowing} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    proc foo {} {return "global foo"}
    namespace eval test_ns_1 {
        proc trigger {} {
            return [foo]
        }
    }
    set l ""
    lappend l [test_ns_1::trigger]
    namespace eval test_ns_1 {
        # force invalidation of cached ref to "foo" in proc trigger
        proc foo {} {return "foo in test_ns_1"}
    }
    lappend l [test_ns_1::trigger]
} {{global foo} {foo in test_ns_1}}
test namespace-18.2 {TclResetShadowedCmdRefs, multilevel check for command shadowing} {
    namespace eval test_ns_2 {
        proc foo {} {return "foo in ::test_ns_2"}
    }
    namespace eval test_ns_1 {
        namespace eval test_ns_2 {}
        proc trigger {} {
            return [test_ns_2::foo]
        }
    }
    set l ""
    lappend l [test_ns_1::trigger]
    namespace eval test_ns_1 {
        namespace eval test_ns_2 {
            # force invalidation of cached ref to "foo" in proc trigger
            proc foo {} {return "foo in ::test_ns_1::test_ns_2"}
        }
    }
    lappend l [test_ns_1::trigger]
} {{foo in ::test_ns_2} {foo in ::test_ns_1::test_ns_2}}
catch {unset l}
catch {rename foo {}}

test namespace-19.1 {GetNamespaceFromObj, global name found} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1::test_ns_2 {}
    namespace children ::test_ns_1
} {::test_ns_1::test_ns_2}
test namespace-19.2 {GetNamespaceFromObj, relative name found} {
    namespace eval test_ns_1 {
        namespace children test_ns_2
    }
} {}
test namespace-19.3 {GetNamespaceFromObj, name not found} -body {
    namespace eval test_ns_1 {
        namespace children test_ns_99
    }
} -returnCodes error -result {namespace "test_ns_99" not found in "::test_ns_1"}
test namespace-19.4 {GetNamespaceFromObj, invalidation of cached ns refs} {
    namespace eval test_ns_1 {
        proc foo {} {
            return [namespace children test_ns_2]
        }
        list [catch {namespace children test_ns_99} msg] $msg
    }
    set l {}
    lappend l [test_ns_1::foo]
    namespace delete test_ns_1::test_ns_2
    namespace eval test_ns_1::test_ns_2::test_ns_3 {}
    lappend l [test_ns_1::foo]
} {{} ::test_ns_1::test_ns_2::test_ns_3}

test namespace-20.1 {Tcl_NamespaceObjCmd, bad subcommand} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace} msg] $msg
} {1 {wrong # args: should be "namespace subcommand ?arg ...?"}}
test namespace-20.2 {Tcl_NamespaceObjCmd, bad subcommand} -body {
    namespace wombat {}
} -returnCodes error -match glob -result {unknown or ambiguous subcommand "wombat": must be *}
test namespace-20.3 {Tcl_NamespaceObjCmd, abbreviations are okay} {
    namespace ch :: test_ns_*
} {}

test namespace-21.1 {NamespaceChildrenCmd, no args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1::test_ns_2 {}
    expr {[string first ::test_ns_1 [namespace children]] != -1}
} {1}
test namespace-21.2 {NamespaceChildrenCmd, no args} {
    namespace eval test_ns_1 {
        namespace children
    }
} {::test_ns_1::test_ns_2}
test namespace-21.3 {NamespaceChildrenCmd, ns name given} {
    namespace children ::test_ns_1
} {::test_ns_1::test_ns_2}
test namespace-21.4 {NamespaceChildrenCmd, ns name given} {
    namespace eval test_ns_1 {
        namespace children test_ns_2
    }
} {}
test namespace-21.5 {NamespaceChildrenCmd, too many args} {
    namespace eval test_ns_1 {
        list [catch {namespace children test_ns_2 xxx yyy} msg] $msg
    }
} {1 {wrong # args: should be "namespace children ?name? ?pattern?"}}
test namespace-21.6 {NamespaceChildrenCmd, glob-style pattern given} {
    namespace eval test_ns_1::test_ns_foo {}
    namespace children test_ns_1 *f*
} {::test_ns_1::test_ns_foo}
test namespace-21.7 {NamespaceChildrenCmd, glob-style pattern given} {
    namespace eval test_ns_1::test_ns_foo {}
    lsort [namespace children test_ns_1 test*]
} [lsort {::test_ns_1::test_ns_2 ::test_ns_1::test_ns_foo}]
test namespace-21.8 {NamespaceChildrenCmd, trivial pattern starting with ::} {
    namespace eval test_ns_1 {}
    namespace children [namespace current] [fq test_ns_1]
} [fq test_ns_1]

test namespace-22.1 {NamespaceCodeCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace code} msg] $msg \
         [catch {namespace code xxx yyy} msg] $msg
} {1 {wrong # args: should be "namespace code arg"} 1 {wrong # args: should be "namespace code arg"}}
test namespace-22.2 {NamespaceCodeCmd, arg is already scoped value} {
    namespace eval test_ns_1 {
        proc cmd {} {return "test_ns_1::cmd"}
    }
    namespace code {::namespace inscope ::test_ns_1 cmd}
} {::namespace inscope ::test_ns_1 cmd}
test namespace-22.3 {NamespaceCodeCmd, arg is already scoped value} {
    namespace code {namespace     inscope     ::test_ns_1 cmd}
} {::namespace inscope :: {namespace     inscope     ::test_ns_1 cmd}}
test namespace-22.4 {NamespaceCodeCmd, in :: namespace} {
    namespace code unknown
} {::namespace inscope :: unknown}
test namespace-22.5 {NamespaceCodeCmd, in other namespace} {
    namespace eval test_ns_1 {
        namespace code cmd
    }
} {::namespace inscope ::test_ns_1 cmd}
test namespace-22.6 {NamespaceCodeCmd, in other namespace} { 
    namespace eval test_ns_1 { 
	variable v 42 
    } 
    namespace eval test_ns_2 { 
	proc namespace args {} 
    } 
    namespace eval test_ns_2 [namespace eval test_ns_1 { 
	namespace code {set v} 
    }] 
} {42} 
test namespace-22.7 {NamespaceCodeCmd, Bug 3202171} {
    namespace eval demo {
	proc namespace args {puts $args}
	::namespace code {namespace inscope foo}
    }
} [list ::namespace inscope [fq demo] {namespace inscope foo}]

test namespace-23.1 {NamespaceCurrentCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace current xxx} msg] $msg \
         [catch {namespace current xxx yyy} msg] $msg
} {1 {wrong # args: should be "namespace current"} 1 {wrong # args: should be "namespace current"}}
test namespace-23.2 {NamespaceCurrentCmd, at global level} {
    namespace current
} {::}
test namespace-23.3 {NamespaceCurrentCmd, in nested ns} {
    namespace eval test_ns_1::test_ns_2 {
        namespace current
    }
} {::test_ns_1::test_ns_2}

test namespace-24.1 {NamespaceDeleteCmd, no args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace delete
} {}
test namespace-24.2 {NamespaceDeleteCmd, one arg} {
    namespace eval test_ns_1::test_ns_2 {}
    namespace delete ::test_ns_1
} {}
test namespace-24.3 {NamespaceDeleteCmd, two args} {
    namespace eval test_ns_1::test_ns_2 {}
    list [namespace delete ::test_ns_1::test_ns_2] [namespace delete ::test_ns_1]
} {{} {}}
test namespace-24.4 {NamespaceDeleteCmd, unknown ns} {
    list [catch {namespace delete ::test_ns_foo} msg] $msg
} {1 {unknown namespace "::test_ns_foo" in namespace delete command}}

test namespace-25.1 {NamespaceEvalCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace eval} msg] $msg
} {1 {wrong # args: should be "namespace eval name arg ?arg...?"}}
test namespace-25.2 {NamespaceEvalCmd, bad args} -body {
    namespace test_ns_1
} -returnCodes error -match glob -result {unknown or ambiguous subcommand "test_ns_1": must be *}
catch {unset v}
test namespace-25.3 {NamespaceEvalCmd, new namespace} {
    set v 123
    namespace eval test_ns_1 {
        variable v 314159
        proc p {} {
            variable v
            return $v
        }
    }
    test_ns_1::p
} {314159}
test namespace-25.4 {NamespaceEvalCmd, existing namespace} {
    namespace eval test_ns_1 {
        proc q {} {return [expr {[p]+1}]}
    }
    test_ns_1::q
} {314160}
test namespace-25.5 {NamespaceEvalCmd, multiple args} {
    namespace eval test_ns_1 "set" "v"
} {314159}
test namespace-25.6 {NamespaceEvalCmd, error in eval'd script} {
    list [catch {namespace eval test_ns_1 {xxxx}} msg] $msg $::errorInfo
} {1 {invalid command name "xxxx"} {invalid command name "xxxx"
    while executing
"xxxx"
    (in namespace eval "::test_ns_1" script line 1)
    invoked from within
"namespace eval test_ns_1 {xxxx}"}}
test namespace-25.7 {NamespaceEvalCmd, error in eval'd script} {
    list [catch {namespace eval test_ns_1 {error foo bar baz}} msg] $msg $::errorInfo
} {1 foo {bar
    (in namespace eval "::test_ns_1" script line 1)
    invoked from within
"namespace eval test_ns_1 {error foo bar baz}"}}
test namespace-25.8 {NamespaceEvalCmd, error in eval'd script} {
    list [catch {namespace eval test_ns_1 error foo bar baz} msg] $msg $::errorInfo
} {1 foo {bar
    (in namespace eval "::test_ns_1" script line 1)
    invoked from within
"namespace eval test_ns_1 error foo bar baz"}}
catch {unset v}
test namespace-25.9 {NamespaceEvalCmd, 545325} {
    namespace eval test_ns_1 info level 0
} {namespace eval test_ns_1 info level 0}

test namespace-26.1 {NamespaceExportCmd, no args and new ns} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace export
} {}
test namespace-26.2 {NamespaceExportCmd, just -clear arg} {
    namespace export -clear
} {}
test namespace-26.3 {NamespaceExportCmd, pattern can't specify a namespace} {
    namespace eval test_ns_1 {
        list [catch {namespace export ::zzz} msg] $msg
    }
} {1 {invalid export pattern "::zzz": pattern can't specify a namespace}}
test namespace-26.4 {NamespaceExportCmd, one pattern} {
    namespace eval test_ns_1 {
        namespace export cmd1
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
        proc cmd3 {args} {return "cmd3: $args"}
        proc cmd4 {args} {return "cmd4: $args"}
    }
    namespace eval test_ns_2 {
        namespace import ::test_ns_1::*
    }
    list [info commands test_ns_2::*] [test_ns_2::cmd1 hello]
} {::test_ns_2::cmd1 {cmd1: hello}}
test namespace-26.5 {NamespaceExportCmd, sequence of patterns, patterns accumulate} {
    namespace eval test_ns_1 {
        namespace export cmd1 cmd3
    }
    namespace eval test_ns_2 {
        namespace import -force ::test_ns_1::*
    }
    list [lsort [info commands test_ns_2::*]] [test_ns_2::cmd3 hello]
} [list [lsort {::test_ns_2::cmd1 ::test_ns_2::cmd3}] {cmd3: hello}]
test namespace-26.6 {NamespaceExportCmd, no patterns means return uniq'ed export list} {
    namespace eval test_ns_1 {
        namespace export
    }
} {cmd1 cmd3}
test namespace-26.7 {NamespaceExportCmd, -clear resets export list} {
    namespace eval test_ns_1 {
        namespace export -clear cmd4
    }
    namespace eval test_ns_2 {
        namespace import ::test_ns_1::*
    }
    list [lsort [info commands test_ns_2::*]] [test_ns_2::cmd4 hello]
} [list [lsort {::test_ns_2::cmd4 ::test_ns_2::cmd1 ::test_ns_2::cmd3}] {cmd4: hello}]

test namespace-27.1 {NamespaceForgetCmd, no args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace forget
} {}
test namespace-27.2 {NamespaceForgetCmd, args must be valid namespaces} {
    list [catch {namespace forget ::test_ns_1::xxx} msg] $msg
} {1 {unknown namespace in namespace forget pattern "::test_ns_1::xxx"}}
test namespace-27.3 {NamespaceForgetCmd, arg is forgotten} {
    namespace eval test_ns_1 {
        namespace export cmd*
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_2 {
        namespace import ::test_ns_1::*
        namespace forget ::test_ns_1::cmd1
    }
    info commands ::test_ns_2::*
} {::test_ns_2::cmd2}

test namespace-28.1 {NamespaceImportCmd, no args} -setup {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
} -body {
    namespace eval ::test_ns_1 {
	proc foo {} {}
	proc bar {} {}
	proc boo {} {}
	proc glorp {} {}
	namespace export foo b*
    }
    namespace eval ::test_ns_2 {
	namespace import ::test_ns_1::*
	lsort [namespace import]
    }
} -cleanup {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
} -result {bar boo foo}
test namespace-28.2 {NamespaceImportCmd, no args and just "-force"} {
    namespace import -force
} {}
test namespace-28.3 {NamespaceImportCmd, arg is imported} {
    namespace eval test_ns_1 {
        namespace export cmd2
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_2 {
        namespace import ::test_ns_1::*
        namespace forget ::test_ns_1::cmd1
    }
    info commands test_ns_2::*
} {::test_ns_2::cmd2}

test namespace-29.1 {NamespaceInscopeCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace inscope} msg] $msg
} {1 {wrong # args: should be "namespace inscope name arg ?arg...?"}}
test namespace-29.2 {NamespaceInscopeCmd, bad args} {
    list [catch {namespace inscope ::} msg] $msg
} {1 {wrong # args: should be "namespace inscope name arg ?arg...?"}}
test namespace-29.3 {NamespaceInscopeCmd, specified ns must exist} -body {
    namespace inscope test_ns_1 {set v}
} -returnCodes error -result {namespace "test_ns_1" not found in "::"}
test namespace-29.4 {NamespaceInscopeCmd, simple case} {
    namespace eval test_ns_1 {
        variable v 747
        proc cmd {args} {
            variable v
            return "[namespace current]::cmd: v=$v, args=$args"
        }
    }
    namespace inscope test_ns_1 cmd
} {::test_ns_1::cmd: v=747, args=}
test namespace-29.5 {NamespaceInscopeCmd, has lappend semantics} {
    list [namespace inscope test_ns_1 cmd x y z] \
         [namespace eval test_ns_1 [concat cmd [list x y z]]]
} {{::test_ns_1::cmd: v=747, args=x y z} {::test_ns_1::cmd: v=747, args=x y z}}
test namespace-29.6 {NamespaceInscopeCmd, 1400572} {
    namespace inscope test_ns_1 {info level 0}
} {namespace inscope test_ns_1 {info level 0}}


test namespace-30.1 {NamespaceOriginCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace origin} msg] $msg
} {1 {wrong # args: should be "namespace origin name"}}
test namespace-30.2 {NamespaceOriginCmd, bad args} {
    list [catch {namespace origin x y} msg] $msg
} {1 {wrong # args: should be "namespace origin name"}}
test namespace-30.3 {NamespaceOriginCmd, command not found} {
    list [catch {namespace origin fred} msg] $msg
} {1 {invalid command name "fred"}}
test namespace-30.4 {NamespaceOriginCmd, command isn't imported} {
    namespace origin set
} {::set}
test namespace-30.5 {NamespaceOriginCmd, imported command} {
    namespace eval test_ns_1 {
        namespace export cmd*
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_2 {
        namespace export *
        namespace import ::test_ns_1::*
        proc p {} {}
    }
    namespace eval test_ns_3 {
        namespace import ::test_ns_2::*
        list [namespace origin foreach] \
             [namespace origin p] \
             [namespace origin cmd1] \
             [namespace origin ::test_ns_2::cmd2]
    }
} {::foreach ::test_ns_2::p ::test_ns_1::cmd1 ::test_ns_1::cmd2}

test namespace-31.1 {NamespaceParentCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace parent a b} msg] $msg
} {1 {wrong # args: should be "namespace parent ?name?"}}
test namespace-31.2 {NamespaceParentCmd, no args} {
    namespace parent
} {}
test namespace-31.3 {NamespaceParentCmd, namespace specified} {
    namespace eval test_ns_1 {
        namespace eval test_ns_2 {
            namespace eval test_ns_3 {}
        }
    }
    list [namespace parent ::] \
         [namespace parent test_ns_1::test_ns_2] \
         [namespace eval test_ns_1::test_ns_2::test_ns_3 {namespace parent ::test_ns_1::test_ns_2}]
} {{} ::test_ns_1 ::test_ns_1}
test namespace-31.4 {NamespaceParentCmd, bad namespace specified} -body {
    namespace parent test_ns_1::test_ns_foo
} -returnCodes error -result {namespace "test_ns_1::test_ns_foo" not found in "::"}

test namespace-32.1 {NamespaceQualifiersCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace qualifiers} msg] $msg
} {1 {wrong # args: should be "namespace qualifiers string"}}
test namespace-32.2 {NamespaceQualifiersCmd, bad args} {
    list [catch {namespace qualifiers x y} msg] $msg
} {1 {wrong # args: should be "namespace qualifiers string"}}
test namespace-32.3 {NamespaceQualifiersCmd, simple name} {
    namespace qualifiers foo
} {}
test namespace-32.4 {NamespaceQualifiersCmd, leading ::} {
    namespace qualifiers ::x::y::z
} {::x::y}
test namespace-32.5 {NamespaceQualifiersCmd, no leading ::} {
    namespace qualifiers a::b
} {a}
test namespace-32.6 {NamespaceQualifiersCmd, :: argument} {
    namespace qualifiers ::
} {}
test namespace-32.7 {NamespaceQualifiersCmd, odd number of :s} {
    namespace qualifiers :::::
} {}
test namespace-32.8 {NamespaceQualifiersCmd, odd number of :s} {
    namespace qualifiers foo:::
} {foo}

test namespace-33.1 {NamespaceTailCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace tail} msg] $msg
} {1 {wrong # args: should be "namespace tail string"}}
test namespace-33.2 {NamespaceTailCmd, bad args} {
    list [catch {namespace tail x y} msg] $msg
} {1 {wrong # args: should be "namespace tail string"}}
test namespace-33.3 {NamespaceTailCmd, simple name} {
    namespace tail foo
} {foo}
test namespace-33.4 {NamespaceTailCmd, leading ::} {
    namespace tail ::x::y::z
} {z}
test namespace-33.5 {NamespaceTailCmd, no leading ::} {
    namespace tail a::b
} {b}
test namespace-33.6 {NamespaceTailCmd, :: argument} {
    namespace tail ::
} {}
test namespace-33.7 {NamespaceTailCmd, odd number of :s} {
    namespace tail :::::
} {}
test namespace-33.8 {NamespaceTailCmd, odd number of :s} {
    namespace tail foo:::
} {}

test namespace-34.1 {NamespaceWhichCmd, bad args} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    list [catch {namespace which} msg] $msg
} {1 {wrong # args: should be "namespace which ?-command? ?-variable? name"}}
test namespace-34.2 {NamespaceWhichCmd, bad args} {
    list [catch {namespace which -fred x} msg] $msg
} {1 {wrong # args: should be "namespace which ?-command? ?-variable? name"}}
test namespace-34.3 {NamespaceWhichCmd, single arg is always command name} {
    namespace which -command
} {}
test namespace-34.4 {NamespaceWhichCmd, bad args} {
    list [catch {namespace which a b} msg] $msg
} {1 {wrong # args: should be "namespace which ?-command? ?-variable? name"}}
test namespace-34.5 {NamespaceWhichCmd, command lookup} {
    namespace eval test_ns_1 {
        namespace export cmd*
        variable v1 111
        proc cmd1 {args} {return "cmd1: $args"}
        proc cmd2 {args} {return "cmd2: $args"}
    }
    namespace eval test_ns_2 {
        namespace export *
        namespace import ::test_ns_1::*
        variable v2 222
        proc p {} {}
    }
    namespace eval test_ns_3 {
        namespace import ::test_ns_2::*
        variable v3 333
        list [namespace which -command foreach] \
             [namespace which -command p] \
             [namespace which -command cmd1] \
             [namespace which -command ::test_ns_2::cmd2] \
             [catch {namespace which -command ::test_ns_2::noSuchCmd} msg] $msg
    }
} {::foreach ::test_ns_3::p ::test_ns_3::cmd1 ::test_ns_2::cmd2 0 {}}
test namespace-34.6 {NamespaceWhichCmd, -command is default} {
    namespace eval test_ns_3 {
        list [namespace which foreach] \
             [namespace which p] \
             [namespace which cmd1] \
             [namespace which ::test_ns_2::cmd2]
    }
} {::foreach ::test_ns_3::p ::test_ns_3::cmd1 ::test_ns_2::cmd2}
test namespace-34.7 {NamespaceWhichCmd, variable lookup} {
    namespace eval test_ns_3 {
        list [namespace which -variable env] \
             [namespace which -variable v3] \
             [namespace which -variable ::test_ns_2::v2] \
             [catch {namespace which -variable ::test_ns_2::noSuchVar} msg] $msg
    }
} {::env ::test_ns_3::v3 ::test_ns_2::v2 0 {}}

test namespace-35.1 {FreeNsNameInternalRep, resulting ref count > 0} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1 {
        proc p {} {
            namespace delete [namespace current]
            return [namespace current]
        }
    }
    test_ns_1::p
} {::test_ns_1}
test namespace-35.2 {FreeNsNameInternalRep, resulting ref count == 0} {
    namespace eval test_ns_1 {
        proc q {} {
            return [namespace current]
        }
    }
    list [test_ns_1::q] \
         [namespace delete test_ns_1] \
         [catch {test_ns_1::q} msg] $msg
} {::test_ns_1 {} 1 {invalid command name "test_ns_1::q"}}

catch {unset x}
catch {unset y}
test namespace-36.1 {DupNsNameInternalRep} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1 {}
    set x "::test_ns_1"
    list [namespace parent $x] [set y $x] [namespace parent $y]
} {:: ::test_ns_1 ::}
catch {unset x}
catch {unset y}

test namespace-37.1 {SetNsNameFromAny, ns name found} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval test_ns_1::test_ns_2 {}
    namespace eval test_ns_1 {
        namespace children ::test_ns_1
    }
} {::test_ns_1::test_ns_2}
test namespace-37.2 {SetNsNameFromAny, ns name not found} -body {
    namespace eval test_ns_1 {
        namespace children ::test_ns_1::test_ns_foo
    }
} -returnCodes error -result {namespace "::test_ns_1::test_ns_foo" not found}

test namespace-38.1 {UpdateStringOfNsName} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    ;# Tcl_NamespaceObjCmd calls UpdateStringOfNsName to get subcmd name
    list [namespace eval {} {namespace current}] \
         [namespace eval {} {namespace current}]
} {:: ::}

test namespace-39.1 {NamespaceExistsCmd} {
    catch {namespace delete {*}[namespace children :: test_ns_*]}
    namespace eval ::test_ns_z::test_me { variable foo }
    list [namespace exists ::] \
	    [namespace exists ::bogus_namespace] \
	    [namespace exists ::test_ns_z] \
	    [namespace exists test_ns_z] \
	    [namespace exists ::test_ns_z::foo] \
	    [namespace exists ::test_ns_z::test_me] \
	    [namespace eval ::test_ns_z { namespace exists ::test_me }] \
	    [namespace eval ::test_ns_z { namespace exists test_me }] \
	    [namespace exists :::::test_ns_z]
} {1 0 1 1 0 1 0 1 1}
test namespace-39.2 {NamespaceExistsCmd error} {
    list [catch {namespace exists} msg] $msg
} {1 {wrong # args: should be "namespace exists name"}}
test namespace-39.3 {NamespaceExistsCmd error} {
    list [catch {namespace exists a b} msg] $msg
} {1 {wrong # args: should be "namespace exists name"}}

test namespace-40.1 {Ignoring namespace proc "unknown"} -setup {
    rename unknown _unknown
} -body {
    proc unknown args {return global}
    namespace eval ns {proc unknown args {return local}}
    list [namespace eval ns aaa bbb] [namespace eval ns aaa]
} -cleanup {
    rename unknown {}   
    rename _unknown unknown
    namespace delete ns
} -result {global global}

test namespace-41.1 {Shadowing byte-compiled commands, Bug: 231259} {
    set res {}
    namespace eval ns {
	set res {}
	proc test {} {
	    set ::g 0
	}  
	lappend ::res [test]
	proc set {a b} {
	    ::set a [incr b]
	}
	lappend ::res [test]
    }
    namespace delete ns
    set res
} {0 1}
test namespace-41.2 {Shadowing byte-compiled commands, Bug: 231259} {
    set res {}
    namespace eval ns {}
    proc ns::a {i} {
	variable b
	proc set args {return "New proc is called"}
	return [set b $i]
    }
    ns::a 1
    set res [ns::a 2]
    namespace delete ns
    set res
} {New proc is called}
test namespace-41.3 {Shadowing byte-compiled commands, Bugs: 231259, 729692} {
    set res {}
    namespace eval ns {
	variable b 0
    }
    proc ns::a {i} {
	variable b
	proc set args {return "New proc is called"}
	return [set b $i]
    }
    set res [list [ns::a 1] $ns::b]
    namespace delete ns
    set res
} {{New proc is called} 0}

# Ensembles (TIP#112)

test namespace-42.1 {ensembles: basic} {
    namespace eval ns {
	namespace export x
	proc x {} {format 1}
	namespace ensemble create
    }
    list [info command ns] [ns x] [namespace delete ns] [info command ns]
} {ns 1 {} {}}
test namespace-42.2 {ensembles: basic} {
    namespace eval ns {
	namespace export x
	proc x {} {format 1}
	namespace ensemble create
    }
    rename ns foo
    list [info command foo] [foo x] [namespace delete ns] [info command foo]
} {foo 1 {} {}}
test namespace-42.3 {ensembles: basic} {
    namespace eval ns {
	namespace export x*
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	namespace ensemble create
    }
    set result [list [ns x1] [ns x2]]
    lappend result [catch {ns x} msg] $msg
    rename ns {}
    lappend result [info command ns::x1]
    namespace delete ns
    lappend result [info command ns::x1]
} {1 2 1 {unknown or ambiguous subcommand "x": must be x1, or x2} ::ns::x1 {}}
test namespace-42.4 {ensembles: basic} -body {
    namespace eval ns {
	namespace export y*
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	namespace ensemble create
    }
    list [catch {ns x} msg] $msg
} -cleanup {
    namespace delete ns
} -result {1 {unknown subcommand "x": namespace ::ns does not export any commands}}
test namespace-42.5 {ensembles: basic} -body {
    namespace eval ns {
	namespace export x*
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	proc x3 {} {format 3}
	namespace ensemble create
    }
    list [catch {ns x} msg] $msg
} -cleanup {
    namespace delete ns
} -result {1 {unknown or ambiguous subcommand "x": must be x1, x2, or x3}}
test namespace-42.6 {ensembles: nested} -body {
    namespace eval ns {
	namespace export x*
	namespace eval x0 {
	    proc z {} {format 0}
	    namespace export z
	    namespace ensemble create
	}
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	proc x3 {} {format 3}
	namespace ensemble create
    }
    list [ns x0 z] [ns x1] [ns x2] [ns x3]
} -cleanup {
    namespace delete ns
} -result {0 1 2 3}
test namespace-42.7 {ensembles: nested} -body {
    namespace eval ns {
	namespace export x*
	namespace eval x0 {
	    proc z {} {list [info level] [info level 1]}
	    namespace export z
	    namespace ensemble create
	}
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	proc x3 {} {format 3}
	namespace ensemble create
    }
    list [ns x0 z] [ns x1] [ns x2] [ns x3]
} -cleanup {
    namespace delete ns
} -result {{1 ::ns::x0::z} 1 2 3}
test namespace-42.8 {ensembles: [Bug 1670091]} -setup {
    proc demo args {}
    variable target [list [namespace which demo] x]
    proc trial args {variable target; string length $target}
    trace add execution demo enter [namespace code trial]
    namespace ensemble create -command foo -map [list bar $target]
} -body {
    foo bar
} -cleanup {
    unset target
    rename demo {}
    rename trial {}
    rename foo {}
} -result {}

test namespace-43.1 {ensembles: dict-driven} {
    namespace eval ns {
	namespace export x*
	proc x1 {} {format 1}
	proc x2 {} {format 2}
	namespace ensemble create -map {a x1 b x2}
    }
    set result [list [catch {ns c} msg] $msg [namespace ensemble exists ns]]
    rename ns {}
    lappend result [namespace ensemble exists ns]
} {1 {unknown or ambiguous subcommand "c": must be a, or b} 1 0}
test namespace-43.2 {ensembles: dict-driven} -body {
    namespace eval ns {
	namespace export x*
	proc x1 {args} {list 1 $args}
	proc x2 {args} {list 2 [llength $args]}
	namespace ensemble create -map {
	    a ::ns::x1 b ::ns::x2 c {::ns::x1 .} d {::ns::x2 .}
	}
    }
    list [ns a] [ns b] [ns c] [ns c foo] [ns d] [ns d foo]
} -cleanup {
    namespace delete ns
} -result {{1 {}} {2 0} {1 .} {1 {. foo}} {2 1} {2 2}}
set SETUP {
    namespace eval ns {
	namespace export a b
	proc a args {format 1,[llength $args]}
	proc b args {format 2,[llength $args]}
	proc c args {format 3,[llength $args]}
	proc d args {format 4,[llength $args]}
	namespace ensemble create -subcommands {b c}
    }
}
test namespace-43.3 {ensembles: list-driven} -setup $SETUP -body {
    namespace delete ns
} -result {}
test namespace-43.4 {ensembles: list-driven} -setup $SETUP -body {
    ns a foo bar boo spong wibble
} -cleanup {namespace delete ns} -returnCodes error -result {unknown or ambiguous subcommand "a": must be b, or c}
test namespace-43.5 {ensembles: list-driven} -setup $SETUP -body {
    ns b foo bar boo spong wibble
} -cleanup {namespace delete ns} -result 2,5
test namespace-43.6 {ensembles: list-driven} -setup $SETUP -body {
    ns c foo bar boo spong wibble
} -cleanup {namespace delete ns} -result 3,5
test namespace-43.7 {ensembles: list-driven} -setup $SETUP -body {
    ns d foo bar boo spong wibble
} -cleanup {namespace delete ns} -returnCodes error -result {unknown or ambiguous subcommand "d": must be b, or c}
set SETUP {
    namespace eval ns {
	namespace export a b
	proc a args {format 1,[llength $args]}
	proc b args {format 2,[llength $args]}
	proc c args {format 3,[llength $args]}
	proc d args {format 4,[llength $args]}
	namespace ensemble create -subcommands {b c} -map {c ::ns::d}
    }
}
test namespace-43.8 {ensembles: list-and-map-driven} -setup $SETUP -body {
    namespace delete ns
} -result {}
test namespace-43.9 {ensembles: list-and-map-driven} -setup $SETUP -body {
    ns a foo bar boo spong wibble
} -cleanup {namespace delete ns} -returnCodes error -result {unknown or ambiguous subcommand "a": must be b, or c}
test namespace-43.10 {ensembles: list-and-map-driven} -setup $SETUP -body {
    ns b foo bar boo spong wibble
} -cleanup {namespace delete ns} -result 2,5
test namespace-43.11 {ensembles: list-and-map-driven} -setup $SETUP -body {
    ns c foo bar boo spong wibble
} -cleanup {namespace delete ns} -result 4,5
test namespace-43.12 {ensembles: list-and-map-driven} -setup $SETUP -body {
    ns d foo bar boo spong wibble
} -cleanup {namespace delete ns} -returnCodes error -result {unknown or ambiguous subcommand "d": must be b, or c}
set SETUP {
    namespace eval ns {
	namespace export *
	proc foo args {format bar}
	proc spong args {format wibble}
	namespace ensemble create -prefixes off
    }
}
test namespace-43.13 {ensembles: turn off prefixes} -setup $SETUP -body {
    namespace delete ns
} -result {}
test namespace-43.14 {ensembles: turn off prefixes} -setup $SETUP -body {
    ns fo
} -cleanup {namespace delete ns} -returnCodes error -result {unknown subcommand "fo": must be foo, or spong}
test namespace-43.15 {ensembles: turn off prefixes} -setup $SETUP -body {
    ns foo
} -cleanup {namespace delete ns} -result bar
test namespace-43.16 {ensembles: turn off prefixes} -setup $SETUP -body {
    ns s
} -cleanup {namespace delete ns} -returnCodes error -result {unknown subcommand "s": must be foo, or spong}
test namespace-43.17 {ensembles: turn off prefixes} -setup $SETUP -body {
    ns spong
} -cleanup {namespace delete ns} -result wibble

test namespace-44.1 {ensemble: errors} {
    list [catch {namespace ensemble} msg] $msg
} {1 {wrong # args: should be "namespace ensemble subcommand ?arg ...?"}}
test namespace-44.2 {ensemble: errors} {
    list [catch {namespace ensemble ?} msg] $msg
} {1 {bad subcommand "?": must be configure, create, or exists}}
test namespace-44.3 {ensemble: errors} {
    namespace eval ns {
	list [catch {namespace ensemble create -map x} msg] $msg
    }
} {1 {missing value to go with key}}
test namespace-44.4 {ensemble: errors} {
    namespace eval ns {
	list [catch {namespace ensemble create -map {x {}}} msg] $msg
    }
} {1 {ensemble subcommand implementations must be non-empty lists}}
test namespace-44.5 {ensemble: errors} -setup {
    namespace ensemble create -command foobar -subcommands {foobarcget foobarconfigure}
} -body {
    foobar foobarcon
} -cleanup {
    rename foobar {}
} -returnCodes error -result {invalid command name "::foobarconfigure"}
test namespace-44.6 {ensemble: errors} -returnCodes error -body {
    namespace ensemble create gorp
} -result {wrong # args: should be "namespace ensemble create ?option value ...?"}

test namespace-45.1 {ensemble: introspection} {
    namespace eval ns {
	namespace export x
	proc x {} {}
	namespace ensemble create
	set ::result [namespace ensemble configure ::ns]
    }
    namespace delete ns
    set result
} {-map {} -namespace ::ns -parameters {} -prefixes 1 -subcommands {} -unknown {}}
test namespace-45.2 {ensemble: introspection} {
    namespace eval ns {
	namespace export x
	proc x {} {}
	namespace ensemble create -map {A x}
	set ::result [namespace ensemble configure ::ns -map]
    }
    namespace delete ns
    set result
} {A ::ns::x}

test namespace-46.1 {ensemble: modification} {
    namespace eval ns {
	namespace export x
	proc x {} {format 123}
	# Ensemble maps A->x
	namespace ensemble create -command ns -map {A ::ns::x}
	set ::result [list [namespace ensemble configure ns -map] [ns A]]
	# Ensemble maps B->x
	namespace ensemble configure ns -map {B ::ns::x}
	lappend ::result [namespace ensemble configure ns -map] [ns B]
	# Ensemble maps x->x
	namespace ensemble configure ns -map {}
	lappend ::result [namespace ensemble configure ns -map] [ns x]
    }
    namespace delete ns
    set result
} {{A ::ns::x} 123 {B ::ns::x} 123 {} 123}
test namespace-46.2 {ensemble: ensembles really use current export list} {
    namespace eval ns {
	namespace export x1
	proc x1 {} {format 1}
	proc x2 {} {format 1}
	namespace ensemble create
    }
    catch {ns ?} msg; set result [list $msg]
    namespace eval ns {namespace export x*}
    catch {ns ?} msg; lappend result $msg
    rename ns::x1 {}
    catch {ns ?} msg; lappend result $msg
    namespace delete ns
    set result
} {{unknown or ambiguous subcommand "?": must be x1} {unknown or ambiguous subcommand "?": must be x1, or x2} {unknown or ambiguous subcommand "?": must be x2}}
test namespace-46.3 {ensemble: implementation errors} {
    namespace eval ns {
	variable count 0
	namespace ensemble create -map {
	    a {::lappend ::result}
	    b {::incr ::ns::count}
	}
    }
    set result {}
    lappend result [catch { ns } msg] $msg
    ns a [ns b 10]
    catch {rename p {}}
    rename ns p
    p a [p b 3000]
    lappend result $ns::count
    namespace delete ns
    lappend result [info command p]
} {1 {wrong # args: should be "ns subcommand ?arg ...?"} 10 3010 3010 {}}
test namespace-46.4 {ensemble: implementation errors} {
    namespace eval ns {
	namespace ensemble create
    }
    set result [info command ns]
    lappend result [catch {ns ?} msg] $msg
    namespace delete ns
    set result
} {ns 1 {unknown subcommand "?": namespace ::ns does not export any commands}}
test namespace-46.5 {ensemble: implementation errors} {
    namespace eval ns {
	namespace ensemble create -map {makeError ::error}
    }
    list [catch {ns makeError "an error happened"} msg] $msg $::errorInfo [namespace delete ns]
} {1 {an error happened} {an error happened
    while executing
"ns makeError "an error happened""} {}}
test namespace-46.6 {ensemble: implementation renames/deletes itself} {
    namespace eval ns {
	namespace ensemble create -map {to ::rename}
    }
    ns to ns foo
    foo to foo bar
    bar to bar spong
    spong to spong {}
    namespace delete ns
} {}
test namespace-46.7 {ensemble: implementation deletes its namespace} {
    namespace eval ns {
	namespace ensemble create -map {kill {::namespace delete}}
    }
    ns kill ns
} {}
test namespace-46.8 {ensemble: implementation deletes its namespace} {
    namespace eval ns {
	namespace export *
	proc foo {} {
	    variable x 1
	    bar
	    # Tricky; what is the correct return value anyway?
	    info exist x
	}
	proc bar {} {
	    namespace delete [namespace current]
	}
	namespace ensemble create
    }
    list [ns foo] [info exist ns::x]
} {1 0}
test namespace-46.9 {ensemble: configuring really configures things} {
    namespace eval ns {
	namespace ensemble create -map {a a} -prefixes 0
    }
    set result [list [catch {ns x} msg] $msg]
    namespace ensemble configure ns -map {b b}
    lappend result [catch {ns x} msg] $msg
    namespace delete ns
    set result
} {1 {unknown subcommand "x": must be a} 1 {unknown subcommand "x": must be b}}

test namespace-47.1 {ensemble: unknown handler} {
    set log {}
    namespace eval ns {
	namespace export {[a-z]*}
	proc Magic {ensemble subcmd args} {
	    global log
	    if {[string match {[a-z]*} $subcmd]} {
		lappend log "making $subcmd"
		proc $subcmd args {
		    global log
		    lappend log "running [info level 0]"
		    llength $args
		}
	    } else {
		lappend log "unknown $subcmd - args = $args"
		return -code error \
			"unknown or protected subcommand \"$subcmd\""
	    }
	}
	namespace ensemble create -unknown ::ns::Magic
    }
    set result {}
    lappend result [catch {ns a b c} msg] $msg
    lappend result [catch {ns a b c} msg] $msg
    lappend result [catch {ns b c d} msg] $msg
    lappend result [catch {ns c d e} msg] $msg
    lappend result [catch {ns Magic foo bar spong wibble} msg] $msg
    list $result [lsort [info commands ::ns::*]] $log [namespace delete ns]
} {{0 2 0 2 0 2 0 2 1 {unknown or protected subcommand "Magic"}} {::ns::Magic ::ns::a ::ns::b ::ns::c} {{making a} {running ::ns::a b c} {running ::ns::a b c} {making b} {running ::ns::b c d} {making c} {running ::ns::c d e} {unknown Magic - args = foo bar spong wibble}} {}}
test namespace-47.2 {ensemble: unknown handler} {
    namespace eval ns {
	namespace export {[a-z]*}
	proc Magic {ensemble subcmd args} {
	    error foobar
	}
	namespace ensemble create -unknown ::ns::Magic
    }
    list [catch {ns spong} msg] $msg $::errorInfo [namespace delete ns]
} {1 foobar {foobar
    while executing
"error foobar"
    (procedure "::ns::Magic" line 2)
    invoked from within
"::ns::Magic ::ns spong"
    (ensemble unknown subcommand handler)
    invoked from within
"ns spong"} {}}
test namespace-47.3 {ensemble: unknown handler} {
    namespace eval ns {
	variable count 0
	namespace export {[a-z]*}
	proc a {} {}
	proc c {} {}
	proc Magic {ensemble subcmd args} {
	    variable count
	    incr count
	    proc b {} {}
	}
	namespace ensemble create -unknown ::ns::Magic
    }
    list [catch {ns spong} msg] $msg $ns::count [namespace delete ns]
} {1 {unknown or ambiguous subcommand "spong": must be a, b, or c} 1 {}}
test namespace-47.4 {ensemble: unknown handler} {
    namespace eval ns {
	namespace export {[a-z]*}
	proc Magic {ensemble subcmd args} {
	    return -code break
	}
	namespace ensemble create -unknown ::ns::Magic
    }
    list [catch {ns spong} msg] $msg $::errorInfo [namespace delete ns]
} {1 {unknown subcommand handler returned bad code: break} {unknown subcommand handler returned bad code: break
    result of ensemble unknown subcommand handler: ::ns::Magic ::ns spong
    invoked from within
"ns spong"} {}}
test namespace-47.5 {ensemble: unknown handler} {
    namespace ensemble create -command foo -unknown bar
    proc bar {args} {
	global result target
	lappend result "LOG $args"
	return $target
    }
    set result {}
    set target {}
    lappend result [catch {foo bar} msg] $msg
    set target {lappend result boo hoo}
    lappend result [catch {foo bar} msg] $msg [namespace ensemble config foo]
    rename foo {}
    set result
} {{LOG ::foo bar} 1 {unknown subcommand "bar": namespace :: does not export any commands} {LOG ::foo bar} boo hoo 0 {{LOG ::foo bar} 1 {unknown subcommand "bar": namespace :: does not export any commands} {LOG ::foo bar} boo hoo} {-map {} -namespace :: -parameters {} -prefixes 1 -subcommands {} -unknown bar}}
test namespace-47.6 {ensemble: unknown handler} {
    namespace ensemble create -command foo -unknown bar
    proc bar {args} {
	return "\{"
    }
    set result [list [catch {foo bar} msg] $msg $::errorInfo]
    rename foo {}
    set result
} {1 {unmatched open brace in list} {unmatched open brace in list
    while parsing result of ensemble unknown subcommand handler
    invoked from within
"foo bar"}}
test namespace-47.7 {ensemble: unknown handler, commands with spaces} {
    namespace ensemble create -command foo -unknown bar
    proc bar {args} {
	list ::set ::x [join $args |]
    }
    set result [foo {one two three}]
    rename foo {}
    set result
} {::foo|one two three}
test namespace-47.8 {ensemble: unknown handler, commands with spaces} {
    namespace ensemble create -command foo -unknown {bar boo}
    proc bar {args} {
	list ::set ::x [join $args |]
    }
    set result [foo {one two three}]
    rename foo {}
    set result
} {boo|::foo|one two three}

test namespace-48.1 {ensembles and namespace import: unknown handler} {
    namespace eval foo {
	namespace export bar
	namespace ensemble create -command bar -unknown ::foo::u -subcomm x
	proc u {ens args} {
	    global result
	    lappend result $ens $args
	    namespace ensemble config $ens -subcommand {x y}
	}
	proc u2 {ens args} {
	    global result
	    lappend result $ens $args
	    namespace ensemble config ::bar -subcommand {x y z}
	}
	proc x args {
	    global result
	    lappend result XXX $args
	}
	proc y args {
	    global result
	    lappend result YYY $args
	}
	proc z args {
	    global result
	    lappend result ZZZ $args
	}
    }
    namespace import -force foo::bar
    set result [list [namespace ensemble config bar]]
    bar x 123
    bar y 456
    namespace ensemble config bar -unknown ::foo::u2
    bar z 789
    namespace delete foo
    set result
} {{-map {} -namespace ::foo -parameters {} -prefixes 1 -subcommands x -unknown ::foo::u} XXX 123 ::foo::bar {y 456} YYY 456 ::foo::bar {z 789} ZZZ 789}
test namespace-48.2 {ensembles and namespace import: exists} {
    namespace eval foo {
	namespace ensemble create -command ::foo::bar
	namespace export bar
    }
    set result     [namespace ensemble exist foo::bar]
    lappend result [namespace ensemble exist bar]
    namespace import foo::bar
    lappend result [namespace ensemble exist bar]
    rename foo::bar foo::bar2
    lappend result [namespace ensemble exist bar] \
	    [namespace ensemble exist spong]
    rename bar spong
    lappend result [namespace ensemble exist bar] \
	    [namespace ensemble exist spong]
    rename foo::bar2 {}
    lappend result [namespace ensemble exist spong]
    namespace delete foo
    set result
} {1 0 1 1 0 0 1 0}
test namespace-48.3 {ensembles and namespace import: config} {
    catch {rename spong {}}
    namespace eval foo {
	namespace ensemble create -command ::foo::bar
	namespace export bar boo
	proc boo {} {}
    }
    namespace import foo::bar foo::boo
    set result [namespace ensemble config bar -namespace]
    lappend result [catch {namespace ensemble config boo} msg] $msg
    lappend result [catch {namespace ensemble config spong} msg] $msg
    namespace delete foo
    set result
} {::foo 1 {"boo" is not an ensemble command} 1 {unknown command "spong"}}

test namespace-49.1 {ensemble subcommand caching} -body {
    namespace ens cre -command a -map {b {lappend result 1}}
    namespace ens cre -command c -map {b {lappend result 2}}
    proc x {} {a b; c b; a b; c b}
    x
} -result {1 2 1 2} -cleanup {
    rename a {}
    rename c {}
    rename x {}
}
test namespace-49.2 {strange delete crash} -body {
    namespace eval foo {namespace ensemble create -command ::bar}
    trace add command ::bar delete DeleteTrace
    proc DeleteTrace {old new op} {
	trace remove command ::bar delete DeleteTrace
	rename $old ""
	# This next line caused a bus error in [Bug 1220058]
	namespace delete foo
    }
    rename ::bar ""
} -result "" -cleanup {
    rename DeleteTrace ""
}

test namespace-50.1 {ensembles affect proc arguments error messages} -body {
    namespace ens cre -command a -map {b {bb foo}}
    proc bb {c d {e f} args} {list $c $args}
    a b
} -returnCodes error -result "wrong # args: should be \"a b d ?e? ?arg ...?\"" -cleanup {
    rename a {}
    rename bb {}
}
test namespace-50.2 {ensembles affect WrongNumArgs error messages} -body {
    namespace ens cre -command a -map {b {string is}}
    a b boolean
} -returnCodes error -result "wrong # args: should be \"a b class ?-strict? ?-failindex var? str\"" -cleanup {
    rename a {}
}
test namespace-50.3 {chained ensembles affect error messages} -body {
    namespace ens cre -command a -map {b c}
    namespace ens cre -command c -map {d e}
    proc e f {}
    a b d
} -returnCodes error -result "wrong # args: should be \"a b d f\"" -cleanup {
    rename a {}
    rename c {}
}
test namespace-50.4 {chained ensembles affect error messages} -body {
    namespace ens cre -command a -map {b {c d}}
    namespace ens cre -command c -map {d {e f}}
    proc e f {}
    a b d
} -returnCodes error -result "wrong # args: should be \"a b\"" -cleanup {
    rename a {}
    rename c {}
}

test namespace-51.1 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
	namespace path ::test_ns_1
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    test_ns_1::test_ns_2::pathtestA
} -result "global,2,global," -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.2 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    namespace path ::test_ns_1
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    ::test_ns_1::test_ns_2::pathtestA
} -result "1,2,global,::test_ns_1" -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.3 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    set result [::test_ns_1::test_ns_2::pathtestA]
    namespace eval ::test_ns_1::test_ns_2 {
	namespace path ::test_ns_1
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
    rename ::test_ns_1::pathtestB {}
    lappend result [::test_ns_1::test_ns_2::pathtestA]
} -result "global,2,global, 1,2,global,::test_ns_1 global,2,global,::test_ns_1" -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.4 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    set result [::test_ns_1::test_ns_2::pathtestA]
    namespace eval ::test_ns_1::test_ns_2 {
	namespace path ::test_ns_1
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
    namespace eval ::test_ns_1::test_ns_2 {
	namespace path {}
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
} -result "global,2,global, 1,2,global,::test_ns_1 global,2,global," -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.5 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	    namespace path ::test_ns_1
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
	proc pathtestD {} {
	    return 1
	}
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    set result [::test_ns_1::test_ns_2::pathtestA]
    namespace eval ::test_ns_1::test_ns_2 {
	namespace path {:: ::test_ns_1}
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
    rename ::test_ns_1::test_ns_2::pathtestC {}
    lappend result [::test_ns_1::test_ns_2::pathtestA]
} -result "1,2,1,::test_ns_1 {global,2,global,:: ::test_ns_1} {global,1,global,:: ::test_ns_1}" -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.6 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc pathtestA {} {
		::return [pathtestB],[pathtestC],[pathtestD],[namespace path]
	    }
	    proc pathtestC {} {
		::return 2
	    }
	    namespace path ::test_ns_1
	}
	proc pathtestB {} {
	    return 1
	}
	proc pathtestC {} {
	    return 1
	}
	proc pathtestD {} {
	    return 1
	}
    }
    proc ::pathtestB {} {
	return global
    }
    proc ::pathtestD {} {
	return global
    }
    set result [::test_ns_1::test_ns_2::pathtestA]
    namespace eval ::test_ns_1::test_ns_2 {
	namespace path {:: ::test_ns_1}
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
    rename ::test_ns_1::test_ns_2::pathtestC {}
    lappend result [::test_ns_1::test_ns_2::pathtestA]
    proc ::pathtestC {} {
	return global
    }
    lappend result [::test_ns_1::test_ns_2::pathtestA]
} -result "1,2,1,::test_ns_1 {global,2,global,:: ::test_ns_1} {global,1,global,:: ::test_ns_1} {global,global,global,:: ::test_ns_1}" -cleanup {
    namespace delete ::test_ns_1
    catch {rename ::pathtestB {}}
    catch {rename ::pathtestD {}}
}
test namespace-51.7 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
    }
    namespace eval ::test_ns_2 {
	namespace path ::test_ns_1
	proc getpath {} {namespace path}
    }
    list [::test_ns_2::getpath] [namespace delete ::test_ns_1] [::test_ns_2::getpath]
} -result {::test_ns_1 {} {}} -cleanup {
    catch {namespace delete ::test_ns_1}
    namespace delete ::test_ns_2
}
test namespace-51.8 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
    }
    namespace eval ::test_ns_2 {
    }
    namespace eval ::test_ns_3 {
    }
    namespace eval ::test_ns_4 {
	namespace path {::test_ns_1 ::test_ns_2 ::test_ns_3}
	proc getpath {} {namespace path}
    }
    list [::test_ns_4::getpath] [namespace delete ::test_ns_2] [::test_ns_4::getpath]
} -result {{::test_ns_1 ::test_ns_2 ::test_ns_3} {} {::test_ns_1 ::test_ns_3}} -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
    catch {namespace delete ::test_ns_4}
}
test namespace-51.9 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
    }
    namespace eval ::test_ns_2 {
    }
    namespace eval ::test_ns_3 {
    }
    namespace eval ::test_ns_4 {
	namespace path {::test_ns_1 ::test_ns_2 ::test_ns_3}
	proc getpath {} {namespace path}
    }
    list [::test_ns_4::getpath] [namespace delete ::test_ns_2] [namespace eval ::test_ns_2 {}] [::test_ns_4::getpath]
} -result {{::test_ns_1 ::test_ns_2 ::test_ns_3} {} {} {::test_ns_1 ::test_ns_3}} -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
    catch {namespace delete ::test_ns_4}
}
test namespace-51.10 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	namespace path does::not::exist
    }
} -returnCodes error -result {namespace "does::not::exist" not found in "::test_ns_1"} -cleanup {
    catch {namespace delete ::test_ns_1}
}
test namespace-51.11 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	proc foo {} {return 1}
    }
    namespace eval ::test_ns_2 {
	proc foo {} {return 2}
    }
    namespace eval ::test_ns_3 {
	namespace path ::test_ns_1
    }
    namespace eval ::test_ns_4 {
	namespace path {::test_ns_3 ::test_ns_2}
	foo
    }
} -result 2 -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
    catch {namespace delete ::test_ns_4}
}
test namespace-51.12 {name resolution path control} -body {
    namespace eval ::test_ns_1 {
	proc foo {} {return 1}
    }
    namespace eval ::test_ns_2 {
	proc foo {} {return 2}
    }
    namespace eval ::test_ns_3 {
	namespace path ::test_ns_1
    }
    namespace eval ::test_ns_4 {
	namespace path {::test_ns_3 ::test_ns_2}
	list [foo] [namespace delete ::test_ns_3] [foo]
    }
} -result {2 {} 2} -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
    catch {namespace delete ::test_ns_4}
}
test namespace-51.13 {name resolution path control} -body {
    set ::result {}
    namespace eval ::test_ns_1 {
	proc foo {} {lappend ::result 1}
    }
    namespace eval ::test_ns_2 {
	proc foo {} {lappend ::result 2}
	trace add command foo delete "namespace eval ::test_ns_3 foo;#"
    }
    namespace eval ::test_ns_3 {
	proc foo {} {
	    lappend ::result 3
	    namespace delete [namespace current]
	    ::test_ns_4::bar
	}
    }
    namespace eval ::test_ns_4 {
	namespace path {::test_ns_2 ::test_ns_3 ::test_ns_1}
	proc bar {} {
	    list [foo] [namespace delete ::test_ns_2] [foo]
	}
	bar
    }
    # Should the result be "2 {} {2 3 2 1}" instead?
} -result {2 {} {2 3 1 1}} -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
    catch {namespace delete ::test_ns_4}
}
test namespace-51.14 {name resolution path control} -setup {
    foreach cmd [info commands foo*] {
	rename $cmd {}
    }
    namespace eval ::test_ns_1 {}
    namespace eval ::test_ns_2 {}
    namespace eval ::test_ns_3 {}
} -body {
    proc foo0 {} {}
    proc ::test_ns_1::foo1 {} {}
    proc ::test_ns_2::foo2 {} {}
    namespace eval ::test_ns_3 {
	variable result {}
	lappend result [info commands foo*]
	namespace path {::test_ns_1 ::test_ns_2}
	lappend result [info commands foo*]
	proc foo2 {} {}
	lappend result [info commands foo*]
	rename foo2 {}
	lappend result [info commands foo*]
	namespace delete ::test_ns_1
	lappend result [info commands foo*]
    }
} -cleanup {
    catch {namespace delete ::test_ns_1}
    catch {namespace delete ::test_ns_2}
    catch {namespace delete ::test_ns_3}
} -result {foo0 {foo1 foo2 foo0} {foo2 foo1 foo0} {foo1 foo2 foo0} {foo2 foo0}}
test namespace-51.15 {namespace resolution path control} -body {
    namespace eval ::test_ns_2 {
	proc foo {} {return 2}
    }
    namespace eval ::test_ns_1 {
	namespace eval test_ns_2 {
	    proc foo {} {return 1_2}
	}
	namespace eval test_ns_3 {
	    namespace path ::test_ns_1
	    test_ns_2::foo
	}
    }
} -result 1_2 -cleanup {
    namespace delete ::test_ns_1
    namespace delete ::test_ns_2
}
test namespace-51.16 {Bug 1566526} {
    interp create slave
    slave eval namespace eval demo namespace path ::
    interp delete slave
} {}
test namespace-51.17 {resolution epoch handling: Bug 2898722} -setup {
    set result {}
    catch {namespace delete ::a}
} -body {
    namespace eval ::a {
	proc c {} {lappend ::result A}
	c
	namespace eval b {
	    variable d c
	    lappend ::result [catch { $d }]
	}
	lappend ::result .
	namespace eval b {
	    namespace path [namespace parent]
	    $d;[format %c 99]
	}
	lappend ::result .
	namespace eval b {
	    proc c {} {lappend ::result B}
	    $d;[format %c 99]
	}
	lappend ::result .
    }
    namespace eval ::a::b {
	$d;[format %c 99]
	lappend ::result .
	proc ::c {} {lappend ::result G}
	$d;[format %c 99]
	lappend ::result .
	rename ::a::c {}
	$d;[format %c 99]
	lappend ::result .
	rename ::a::b::c {}
	$d;[format %c 99]
    }
} -cleanup {
    namespace delete ::a
    catch {rename ::c {}}
    unset result
} -result {A 1 . A A . B B . B B . B B . B B . G G}
test namespace-51.18 {Bug 3185407} -setup {
    namespace eval ::test_ns_1 {}
} -body {
    namespace eval ::test_ns_1 {
	variable result {}
	namespace eval ns {proc foo {} {}}
	namespace eval ns2 {proc foo {} {}}
	namespace path {ns ns2}
	variable x foo
	lappend result [namespace which $x]
	proc foo {} {}
	lappend result [namespace which $x]
    }
} -cleanup {
    namespace delete ::test_ns_1
} -result {::test_ns_1::ns::foo ::test_ns_1::foo}

# TIP 181 - namespace unknown tests
test namespace-52.1 {unknown: default handler ::unknown} {
    set result [list [namespace eval foobar { namespace unknown }]]
    lappend result [namespace eval :: { namespace unknown }]
    namespace delete foobar
    set result
} {{} ::unknown}
test namespace-52.2 {unknown: default resolution global} {
    proc ::foo {} { return "GLOBAL" }
    namespace eval ::bar { proc foo {} { return "NAMESPACE" } }
    namespace eval ::bar::jim { proc test {} { foo } }
    set result [::bar::jim::test]
    namespace delete ::bar
    rename ::foo {}
    set result
} {GLOBAL}
test namespace-52.3 {unknown: default resolution local} {
    proc ::foo {} { return "GLOBAL" }
    namespace eval ::bar {
	proc foo {} { return "NAMESPACE" }
	proc test {} { foo }
    }
    set result [::bar::test]
    namespace delete ::bar
    rename ::foo {}
    set result
} {NAMESPACE}
test namespace-52.4 {unknown: set handler} {
    namespace eval foo {
	namespace unknown [list dispatch]
	proc dispatch {args} { return $args }
	proc test {} {
	    UnknownCmd a b c
	}
    }
    set result [foo::test]
    namespace delete foo
    set result
} {UnknownCmd a b c}
test namespace-52.5 {unknown: search path before unknown is unaltered} {
    proc ::test2 {args} { return "TEST2: $args" }
    namespace eval foo {
	namespace unknown [list dispatch]
	proc dispatch {args} { return "UNKNOWN: $args" }
	proc test1 {args} { return "TEST1: $args" }
	proc test {} {
	    set result [list [test1 a b c]]
	    lappend result [test2 a b c]
	    lappend result [test3 a b c]
	    return $result
	}
    }
    set result [foo::test]
    namespace delete foo
    rename ::test2 {}
    set result
} {{TEST1: a b c} {TEST2: a b c} {UNKNOWN: test3 a b c}}
test namespace-52.6 {unknown: deleting handler restores default} {
    rename ::unknown ::_unknown_orig
    proc ::unknown {args} { return "DEFAULT: $args" }
    namespace eval foo {
	namespace unknown dummy
	namespace unknown {}
    }
    set result [namespace eval foo { dummy a b c }]
    rename ::unknown {}
    rename ::_unknown_orig ::unknown
    namespace delete foo
    set result
} {DEFAULT: dummy a b c}
test namespace-52.7 {unknown: setting global unknown handler} {
    proc ::myunknown {args} { return "MYUNKNOWN: $args" }
    namespace eval :: { namespace unknown ::myunknown }
    set result [namespace eval foo { dummy a b c }]
    namespace eval :: { namespace unknown {} }
    rename ::myunknown {}
    namespace delete foo
    set result
} {MYUNKNOWN: dummy a b c}
test namespace-52.8 {unknown: destroying and redefining global namespace} {
    set i [interp create]
    $i hide proc
    $i hide namespace
    $i hide return
    $i invokehidden namespace delete ::
    $i expose return
    $i invokehidden proc unknown args { return "FINE" }
    $i eval { foo bar bob }
} {FINE}
test namespace-52.9 {unknown: refcounting} -setup {
    proc this args {
	unset args		;# stop sharing
	set copy [namespace unknown]
	string length $copy	;# shimmer away list rep
	info level 0
    }
    set handler [namespace unknown]
    namespace unknown {this is a test}
    catch {rename noSuchCommand {}}
} -body {
    noSuchCommand
} -cleanup {
    namespace unknown $handler
    rename this {}
} -result {this is a test noSuchCommand}
testConstraint testevalobjv [llength [info commands testevalobjv]]
test namespace-52.10 {unknown: with TCL_EVAL_GLOBAL} -constraints {
    testevalobjv
} -setup {
    rename ::unknown unknown.save
    proc ::unknown args {
	set caller [uplevel 1 {namespace current}]
	namespace eval $caller {
	    variable foo
	    return $foo
	}
    }
    catch {rename ::noSuchCommand {}}
} -body {
    namespace eval :: {
	variable foo SUCCESS
    }
    namespace eval test_ns_1 {
	variable foo FAIL
	testevalobjv 1 noSuchCommand
    }
} -cleanup {
    unset -nocomplain ::foo
    namespace delete test_ns_1
    rename ::unknown {}
    rename unknown.save ::unknown
} -result SUCCESS
test namespace-52.11 {unknown: with TCL_EVAL_INVOKE} -setup {
    set handler [namespace eval :: {namespace unknown}]
    namespace eval :: {namespace unknown unknown}
    rename ::unknown unknown.save
    namespace eval :: {
	proc unknown args {
	    return SUCCESS
	}
    }
    catch {rename ::noSuchCommand {}}
    set ::slave [interp create]
} -body {
    $::slave alias bar noSuchCommand
    namespace eval test_ns_1 {
	namespace unknown unknown
	proc unknown args {
	    return FAIL
	}
	$::slave eval bar
    }
} -cleanup {
    interp delete $::slave
    unset ::slave
    namespace delete test_ns_1
    rename ::unknown {}
    rename unknown.save ::unknown
    namespace eval :: [list namespace unknown $handler]
} -result SUCCESS
test namespace-52.12 {unknown: error case must not reset handler} -body {
    namespace eval foo {
	namespace unknown ok
	catch {namespace unknown {{}{}{}}}
	namespace unknown
    }
} -cleanup {
    namespace delete foo
} -result ok

# TIP 314 - ensembles with parameters
test namespace-53.1 {ensembles: parameters} {
    namespace eval ns {
	namespace export x
	proc x {para} {list 1 $para}
	namespace ensemble create -parameters {para1}
    }
    list [info command ns] [ns bar x] [namespace delete ns] [info command ns]
} {ns {1 bar} {} {}}
test namespace-53.2 {ensembles: parameters} -setup {
    namespace eval ns {
	namespace export x
	proc x {para} {list 1 $para}
	namespace ensemble create
    }
} -body {
    namespace ensemble configure ns -parameters {para1}
    rename ns foo
    list [info command foo] [foo bar x] [namespace delete ns] [info command foo]
} -result {foo {1 bar} {} {}}
test namespace-53.3 {ensembles: parameters} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {para} {list 1 $para}
	proc x2 {para} {list 2 $para}
	namespace ensemble create -parameters param1
    }
} -body {
    set result [list [ns x2 x1] [ns x1 x2]]
    lappend result [catch {ns x} msg] $msg
    lappend result [catch {ns x x} msg] $msg
    rename ns {}
    lappend result [info command ns::x1]
    namespace delete ns
    lappend result [info command ns::x1]
} -result\
   {{1 x2} {2 x1}\
    1 {wrong # args: should be "ns param1 subcommand ?arg ...?"}\
    1 {unknown or ambiguous subcommand "x": must be x1, or x2}\
    ::ns::x1 {}}
test namespace-53.4 {ensembles: parameters} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {a1 a2} {list 1 $a1 $a2}
	proc x2 {a1 a2} {list 2 $a1 $a2}
	proc x3 {a1 a2} {list 3 $a1 $a2}
	namespace ensemble create
    }
} -body {
    set result {}
    lappend result [ns x1 x2 x3]
    namespace ensemble configure ns -parameters p1
    lappend result [ns x1 x2 x3]
    namespace ensemble configure ns -parameters {p1 p2}
    lappend result [ns x1 x2 x3]
} -cleanup {
    namespace delete ns
} -result {{1 x2 x3} {2 x1 x3} {3 x1 x2}}
test namespace-53.5 {ensembles: parameters} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {para} {list 1 $para}
	proc x2 {para} {list 2 $para}
	proc x3 {para} {list 3 $para}
	namespace ensemble create
    }
} -body {
    set result [list [catch {ns x x1} msg] $msg]
    lappend result [catch {ns x1 x} msg] $msg
    namespace ensemble configure ns -parameters p1
    lappend result [catch {ns x1 x} msg] $msg
    lappend result [catch {ns x x1} msg] $msg
} -cleanup {
    namespace delete ns
} -result\
   {1 {unknown or ambiguous subcommand "x": must be x1, x2, or x3}\
    0 {1 x}\
    1 {unknown or ambiguous subcommand "x": must be x1, x2, or x3}\
    0 {1 x}}
test namespace-53.6 {ensembles: nested} -setup {
    namespace eval ns {
	namespace export x*
	namespace eval x0 {
	    proc z {args} {list 0 $args}
	    namespace export z
	    namespace ensemble create
	}
	proc x1 {args} {list 1 $args}
	proc x2 {args} {list 2 $args}
	proc x3 {args} {list 3 $args}
	namespace ensemble create -parameters p
    }
} -body {
    list [ns z x0] [ns z x1] [ns z x2] [ns z x3]
} -cleanup {
    namespace delete ns
} -result {{0 {}} {1 z} {2 z} {3 z}}
test namespace-53.7 {ensembles: parameters & wrong # args} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {a1 a2 a3 a4} {list x1 $a1 $a2 $a3 $a4}
	namespace ensemble create -parameters p1
    }
} -body {
    set result {}
    lappend result [catch {ns} msg] $msg
    lappend result [catch {ns x1} msg] $msg
    lappend result [catch {ns x1 x1} msg] $msg
    lappend result [catch {ns x1 x1 x1} msg] $msg
    lappend result [catch {ns x1 x1 x1 x1} msg] $msg
    lappend result [catch {ns x1 x1 x1 x1 x1} msg] $msg
} -cleanup {
    namespace delete ns
} -result\
   {1 {wrong # args: should be "ns p1 subcommand ?arg ...?"}\
    1 {wrong # args: should be "ns p1 subcommand ?arg ...?"}\
    1 {wrong # args: should be "ns x1 x1 a2 a3 a4"}\
    1 {wrong # args: should be "ns x1 x1 a2 a3 a4"}\
    1 {wrong # args: should be "ns x1 x1 a2 a3 a4"}\
    0 {x1 x1 x1 x1 x1}}
test namespace-53.8 {ensemble: unknown handler changing -parameters} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {a1} {list 1 $a1}
	proc Magic {ensemble subcmd args} {
	    namespace ensemble configure $ensemble\
              -parameters [lrange p1 [llength [
                namespace ensemble configure $ensemble -parameters
              ]] 0]
            list
	}
	namespace ensemble create -unknown ::ns::Magic
    }
} -body {
    set result {}
    lappend result [catch {ns x1 x2} msg] $msg [namespace ensemble configure ns -parameters]
    lappend result [catch {ns x2 x1} msg] $msg [namespace ensemble configure ns -parameters]
    lappend result [catch {ns x2 x3} msg] $msg [namespace ensemble configure ns -parameters]
} -cleanup {
    namespace delete ns
} -result\
   {0 {1 x2} {}\
    0 {1 x2} p1\
    1 {unknown or ambiguous subcommand "x2": must be x1} {}}
test namespace-53.9 {ensemble: unknown handler changing -parameters,\
  thereby eating all args} -setup {
    namespace eval ns {
	namespace export x*
	proc x1 {args} {list 1 $args}
	proc Magic {ensemble subcmd args} {
	    namespace ensemble configure $ensemble\
              -parameters {p1 p2 p3 p4 p5}
            list
	}
	namespace ensemble create -unknown ::ns::Magic
    }
} -body {
    set result {}
    lappend result [catch {ns x1 x2} msg] $msg [namespace ensemble configure ns -parameters]
    lappend result [catch {ns x2 x1} msg] $msg [namespace ensemble configure ns -parameters]
    lappend result [catch {ns a1 a2 a3 a4 a5 x1} msg] $msg [namespace ensemble configure ns -parameters]
} -cleanup {
    namespace delete ns
} -result\
   {0 {1 x2} {}\
    1 {wrong # args: should be "ns p1 p2 p3 p4 p5 subcommand ?arg ...?"} {p1 p2 p3 p4 p5}\
    0 {1 {a1 a2 a3 a4 a5}} {p1 p2 p3 p4 p5}}
test namespace-53.10 {ensembles: nested rewrite} -setup {
    namespace eval ns {
	namespace export x
	namespace eval x {
	    proc z0 {} {list 0}
	    proc z1 {a1} {list 1 $a1}
	    proc z2 {a1 a2} {list 2 $a1 $a2}
	    proc z3 {a1 a2 a3} {list 3 $a1 $a2 $a3}
	    namespace export z*
	    namespace ensemble create
	}
	namespace ensemble create -parameters p
    }
} -body {
    set result {}
    # In these cases, parsing the subensemble does not grab a new word.
    lappend result [catch {ns z0 x} msg] $msg
    lappend result [catch {ns z1 x} msg] $msg
    lappend result [catch {ns z2 x} msg] $msg
    lappend result [catch {ns z2 x v} msg] $msg
    namespace ensemble configure ns::x -parameters q1
    # In these cases, parsing the subensemble grabs a new word.
    lappend result [catch {ns v x z0} msg] $msg
    lappend result [catch {ns v x z1} msg] $msg
    lappend result [catch {ns v x z2} msg] $msg
    lappend result [catch {ns v x z2 v2} msg] $msg
} -cleanup {
    namespace delete ns
} -result\
   {0 0\
    1 {wrong # args: should be "ns z1 x a1"}\
    1 {wrong # args: should be "ns z2 x a1 a2"}\
    1 {wrong # args: should be "ns z2 x a1 a2"}\
    1 {wrong # args: should be "::ns::x::z0"}\
    0 {1 v}\
    1 {wrong # args: should be "ns v x z2 a2"}\
    0 {2 v v2}}

test namespace-54.1 {leak on namespace deletion} -constraints {memory} \
-setup {
    proc getbytes {} {
	set lines [split [memory info] "\n"]
	lindex $lines 3 3
    }
} -body {
    set end [getbytes]
    for {set i 0} {$i < 5} {incr i} {
	set ns ::y$i
	namespace eval $ns {}
	namespace delete $ns
	set start $end
	set end [getbytes]
    }
    set leakedBytes [expr {$end - $start}]
} -cleanup {
    rename getbytes {}
    unset i ns start end
} -result 0

# cleanup
catch {rename cmd1 {}}
catch {unset l}
catch {unset msg}
catch {unset trigger}
namespace delete {*}[namespace children :: test_ns_*]
::tcltest::cleanupTests
return

# Local Variables:
# mode: tcl
# End:
a>
<a id='n1735' href='#n1735'>1735</a>
<a id='n1736' href='#n1736'>1736</a>
<a id='n1737' href='#n1737'>1737</a>
<a id='n1738' href='#n1738'>1738</a>
<a id='n1739' href='#n1739'>1739</a>
<a id='n1740' href='#n1740'>1740</a>
<a id='n1741' href='#n1741'>1741</a>
<a id='n1742' href='#n1742'>1742</a>
<a id='n1743' href='#n1743'>1743</a>
<a id='n1744' href='#n1744'>1744</a>
<a id='n1745' href='#n1745'>1745</a>
<a id='n1746' href='#n1746'>1746</a>
<a id='n1747' href='#n1747'>1747</a>
<a id='n1748' href='#n1748'>1748</a>
<a id='n1749' href='#n1749'>1749</a>
<a id='n1750' href='#n1750'>1750</a>
<a id='n1751' href='#n1751'>1751</a>
<a id='n1752' href='#n1752'>1752</a>
<a id='n1753' href='#n1753'>1753</a>
<a id='n1754' href='#n1754'>1754</a>
<a id='n1755' href='#n1755'>1755</a>
<a id='n1756' href='#n1756'>1756</a>
<a id='n1757' href='#n1757'>1757</a>
<a id='n1758' href='#n1758'>1758</a>
<a id='n1759' href='#n1759'>1759</a>
<a id='n1760' href='#n1760'>1760</a>
<a id='n1761' href='#n1761'>1761</a>
<a id='n1762' href='#n1762'>1762</a>
<a id='n1763' href='#n1763'>1763</a>
<a id='n1764' href='#n1764'>1764</a>
<a id='n1765' href='#n1765'>1765</a>
<a id='n1766' href='#n1766'>1766</a>
<a id='n1767' href='#n1767'>1767</a>
<a id='n1768' href='#n1768'>1768</a>
<a id='n1769' href='#n1769'>1769</a>
<a id='n1770' href='#n1770'>1770</a>
<a id='n1771' href='#n1771'>1771</a>
<a id='n1772' href='#n1772'>1772</a>
<a id='n1773' href='#n1773'>1773</a>
<a id='n1774' href='#n1774'>1774</a>
<a id='n1775' href='#n1775'>1775</a>
<a id='n1776' href='#n1776'>1776</a>
<a id='n1777' href='#n1777'>1777</a>
<a id='n1778' href='#n1778'>1778</a>
<a id='n1779' href='#n1779'>1779</a>
<a id='n1780' href='#n1780'>1780</a>
<a id='n1781' href='#n1781'>1781</a>
<a id='n1782' href='#n1782'>1782</a>
<a id='n1783' href='#n1783'>1783</a>
<a id='n1784' href='#n1784'>1784</a>
<a id='n1785' href='#n1785'>1785</a>
<a id='n1786' href='#n1786'>1786</a>
<a id='n1787' href='#n1787'>1787</a>
<a id='n1788' href='#n1788'>1788</a>
<a id='n1789' href='#n1789'>1789</a>
<a id='n1790' href='#n1790'>1790</a>
<a id='n1791' href='#n1791'>1791</a>
<a id='n1792' href='#n1792'>1792</a>
<a id='n1793' href='#n1793'>1793</a>
<a id='n1794' href='#n1794'>1794</a>
<a id='n1795' href='#n1795'>1795</a>
<a id='n1796' href='#n1796'>1796</a>
<a id='n1797' href='#n1797'>1797</a>
<a id='n1798' href='#n1798'>1798</a>
<a id='n1799' href='#n1799'>1799</a>
<a id='n1800' href='#n1800'>1800</a>
<a id='n1801' href='#n1801'>1801</a>
<a id='n1802' href='#n1802'>1802</a>
<a id='n1803' href='#n1803'>1803</a>
<a id='n1804' href='#n1804'>1804</a>
<a id='n1805' href='#n1805'>1805</a>
<a id='n1806' href='#n1806'>1806</a>
<a id='n1807' href='#n1807'>1807</a>
<a id='n1808' href='#n1808'>1808</a>
<a id='n1809' href='#n1809'>1809</a>
<a id='n1810' href='#n1810'>1810</a>
<a id='n1811' href='#n1811'>1811</a>
<a id='n1812' href='#n1812'>1812</a>
<a id='n1813' href='#n1813'>1813</a>
<a id='n1814' href='#n1814'>1814</a>
<a id='n1815' href='#n1815'>1815</a>
<a id='n1816' href='#n1816'>1816</a>
<a id='n1817' href='#n1817'>1817</a>
<a id='n1818' href='#n1818'>1818</a>
<a id='n1819' href='#n1819'>1819</a>
<a id='n1820' href='#n1820'>1820</a>
<a id='n1821' href='#n1821'>1821</a>
<a id='n1822' href='#n1822'>1822</a>
<a id='n1823' href='#n1823'>1823</a>
<a id='n1824' href='#n1824'>1824</a>
<a id='n1825' href='#n1825'>1825</a>
<a id='n1826' href='#n1826'>1826</a>
<a id='n1827' href='#n1827'>1827</a>
<a id='n1828' href='#n1828'>1828</a>
<a id='n1829' href='#n1829'>1829</a>
<a id='n1830' href='#n1830'>1830</a>
<a id='n1831' href='#n1831'>1831</a>
<a id='n1832' href='#n1832'>1832</a>
<a id='n1833' href='#n1833'>1833</a>
<a id='n1834' href='#n1834'>1834</a>
<a id='n1835' href='#n1835'>1835</a>
<a id='n1836' href='#n1836'>1836</a>
<a id='n1837' href='#n1837'>1837</a>
<a id='n1838' href='#n1838'>1838</a>
<a id='n1839' href='#n1839'>1839</a>
<a id='n1840' href='#n1840'>1840</a>
<a id='n1841' href='#n1841'>1841</a>
<a id='n1842' href='#n1842'>1842</a>
<a id='n1843' href='#n1843'>1843</a>
<a id='n1844' href='#n1844'>1844</a>
<a id='n1845' href='#n1845'>1845</a>
<a id='n1846' href='#n1846'>1846</a>
<a id='n1847' href='#n1847'>1847</a>
<a id='n1848' href='#n1848'>1848</a>
<a id='n1849' href='#n1849'>1849</a>
<a id='n1850' href='#n1850'>1850</a>
<a id='n1851' href='#n1851'>1851</a>
<a id='n1852' href='#n1852'>1852</a>
<a id='n1853' href='#n1853'>1853</a>
<a id='n1854' href='#n1854'>1854</a>
<a id='n1855' href='#n1855'>1855</a>
<a id='n1856' href='#n1856'>1856</a>
<a id='n1857' href='#n1857'>1857</a>
<a id='n1858' href='#n1858'>1858</a>
<a id='n1859' href='#n1859'>1859</a>
<a id='n1860' href='#n1860'>1860</a>
<a id='n1861' href='#n1861'>1861</a>
<a id='n1862' href='#n1862'>1862</a>
<a id='n1863' href='#n1863'>1863</a>
<a id='n1864' href='#n1864'>1864</a>
<a id='n1865' href='#n1865'>1865</a>
<a id='n1866' href='#n1866'>1866</a>
<a id='n1867' href='#n1867'>1867</a>
<a id='n1868' href='#n1868'>1868</a>
<a id='n1869' href='#n1869'>1869</a>
<a id='n1870' href='#n1870'>1870</a>
<a id='n1871' href='#n1871'>1871</a>
<a id='n1872' href='#n1872'>1872</a>
<a id='n1873' href='#n1873'>1873</a>
<a id='n1874' href='#n1874'>1874</a>
<a id='n1875' href='#n1875'>1875</a>
<a id='n1876' href='#n1876'>1876</a>
<a id='n1877' href='#n1877'>1877</a>
<a id='n1878' href='#n1878'>1878</a>
<a id='n1879' href='#n1879'>1879</a>
<a id='n1880' href='#n1880'>1880</a>
<a id='n1881' href='#n1881'>1881</a>
<a id='n1882' href='#n1882'>1882</a>
<a id='n1883' href='#n1883'>1883</a>
<a id='n1884' href='#n1884'>1884</a>
<a id='n1885' href='#n1885'>1885</a>
<a id='n1886' href='#n1886'>1886</a>
<a id='n1887' href='#n1887'>1887</a>
<a id='n1888' href='#n1888'>1888</a>
<a id='n1889' href='#n1889'>1889</a>
<a id='n1890' href='#n1890'>1890</a>
<a id='n1891' href='#n1891'>1891</a>
<a id='n1892' href='#n1892'>1892</a>
<a id='n1893' href='#n1893'>1893</a>
<a id='n1894' href='#n1894'>1894</a>
<a id='n1895' href='#n1895'>1895</a>
<a id='n1896' href='#n1896'>1896</a>
<a id='n1897' href='#n1897'>1897</a>
<a id='n1898' href='#n1898'>1898</a>
<a id='n1899' href='#n1899'>1899</a>
<a id='n1900' href='#n1900'>1900</a>
<a id='n1901' href='#n1901'>1901</a>
<a id='n1902' href='#n1902'>1902</a>
<a id='n1903' href='#n1903'>1903</a>
<a id='n1904' href='#n1904'>1904</a>
<a id='n1905' href='#n1905'>1905</a>
<a id='n1906' href='#n1906'>1906</a>
<a id='n1907' href='#n1907'>1907</a>
<a id='n1908' href='#n1908'>1908</a>
<a id='n1909' href='#n1909'>1909</a>
<a id='n1910' href='#n1910'>1910</a>
<a id='n1911' href='#n1911'>1911</a>
<a id='n1912' href='#n1912'>1912</a>
<a id='n1913' href='#n1913'>1913</a>
<a id='n1914' href='#n1914'>1914</a>
<a id='n1915' href='#n1915'>1915</a>
<a id='n1916' href='#n1916'>1916</a>
<a id='n1917' href='#n1917'>1917</a>
<a id='n1918' href='#n1918'>1918</a>
<a id='n1919' href='#n1919'>1919</a>
<a id='n1920' href='#n1920'>1920</a>
<a id='n1921' href='#n1921'>1921</a>
<a id='n1922' href='#n1922'>1922</a>
<a id='n1923' href='#n1923'>1923</a>
<a id='n1924' href='#n1924'>1924</a>
<a id='n1925' href='#n1925'>1925</a>
<a id='n1926' href='#n1926'>1926</a>
<a id='n1927' href='#n1927'>1927</a>
<a id='n1928' href='#n1928'>1928</a>
<a id='n1929' href='#n1929'>1929</a>
<a id='n1930' href='#n1930'>1930</a>
<a id='n1931' href='#n1931'>1931</a>
<a id='n1932' href='#n1932'>1932</a>
<a id='n1933' href='#n1933'>1933</a>
<a id='n1934' href='#n1934'>1934</a>
<a id='n1935' href='#n1935'>1935</a>
<a id='n1936' href='#n1936'>1936</a>
<a id='n1937' href='#n1937'>1937</a>
<a id='n1938' href='#n1938'>1938</a>
<a id='n1939' href='#n1939'>1939</a>
<a id='n1940' href='#n1940'>1940</a>
<a id='n1941' href='#n1941'>1941</a>
<a id='n1942' href='#n1942'>1942</a>
<a id='n1943' href='#n1943'>1943</a>
<a id='n1944' href='#n1944'>1944</a>
<a id='n1945' href='#n1945'>1945</a>
<a id='n1946' href='#n1946'>1946</a>
<a id='n1947' href='#n1947'>1947</a>
<a id='n1948' href='#n1948'>1948</a>
<a id='n1949' href='#n1949'>1949</a>
<a id='n1950' href='#n1950'>1950</a>
<a id='n1951' href='#n1951'>1951</a>
<a id='n1952' href='#n1952'>1952</a>
<a id='n1953' href='#n1953'>1953</a>
<a id='n1954' href='#n1954'>1954</a>
<a id='n1955' href='#n1955'>1955</a>
<a id='n1956' href='#n1956'>1956</a>
<a id='n1957' href='#n1957'>1957</a>
<a id='n1958' href='#n1958'>1958</a>
<a id='n1959' href='#n1959'>1959</a>
<a id='n1960' href='#n1960'>1960</a>
<a id='n1961' href='#n1961'>1961</a>
<a id='n1962' href='#n1962'>1962</a>
<a id='n1963' href='#n1963'>1963</a>
<a id='n1964' href='#n1964'>1964</a>
<a id='n1965' href='#n1965'>1965</a>
<a id='n1966' href='#n1966'>1966</a>
<a id='n1967' href='#n1967'>1967</a>
<a id='n1968' href='#n1968'>1968</a>
<a id='n1969' href='#n1969'>1969</a>
<a id='n1970' href='#n1970'>1970</a>
<a id='n1971' href='#n1971'>1971</a>
<a id='n1972' href='#n1972'>1972</a>
<a id='n1973' href='#n1973'>1973</a>
<a id='n1974' href='#n1974'>1974</a>
<a id='n1975' href='#n1975'>1975</a>
<a id='n1976' href='#n1976'>1976</a>
<a id='n1977' href='#n1977'>1977</a>
<a id='n1978' href='#n1978'>1978</a>
<a id='n1979' href='#n1979'>1979</a>
<a id='n1980' href='#n1980'>1980</a>
<a id='n1981' href='#n1981'>1981</a>
<a id='n1982' href='#n1982'>1982</a>
<a id='n1983' href='#n1983'>1983</a>
<a id='n1984' href='#n1984'>1984</a>
<a id='n1985' href='#n1985'>1985</a>
<a id='n1986' href='#n1986'>1986</a>
<a id='n1987' href='#n1987'>1987</a>
<a id='n1988' href='#n1988'>1988</a>
<a id='n1989' href='#n1989'>1989</a>
<a id='n1990' href='#n1990'>1990</a>
<a id='n1991' href='#n1991'>1991</a>
<a id='n1992' href='#n1992'>1992</a>
<a id='n1993' href='#n1993'>1993</a>
<a id='n1994' href='#n1994'>1994</a>
<a id='n1995' href='#n1995'>1995</a>
<a id='n1996' href='#n1996'>1996</a>
<a id='n1997' href='#n1997'>1997</a>
<a id='n1998' href='#n1998'>1998</a>
<a id='n1999' href='#n1999'>1999</a>
<a id='n2000' href='#n2000'>2000</a>
<a id='n2001' href='#n2001'>2001</a>
<a id='n2002' href='#n2002'>2002</a>
<a id='n2003' href='#n2003'>2003</a>
<a id='n2004' href='#n2004'>2004</a>
<a id='n2005' href='#n2005'>2005</a>
<a id='n2006' href='#n2006'>2006</a>
<a id='n2007' href='#n2007'>2007</a>
<a id='n2008' href='#n2008'>2008</a>
<a id='n2009' href='#n2009'>2009</a>
<a id='n2010' href='#n2010'>2010</a>
<a id='n2011' href='#n2011'>2011</a>
<a id='n2012' href='#n2012'>2012</a>
<a id='n2013' href='#n2013'>2013</a>
<a id='n2014' href='#n2014'>2014</a>
<a id='n2015' href='#n2015'>2015</a>
<a id='n2016' href='#n2016'>2016</a>
<a id='n2017' href='#n2017'>2017</a>
<a id='n2018' href='#n2018'>2018</a>
<a id='n2019' href='#n2019'>2019</a>
<a id='n2020' href='#n2020'>2020</a>
<a id='n2021' href='#n2021'>2021</a>
<a id='n2022' href='#n2022'>2022</a>
<a id='n2023' href='#n2023'>2023</a>
<a id='n2024' href='#n2024'>2024</a>
<a id='n2025' href='#n2025'>2025</a>
<a id='n2026' href='#n2026'>2026</a>
<a id='n2027' href='#n2027'>2027</a>
<a id='n2028' href='#n2028'>2028</a>
<a id='n2029' href='#n2029'>2029</a>
<a id='n2030' href='#n2030'>2030</a>
<a id='n2031' href='#n2031'>2031</a>
<a id='n2032' href='#n2032'>2032</a>
<a id='n2033' href='#n2033'>2033</a>
<a id='n2034' href='#n2034'>2034</a>
<a id='n2035' href='#n2035'>2035</a>
<a id='n2036' href='#n2036'>2036</a>
<a id='n2037' href='#n2037'>2037</a>
<a id='n2038' href='#n2038'>2038</a>
<a id='n2039' href='#n2039'>2039</a>
<a id='n2040' href='#n2040'>2040</a>
<a id='n2041' href='#n2041'>2041</a>
<a id='n2042' href='#n2042'>2042</a>
<a id='n2043' href='#n2043'>2043</a>
<a id='n2044' href='#n2044'>2044</a>
<a id='n2045' href='#n2045'>2045</a>
<a id='n2046' href='#n2046'>2046</a>
<a id='n2047' href='#n2047'>2047</a>
<a id='n2048' href='#n2048'>2048</a>
<a id='n2049' href='#n2049'>2049</a>
<a id='n2050' href='#n2050'>2050</a>
<a id='n2051' href='#n2051'>2051</a>
<a id='n2052' href='#n2052'>2052</a>
<a id='n2053' href='#n2053'>2053</a>
<a id='n2054' href='#n2054'>2054</a>
<a id='n2055' href='#n2055'>2055</a>
<a id='n2056' href='#n2056'>2056</a>
<a id='n2057' href='#n2057'>2057</a>
<a id='n2058' href='#n2058'>2058</a>
<a id='n2059' href='#n2059'>2059</a>
<a id='n2060' href='#n2060'>2060</a>
<a id='n2061' href='#n2061'>2061</a>
<a id='n2062' href='#n2062'>2062</a>
<a id='n2063' href='#n2063'>2063</a>
<a id='n2064' href='#n2064'>2064</a>
<a id='n2065' href='#n2065'>2065</a>
<a id='n2066' href='#n2066'>2066</a>
<a id='n2067' href='#n2067'>2067</a>
<a id='n2068' href='#n2068'>2068</a>
<a id='n2069' href='#n2069'>2069</a>
<a id='n2070' href='#n2070'>2070</a>
<a id='n2071' href='#n2071'>2071</a>
<a id='n2072' href='#n2072'>2072</a>
<a id='n2073' href='#n2073'>2073</a>
<a id='n2074' href='#n2074'>2074</a>
<a id='n2075' href='#n2075'>2075</a>
<a id='n2076' href='#n2076'>2076</a>
<a id='n2077' href='#n2077'>2077</a>
<a id='n2078' href='#n2078'>2078</a>
<a id='n2079' href='#n2079'>2079</a>
<a id='n2080' href='#n2080'>2080</a>
<a id='n2081' href='#n2081'>2081</a>
<a id='n2082' href='#n2082'>2082</a>
<a id='n2083' href='#n2083'>2083</a>
<a id='n2084' href='#n2084'>2084</a>
<a id='n2085' href='#n2085'>2085</a>
<a id='n2086' href='#n2086'>2086</a>
<a id='n2087' href='#n2087'>2087</a>
<a id='n2088' href='#n2088'>2088</a>
<a id='n2089' href='#n2089'>2089</a>
<a id='n2090' href='#n2090'>2090</a>
<a id='n2091' href='#n2091'>2091</a>
<a id='n2092' href='#n2092'>2092</a>
<a id='n2093' href='#n2093'>2093</a>
<a id='n2094' href='#n2094'>2094</a>
<a id='n2095' href='#n2095'>2095</a>
<a id='n2096' href='#n2096'>2096</a>
<a id='n2097' href='#n2097'>2097</a>
<a id='n2098' href='#n2098'>2098</a>
<a id='n2099' href='#n2099'>2099</a>
<a id='n2100' href='#n2100'>2100</a>
<a id='n2101' href='#n2101'>2101</a>
<a id='n2102' href='#n2102'>2102</a>
<a id='n2103' href='#n2103'>2103</a>
<a id='n2104' href='#n2104'>2104</a>
<a id='n2105' href='#n2105'>2105</a>
<a id='n2106' href='#n2106'>2106</a>
<a id='n2107' href='#n2107'>2107</a>
<a id='n2108' href='#n2108'>2108</a>
<a id='n2109' href='#n2109'>2109</a>
<a id='n2110' href='#n2110'>2110</a>
<a id='n2111' href='#n2111'>2111</a>
<a id='n2112' href='#n2112'>2112</a>
<a id='n2113' href='#n2113'>2113</a>
<a id='n2114' href='#n2114'>2114</a>
<a id='n2115' href='#n2115'>2115</a>
<a id='n2116' href='#n2116'>2116</a>
<a id='n2117' href='#n2117'>2117</a>
<a id='n2118' href='#n2118'>2118</a>
<a id='n2119' href='#n2119'>2119</a>
<a id='n2120' href='#n2120'>2120</a>
<a id='n2121' href='#n2121'>2121</a>
<a id='n2122' href='#n2122'>2122</a>
<a id='n2123' href='#n2123'>2123</a>
<a id='n2124' href='#n2124'>2124</a>
<a id='n2125' href='#n2125'>2125</a>
<a id='n2126' href='#n2126'>2126</a>
<a id='n2127' href='#n2127'>2127</a>
<a id='n2128' href='#n2128'>2128</a>
<a id='n2129' href='#n2129'>2129</a>
<a id='n2130' href='#n2130'>2130</a>
<a id='n2131' href='#n2131'>2131</a>
<a id='n2132' href='#n2132'>2132</a>
<a id='n2133' href='#n2133'>2133</a>
<a id='n2134' href='#n2134'>2134</a>
<a id='n2135' href='#n2135'>2135</a>
<a id='n2136' href='#n2136'>2136</a>
<a id='n2137' href='#n2137'>2137</a>
<a id='n2138' href='#n2138'>2138</a>
<a id='n2139' href='#n2139'>2139</a>
<a id='n2140' href='#n2140'>2140</a>
<a id='n2141' href='#n2141'>2141</a>
<a id='n2142' href='#n2142'>2142</a>
<a id='n2143' href='#n2143'>2143</a>
<a id='n2144' href='#n2144'>2144</a>
<a id='n2145' href='#n2145'>2145</a>
<a id='n2146' href='#n2146'>2146</a>
<a id='n2147' href='#n2147'>2147</a>
<a id='n2148' href='#n2148'>2148</a>
<a id='n2149' href='#n2149'>2149</a>
<a id='n2150' href='#n2150'>2150</a>
<a id='n2151' href='#n2151'>2151</a>
<a id='n2152' href='#n2152'>2152</a>
<a id='n2153' href='#n2153'>2153</a>
<a id='n2154' href='#n2154'>2154</a>
<a id='n2155' href='#n2155'>2155</a>
<a id='n2156' href='#n2156'>2156</a>
<a id='n2157' href='#n2157'>2157</a>
<a id='n2158' href='#n2158'>2158</a>
<a id='n2159' href='#n2159'>2159</a>
<a id='n2160' href='#n2160'>2160</a>
<a id='n2161' href='#n2161'>2161</a>
<a id='n2162' href='#n2162'>2162</a>
<a id='n2163' href='#n2163'>2163</a>
<a id='n2164' href='#n2164'>2164</a>
<a id='n2165' href='#n2165'>2165</a>
<a id='n2166' href='#n2166'>2166</a>
<a id='n2167' href='#n2167'>2167</a>
<a id='n2168' href='#n2168'>2168</a>
<a id='n2169' href='#n2169'>2169</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/*</span>
<span class="hl com"> * re_*comp and friends - compile REs</span>
<span class="hl com"> * This file #includes several others (see the bottom).</span>
<span class="hl com"> *</span>
<span class="hl com"> * Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Development of this software was funded, in part, by Cray Research Inc.,</span>
<span class="hl com"> * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics</span>
<span class="hl com"> * Corporation, none of whom are responsible for the results. The author</span>
<span class="hl com"> * thanks all of them.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Redistribution and use in source and binary forms -- with or without</span>
<span class="hl com"> * modification -- are permitted for any purpose, provided that</span>
<span class="hl com"> * redistributions in source form retain this entire copyright notice and</span>
<span class="hl com"> * indicate the origin and nature of any modifications.</span>
<span class="hl com"> *</span>
<span class="hl com"> * I'd appreciate being given credit for this package in the documentation of</span>
<span class="hl com"> * software which uses it, but that is not a requirement.</span>
<span class="hl com"> *</span>
<span class="hl com"> * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,</span>
<span class="hl com"> * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY</span>
<span class="hl com"> * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL</span>
<span class="hl com"> * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,</span>
<span class="hl com"> * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,</span>
<span class="hl com"> * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;</span>
<span class="hl com"> * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,</span>
<span class="hl com"> * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR</span>
<span class="hl com"> * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF</span>
<span class="hl com"> * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</span>
<span class="hl com"> *</span>
<span class="hl com"> */</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;regguts.h&quot;</span><span class="hl ppc"></span>

<span class="hl com">/*</span>
<span class="hl com"> * forward declarations, up here so forward datatypes etc. are defined early</span>
<span class="hl com"> */</span>
<span class="hl com">/* =====^!^===== begin forwards =====^!^===== */</span>
<span class="hl com">/* automatically gathered by fwd; do not hand-edit */</span>
<span class="hl com">/* === regcomp.c === */</span>
<span class="hl kwb">int</span> <span class="hl kwd">compile</span><span class="hl opt">(</span>regex_t <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">size_t</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">moresubs</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">freev</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">makesearch</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span><span class="hl kwd">parse</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span><span class="hl kwd">parsebranch</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">parseqatom</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">nonword</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">word</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">scannum</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">repeat</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">bracket</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cbracket</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">brackpart</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static const</span> chr <span class="hl opt">*</span><span class="hl kwd">scanplain</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">onechr</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> pchr<span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dovec</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> cvec <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">wordchrs</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span><span class="hl kwd">subre</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freesubre</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freesrnode</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">optst</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">numst</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">markst</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cleanst</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static long</span> <span class="hl kwd">nfatree</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static long</span> <span class="hl kwd">nfanode</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">newlacon</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freelacons</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">rfree</span><span class="hl opt">(</span>regex_t <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dump</span><span class="hl opt">(</span>regex_t <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpst</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">stdump</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span><span class="hl kwd">stid</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*,</span> <span class="hl kwb">char</span> <span class="hl opt">*,</span> <span class="hl kwb">size_t</span><span class="hl opt">);</span>
<span class="hl com">/* === regc_lex.c === */</span>
<span class="hl kwb">static void</span> <span class="hl kwd">lexstart</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">prefixes</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">lexnest</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">lexword</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">next</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">lexescape</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static</span> chr <span class="hl kwd">lexdigits</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">brenext</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> pchr<span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">skip</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*);</span>
<span class="hl kwb">static</span> chr <span class="hl kwd">newline</span><span class="hl opt">(</span>NOPARMS<span class="hl opt">);</span>
<span class="hl ppc">#ifdef REG_DEBUG</span>
<span class="hl kwb">static const</span> chr <span class="hl opt">*</span><span class="hl kwd">ch</span><span class="hl opt">(</span>NOPARMS<span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
<span class="hl kwb">static</span> chr <span class="hl kwd">chrnamed</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> pchr<span class="hl opt">);</span>
<span class="hl com">/* === regc_color.c === */</span>
<span class="hl kwb">static void</span> <span class="hl kwd">initcm</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freecm</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cmtreefree</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">union</span> tree <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">setcolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> pchr<span class="hl opt">,</span> pcolor<span class="hl opt">);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">maxcolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">newcolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freecolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> pcolor<span class="hl opt">);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">pseudocolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">subcolor</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> pchr c<span class="hl opt">);</span>
<span class="hl kwb">static</span> color <span class="hl kwd">newsub</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> pcolor<span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">subrange</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> pchr<span class="hl opt">,</span> pchr<span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">subblock</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> pchr<span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">okcolors</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> colormap <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">colorchain</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">uncolorchain</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">rainbow</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> pcolor<span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">colorcomplement</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl ppc">#ifdef REG_DEBUG</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpcolors</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">fillcheck</span><span class="hl opt">(</span><span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">union</span> tree <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpchr</span><span class="hl opt">(</span>pchr<span class="hl opt">,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl ppc">#endif</span>
<span class="hl com">/* === regc_nfa.c === */</span>
<span class="hl kwb">static struct</span> nfa <span class="hl opt">*</span><span class="hl kwd">newnfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">struct</span> colormap <span class="hl opt">*,</span> <span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freenfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> state <span class="hl opt">*</span><span class="hl kwd">newstate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> state <span class="hl opt">*</span><span class="hl kwd">newfstate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">int</span> flag<span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dropstate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freestate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">destroystate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">newarc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> pcolor<span class="hl opt">,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> arc <span class="hl opt">*</span><span class="hl kwd">allocarc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freearc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> arc <span class="hl opt">*</span><span class="hl kwd">findarc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> pcolor<span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cparc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">moveins</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">copyins</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">moveouts</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">copyouts</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cloneouts</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">delsub</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">deltraverse</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dupnfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">duptraverse</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cleartraverse</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">specialcolors</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static long</span> <span class="hl kwd">optimize</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">pullback</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">pull</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">pushfwd</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">push</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl ppc">#define	INCOMPATIBLE	1</span>	<span class="hl com">/* destroys arc */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	SATISFIED	2</span>	<span class="hl com">/* constraint satisfied */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	COMPATIBLE	3</span>	<span class="hl com">/* compatible but not satisfied yet */</span><span class="hl ppc"></span>
<span class="hl kwb">static int</span> <span class="hl kwd">combine</span><span class="hl opt">(</span><span class="hl kwb">struct</span> arc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">fixempties</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">unempty</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> arc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">cleanup</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">markreachable</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">markcanreach</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*);</span>
<span class="hl kwb">static long</span> <span class="hl kwd">analyze</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">compact</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">struct</span> cnfa <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">carcsort</span><span class="hl opt">(</span><span class="hl kwb">struct</span> carc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> carc <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freecnfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cnfa <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpnfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> nfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl ppc">#ifdef REG_DEBUG</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpstate</span><span class="hl opt">(</span><span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumparcs</span><span class="hl opt">(</span><span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">dumprarcs</span><span class="hl opt">(</span><span class="hl kwb">struct</span> arc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumparc</span><span class="hl opt">(</span><span class="hl kwb">struct</span> arc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> state <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl ppc">#endif</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpcnfa</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cnfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl ppc">#ifdef REG_DEBUG</span>
<span class="hl kwb">static void</span> <span class="hl kwd">dumpcstate</span><span class="hl opt">(</span><span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">struct</span> carc <span class="hl opt">*,</span> <span class="hl kwb">struct</span> cnfa <span class="hl opt">*,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*);</span>
<span class="hl ppc">#endif</span>
<span class="hl com">/* === regc_cvec.c === */</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">clearcvec</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cvec <span class="hl opt">*);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">addchr</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cvec <span class="hl opt">*,</span> pchr<span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">addrange</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cvec <span class="hl opt">*,</span> pchr<span class="hl opt">,</span> pchr<span class="hl opt">);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">newcvec</span><span class="hl opt">(</span><span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">getcvec</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static void</span> <span class="hl kwd">freecvec</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cvec <span class="hl opt">*);</span>
<span class="hl com">/* === regc_locale.c === */</span>
<span class="hl kwb">static</span> celt <span class="hl kwd">element</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">range</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> celt<span class="hl opt">,</span> celt<span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">before</span><span class="hl opt">(</span>celt<span class="hl opt">,</span> celt<span class="hl opt">);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">eclass</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> celt<span class="hl opt">,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">cclass</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">int</span><span class="hl opt">);</span>
<span class="hl kwb">static struct</span> cvec <span class="hl opt">*</span><span class="hl kwd">allcases</span><span class="hl opt">(</span><span class="hl kwb">struct</span> vars <span class="hl opt">*,</span> pchr<span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">cmp</span><span class="hl opt">(</span><span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">size_t</span><span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">casecmp</span><span class="hl opt">(</span><span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">const</span> chr <span class="hl opt">*,</span> <span class="hl kwb">size_t</span><span class="hl opt">);</span>
<span class="hl com">/* automatically gathered by fwd; do not hand-edit */</span>
<span class="hl com">/* =====^!^===== end forwards =====^!^===== */</span>

<span class="hl com">/* internal variables, bundled for easy passing around */</span>
<span class="hl kwb">struct</span> vars <span class="hl opt">{</span>
    regex_t <span class="hl opt">*</span>re<span class="hl opt">;</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>now<span class="hl opt">;</span>		<span class="hl com">/* scan pointer into string */</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>stop<span class="hl opt">;</span>		<span class="hl com">/* end of string */</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>savenow<span class="hl opt">;</span>		<span class="hl com">/* saved now and stop for &quot;subroutine call&quot; */</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>savestop<span class="hl opt">;</span>
    <span class="hl kwb">int</span> err<span class="hl opt">;</span>			<span class="hl com">/* error code (0 if none) */</span>
    <span class="hl kwb">int</span> cflags<span class="hl opt">;</span>			<span class="hl com">/* copy of compile flags */</span>
    <span class="hl kwb">int</span> lasttype<span class="hl opt">;</span>		<span class="hl com">/* type of previous token */</span>
    <span class="hl kwb">int</span> nexttype<span class="hl opt">;</span>		<span class="hl com">/* type of next token */</span>
    chr nextvalue<span class="hl opt">;</span>		<span class="hl com">/* value (if any) of next token */</span>
    <span class="hl kwb">int</span> lexcon<span class="hl opt">;</span>			<span class="hl com">/* lexical context type (see lex.c) */</span>
    <span class="hl kwb">int</span> nsubexp<span class="hl opt">;</span>		<span class="hl com">/* subexpression count */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">**</span>subs<span class="hl opt">;</span>	<span class="hl com">/* subRE pointer vector */</span>
    <span class="hl kwb">size_t</span> nsubs<span class="hl opt">;</span>		<span class="hl com">/* length of vector */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>sub10<span class="hl opt">[</span><span class="hl num">10</span><span class="hl opt">];</span>	<span class="hl com">/* initial vector, enough for most */</span>
    <span class="hl kwb">struct</span> nfa <span class="hl opt">*</span>nfa<span class="hl opt">;</span>		<span class="hl com">/* the NFA */</span>
    <span class="hl kwb">struct</span> colormap <span class="hl opt">*</span>cm<span class="hl opt">;</span>	<span class="hl com">/* character color map */</span>
    color nlcolor<span class="hl opt">;</span>		<span class="hl com">/* color of newline */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>wordchrs<span class="hl opt">;</span>	<span class="hl com">/* state in nfa holding word-char outarcs */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>tree<span class="hl opt">;</span>		<span class="hl com">/* subexpression tree */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>treechain<span class="hl opt">;</span>	<span class="hl com">/* all tree nodes allocated */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>treefree<span class="hl opt">;</span>	<span class="hl com">/* any free tree nodes */</span>
    <span class="hl kwb">int</span> ntree<span class="hl opt">;</span>			<span class="hl com">/* number of tree nodes */</span>
    <span class="hl kwb">struct</span> cvec <span class="hl opt">*</span>cv<span class="hl opt">;</span>		<span class="hl com">/* interface cvec */</span>
    <span class="hl kwb">struct</span> cvec <span class="hl opt">*</span>cv2<span class="hl opt">;</span>		<span class="hl com">/* utility cvec */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>lacons<span class="hl opt">;</span>	<span class="hl com">/* lookahead-constraint vector */</span>
    <span class="hl kwb">int</span> nlacons<span class="hl opt">;</span>		<span class="hl com">/* size of lacons */</span>
<span class="hl opt">};</span>

<span class="hl com">/* parsing macros; most know that `v' is the struct vars pointer */</span>
<span class="hl ppc">#define	NEXT()	(next(v))</span>		<span class="hl com">/* advance by one token */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	SEE(t)	(v-&gt;nexttype == (t))</span>	<span class="hl com">/* is next token this? */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	EAT(t)	(SEE(t) &amp;&amp; next(v))</span>	<span class="hl com">/* if next is this, swallow it */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	VISERR(vv)	((vv)-&gt;err != 0)</span><span class="hl com">/* have we seen an error yet? */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	ISERR()	VISERR(v)</span>
<span class="hl ppc">#define	VERR(vv,e) \</span>
<span class="hl ppc">	((vv)-&gt;nexttype = EOS, ((vv)-&gt;err) ? (vv)-&gt;err : ((vv)-&gt;err = (e)))</span>
<span class="hl ppc">#define	ERR(e)	VERR(v, e)</span>		<span class="hl com">/* record an error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	NOERR()	{if (ISERR()) return;}</span>	<span class="hl com">/* if error seen, return */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	NOERRN()	{if (ISERR()) return NULL;}</span>	<span class="hl com">/* NOERR with retval */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	NOERRZ()	{if (ISERR()) return 0;}</span>	<span class="hl com">/* NOERR with retval */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	INSIST(c, e)	((c) ? 0 : ERR(e))</span>	<span class="hl com">/* if condition false, error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	NOTE(b)	(v-&gt;re-&gt;re_info |= (b))</span>		<span class="hl com">/* note visible condition */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	EMPTYARC(x, y)	newarc(v-&gt;nfa, EMPTY, 0, x, y)</span>

<span class="hl com">/* token type codes, some also used as NFA arc types */</span>
<span class="hl ppc">#define	EMPTY</span>	<span class="hl pps">'n'</span><span class="hl ppc"></span>		<span class="hl com">/* no token present */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	EOS</span>	<span class="hl pps">'e'</span><span class="hl ppc"></span>		<span class="hl com">/* end of string */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	PLAIN</span>	<span class="hl pps">'p'</span><span class="hl ppc"></span>		<span class="hl com">/* ordinary character */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	DIGIT</span>	<span class="hl pps">'d'</span><span class="hl ppc"></span>		<span class="hl com">/* digit (in bound) */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	BACKREF</span>	<span class="hl pps">'b'</span><span class="hl ppc"></span>		<span class="hl com">/* back reference */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	COLLEL</span>	<span class="hl pps">'I'</span><span class="hl ppc"></span>		<span class="hl com">/* start of [. */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	ECLASS</span>	<span class="hl pps">'E'</span><span class="hl ppc"></span>		<span class="hl com">/* start of [= */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	CCLASS</span>	<span class="hl pps">'C'</span><span class="hl ppc"></span>		<span class="hl com">/* start of [: */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	END</span>	<span class="hl pps">'X'</span><span class="hl ppc"></span>		<span class="hl com">/* end of [. [= [: */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	RANGE</span>	<span class="hl pps">'R'</span><span class="hl ppc"></span>		<span class="hl com">/* - within [] which might be range delim. */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	LACON</span>	<span class="hl pps">'L'</span><span class="hl ppc"></span>		<span class="hl com">/* lookahead constraint subRE */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	AHEAD</span>	<span class="hl pps">'a'</span><span class="hl ppc"></span>		<span class="hl com">/* color-lookahead arc */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	BEHIND</span>	<span class="hl pps">'r'</span><span class="hl ppc"></span>		<span class="hl com">/* color-lookbehind arc */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	WBDRY</span>	<span class="hl pps">'w'</span><span class="hl ppc"></span>		<span class="hl com">/* word boundary constraint */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	NWBDRY</span>	<span class="hl pps">'W'</span><span class="hl ppc"></span>		<span class="hl com">/* non-word-boundary constraint */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	SBEGIN</span>	<span class="hl pps">'A'</span><span class="hl ppc"></span>		<span class="hl com">/* beginning of string (even if not BOL) */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	SEND</span>	<span class="hl pps">'Z'</span><span class="hl ppc"></span>		<span class="hl com">/* end of string (even if not EOL) */</span><span class="hl ppc"></span>
<span class="hl ppc">#define	PREFER</span>	<span class="hl pps">'P'</span><span class="hl ppc"></span>		<span class="hl com">/* length preference */</span><span class="hl ppc"></span>

<span class="hl com">/* is an arc colored, and hence on a color chain? */</span>
<span class="hl ppc">#define	COLORED(a) \</span>
<span class="hl ppc">	((a)-&gt;type == PLAIN || (a)-&gt;type == AHEAD || (a)-&gt;type == BEHIND)</span>

<span class="hl com">/* static function list */</span>
<span class="hl kwb">static struct</span> fns functions <span class="hl opt">= {</span>
    rfree<span class="hl opt">,</span>			<span class="hl com">/* regfree insides */</span>
<span class="hl opt">};</span>

<span class="hl com">/*</span>
<span class="hl com"> - compile - compile regular expression</span>
<span class="hl com"> ^ int compile(regex_t *, const chr *, size_t, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">compile</span><span class="hl opt">(</span>
    regex_t <span class="hl opt">*</span>re<span class="hl opt">,</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>string<span class="hl opt">,</span>
    <span class="hl kwb">size_t</span> len<span class="hl opt">,</span>
    <span class="hl kwb">int</span> flags<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">AllocVars</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
    <span class="hl kwb">struct</span> guts <span class="hl opt">*</span>g<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span> j<span class="hl opt">;</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>debug <span class="hl opt">= (</span>flags<span class="hl opt">&amp;</span>REG_PROGRESS<span class="hl opt">)</span> ? stdout <span class="hl opt">:</span> NULL<span class="hl opt">;</span>
<span class="hl ppc">#define	CNOERR()	{ if (ISERR()) return freev(v, v-&gt;err); }</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Sanity checks.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>re <span class="hl opt">==</span> NULL <span class="hl opt">||</span> string <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">FreeVars</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwa">return</span> REG_INVARG<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>flags<span class="hl opt">&amp;</span>REG_QUOTE<span class="hl opt">) &amp;&amp; (</span>flags<span class="hl opt">&amp;(</span>REG_ADVANCED<span class="hl opt">|</span>REG_EXPANDED<span class="hl opt">|</span>REG_NEWLINE<span class="hl opt">))) {</span>
	<span class="hl kwd">FreeVars</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwa">return</span> REG_INVARG<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!(</span>flags<span class="hl opt">&amp;</span>REG_EXTENDED<span class="hl opt">) &amp;&amp; (</span>flags<span class="hl opt">&amp;</span>REG_ADVF<span class="hl opt">)) {</span>
	<span class="hl kwd">FreeVars</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwa">return</span> REG_INVARG<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Initial setup (after which freev() is callable).</span>
<span class="hl com">     */</span>

    v<span class="hl opt">-&gt;</span>re <span class="hl opt">=</span> re<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>now <span class="hl opt">=</span> string<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>stop <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now <span class="hl opt">+</span> len<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>savenow <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>savestop <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>err <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>cflags <span class="hl opt">=</span> flags<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>nsubexp <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>subs <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>sub10<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>nsubs <span class="hl opt">=</span> <span class="hl num">10</span><span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>j <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> j <span class="hl opt">&lt;</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">;</span> j<span class="hl opt">++) {</span>
	v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>j<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    v<span class="hl opt">-&gt;</span>nfa <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>cm <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>nlcolor <span class="hl opt">=</span> COLORLESS<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>wordchrs <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>tree <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>treechain <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>treefree <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>cv <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>cv2 <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    re<span class="hl opt">-&gt;</span>re_magic <span class="hl opt">=</span> REMAGIC<span class="hl opt">;</span>
    re<span class="hl opt">-&gt;</span>re_info <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>		<span class="hl com">/* bits get set during parse */</span>
    re<span class="hl opt">-&gt;</span>re_csize <span class="hl opt">=</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>chr<span class="hl opt">);</span>
    re<span class="hl opt">-&gt;</span>re_guts <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    re<span class="hl opt">-&gt;</span>re_fns <span class="hl opt">=</span> <span class="hl kwd">VS</span><span class="hl opt">(&amp;</span>functions<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * More complex setup, malloced things.</span>
<span class="hl com">     */</span>

    re<span class="hl opt">-&gt;</span>re_guts <span class="hl opt">=</span> <span class="hl kwd">VS</span><span class="hl opt">(</span><span class="hl kwd">MALLOC</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> guts<span class="hl opt">)));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>re<span class="hl opt">-&gt;</span>re_guts <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> <span class="hl kwd">freev</span><span class="hl opt">(</span>v<span class="hl opt">,</span> REG_ESPACE<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    g <span class="hl opt">= (</span><span class="hl kwb">struct</span> guts <span class="hl opt">*)</span> re<span class="hl opt">-&gt;</span>re_guts<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>tree <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">initcm</span><span class="hl opt">(</span>v<span class="hl opt">, &amp;</span>g<span class="hl opt">-&gt;</span>cmap<span class="hl opt">);</span>
    v<span class="hl opt">-&gt;</span>cm <span class="hl opt">= &amp;</span>g<span class="hl opt">-&gt;</span>cmap<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>lacons <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwd">ZAPCNFA</span><span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">);</span>
    v<span class="hl opt">-&gt;</span>nfa <span class="hl opt">=</span> <span class="hl kwd">newnfa</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    v<span class="hl opt">-&gt;</span>cv <span class="hl opt">=</span> <span class="hl kwd">newcvec</span><span class="hl opt">(</span><span class="hl num">100</span><span class="hl opt">,</span> <span class="hl num">20</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cv <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> <span class="hl kwd">freev</span><span class="hl opt">(</span>v<span class="hl opt">,</span> REG_ESPACE<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Parsing.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">lexstart</span><span class="hl opt">(</span>v<span class="hl opt">);</span>		<span class="hl com">/* also handles prefixes */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLSTOP<span class="hl opt">) || (</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLANCH<span class="hl opt">)) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Assign newline a unique color.</span>
<span class="hl com">	 */</span>

	v<span class="hl opt">-&gt;</span>nlcolor <span class="hl opt">=</span> <span class="hl kwd">subcolor</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> <span class="hl kwd">newline</span><span class="hl opt">());</span>
	<span class="hl kwd">okcolors</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    v<span class="hl opt">-&gt;</span>tree <span class="hl opt">=</span> <span class="hl kwd">parse</span><span class="hl opt">(</span>v<span class="hl opt">,</span> EOS<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">-&gt;</span>init<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">-&gt;</span>final<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">));</span>		<span class="hl com">/* even if error; ISERR() =&gt; SEE(EOS) */</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Finish setup of nfa and its subre tree.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">specialcolors</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>debug <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>debug<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= RAW ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">dumpnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> debug<span class="hl opt">);</span>
	<span class="hl kwd">dumpst</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree<span class="hl opt">,</span> debug<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">optst</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>tree<span class="hl opt">);</span>
    v<span class="hl opt">-&gt;</span>ntree <span class="hl opt">=</span> <span class="hl kwd">numst</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwd">markst</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree<span class="hl opt">);</span>
    <span class="hl kwd">cleanst</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>debug <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>debug<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= TREE FIXED ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">dumpst</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree<span class="hl opt">,</span> debug<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Build compacted NFAs for tree and lacons.</span>
<span class="hl com">     */</span>

    re<span class="hl opt">-&gt;</span>re_info <span class="hl opt">|=</span> <span class="hl kwd">nfatree</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>tree<span class="hl opt">,</span> debug<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">==</span> <span class="hl num">0</span> <span class="hl opt">||</span> v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> v<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>debug <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>debug<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= LA%d ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">nfanode</span><span class="hl opt">(</span>v<span class="hl opt">, &amp;</span>v<span class="hl opt">-&gt;</span>lacons<span class="hl opt">[</span>i<span class="hl opt">],</span> debug<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>SHORTER<span class="hl opt">) {</span>
	<span class="hl kwd">NOTE</span><span class="hl opt">(</span>REG_USHORTEST<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Build compacted NFAs for tree, lacons, fast search.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>debug <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>debug<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= SEARCH ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Can sacrifice main NFA now, so use it as work area.</span>
<span class="hl com">     */</span>

    <span class="hl opt">(</span>DISCARD<span class="hl opt">)</span> <span class="hl kwd">optimize</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> debug<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">makesearch</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">compact</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">, &amp;</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">);</span>
    <span class="hl kwd">CNOERR</span><span class="hl opt">();</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Looks okay, package it up.</span>
<span class="hl com">     */</span>

    re<span class="hl opt">-&gt;</span>re_nsub <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nsubexp<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>re <span class="hl opt">=</span> NULL<span class="hl opt">;</span>		<span class="hl com">/* freev no longer frees re */</span>
    g<span class="hl opt">-&gt;</span>magic <span class="hl opt">=</span> GUTSMAGIC<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>cflags <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>info <span class="hl opt">=</span> re<span class="hl opt">-&gt;</span>re_info<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>nsub <span class="hl opt">=</span> re<span class="hl opt">-&gt;</span>re_nsub<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>tree <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>tree<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>tree <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>ntree <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>ntree<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>compare <span class="hl opt">= (</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ICASE<span class="hl opt">)</span> ? casecmp <span class="hl opt">:</span> cmp<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>lacons <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>lacons<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>flags<span class="hl opt">&amp;</span>REG_DUMP<span class="hl opt">) {</span>
	<span class="hl kwd">dump</span><span class="hl opt">(</span>re<span class="hl opt">,</span> stdout<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>err <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl kwd">freev</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - moresubs - enlarge subRE vector</span>
<span class="hl com"> ^ static void moresubs(struct vars *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">moresubs</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> wanted<span class="hl opt">)</span>			<span class="hl com">/* want enough room for this one */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">**</span>p<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span> n<span class="hl opt">;</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>wanted <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp; (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>wanted <span class="hl opt">&gt;=</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">);</span>
    n <span class="hl opt">= (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>wanted <span class="hl opt">*</span> <span class="hl num">3</span> <span class="hl opt">/</span> <span class="hl num">2</span> <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs <span class="hl opt">==</span> v<span class="hl opt">-&gt;</span>sub10<span class="hl opt">) {</span>
	p <span class="hl opt">= (</span><span class="hl kwb">struct</span> subre <span class="hl opt">**)</span> <span class="hl kwd">MALLOC</span><span class="hl opt">(</span>n <span class="hl opt">*</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*));</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">memcpy</span><span class="hl opt">(</span>p<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>subs<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nsubs <span class="hl opt">*</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*));</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	p <span class="hl opt">= (</span><span class="hl kwb">struct</span> subre <span class="hl opt">**)</span> <span class="hl kwd">REALLOC</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs<span class="hl opt">,</span> n<span class="hl opt">*</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre <span class="hl opt">*));</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ESPACE<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    v<span class="hl opt">-&gt;</span>subs <span class="hl opt">=</span> p<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>p <span class="hl opt">= &amp;</span>v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">];</span> v<span class="hl opt">-&gt;</span>nsubs <span class="hl opt">&lt;</span> n<span class="hl opt">;</span> p<span class="hl opt">++,</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">++) {</span>
	<span class="hl opt">*</span>p <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nsubs <span class="hl opt">==</span> n<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>wanted <span class="hl opt">&lt;</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - freev - free vars struct's substructures where necessary</span>
<span class="hl com"> * Optionally does error-number setting, and always returns error code (if</span>
<span class="hl com"> * any), to make error-handling code terser.</span>
<span class="hl com"> ^ static int freev(struct vars *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>
<span class="hl kwd">freev</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> err<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwc">register</span> <span class="hl kwb">int</span> ret<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>re <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">rfree</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>re<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs <span class="hl opt">!=</span> v<span class="hl opt">-&gt;</span>sub10<span class="hl opt">) {</span>
	<span class="hl kwd">FREE</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freenfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>tree <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>tree<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>treechain <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">cleanst</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cv <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freecvec</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cv<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cv2 <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freecvec</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cv2<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freelacons</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>lacons<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">ERR</span><span class="hl opt">(</span>err<span class="hl opt">);</span>			<span class="hl com">/* nop if err==0 */</span>

    ret <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>err<span class="hl opt">;</span>
    <span class="hl kwd">FreeVars</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
    <span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - makesearch - turn an NFA into a search NFA (implicit prepend of .*?)</span>
<span class="hl com"> * NFA must have been optimize()d already.</span>
<span class="hl com"> ^ static void makesearch(struct vars *, struct nfa *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">makesearch</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> nfa <span class="hl opt">*</span>nfa<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> arc <span class="hl opt">*</span>a<span class="hl opt">, *</span>b<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>pre <span class="hl opt">=</span> nfa<span class="hl opt">-&gt;</span>pre<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>s<span class="hl opt">, *</span>s2<span class="hl opt">, *</span>slist<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * No loops are needed if it's anchored.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>a <span class="hl opt">=</span> pre<span class="hl opt">-&gt;</span>outs<span class="hl opt">;</span> a <span class="hl opt">!=</span> NULL<span class="hl opt">;</span> a <span class="hl opt">=</span> a<span class="hl opt">-&gt;</span>outchain<span class="hl opt">) {</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>a<span class="hl opt">-&gt;</span>type <span class="hl opt">==</span> PLAIN<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>a<span class="hl opt">-&gt;</span>co <span class="hl opt">!=</span> nfa<span class="hl opt">-&gt;</span>bos<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] &amp;&amp;</span> a<span class="hl opt">-&gt;</span>co <span class="hl opt">!=</span> nfa<span class="hl opt">-&gt;</span>bos<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]) {</span>
	    <span class="hl kwa">break</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>a <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Add implicit .* in front.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">rainbow</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> COLORLESS<span class="hl opt">,</span> pre<span class="hl opt">,</span> pre<span class="hl opt">);</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * And ^* and \A* too -- not always necessary, but harmless.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">newarc</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> nfa<span class="hl opt">-&gt;</span>bos<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> pre<span class="hl opt">,</span> pre<span class="hl opt">);</span>
	<span class="hl kwd">newarc</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> nfa<span class="hl opt">-&gt;</span>bos<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">],</span> pre<span class="hl opt">,</span> pre<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Now here's the subtle part. Because many REs have no lookback</span>
<span class="hl com">     * constraints, often knowing when you were in the pre state tells you</span>
<span class="hl com">     * little; it's the next state(s) that are informative. But some of them</span>
<span class="hl com">     * may have other inarcs, i.e. it may be possible to make actual progress</span>
<span class="hl com">     * and then return to one of them. We must de-optimize such cases,</span>
<span class="hl com">     * splitting each such state into progress and no-progress states.</span>
<span class="hl com">     */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * First, make a list of the states.</span>
<span class="hl com">     */</span>

    slist <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>a<span class="hl opt">=</span>pre<span class="hl opt">-&gt;</span>outs <span class="hl opt">;</span> a<span class="hl opt">!=</span>NULL <span class="hl opt">;</span> a<span class="hl opt">=</span>a<span class="hl opt">-&gt;</span>outchain<span class="hl opt">) {</span>
	s <span class="hl opt">=</span> a<span class="hl opt">-&gt;</span>to<span class="hl opt">;</span>
	<span class="hl kwa">for</span> <span class="hl opt">(</span>b<span class="hl opt">=</span>s<span class="hl opt">-&gt;</span>ins <span class="hl opt">;</span> b<span class="hl opt">!=</span>NULL <span class="hl opt">;</span> b<span class="hl opt">=</span>b<span class="hl opt">-&gt;</span>inchain<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>b<span class="hl opt">-&gt;</span>from <span class="hl opt">!=</span> pre<span class="hl opt">) {</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>b <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> s<span class="hl opt">-&gt;</span>tmp <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl com">/*</span>
<span class="hl com">	     * Must be split if not already in the list (fixes bugs 505048,</span>
<span class="hl com">	     * 230589, 840258, 504785).</span>
<span class="hl com">	     */</span>

	    s<span class="hl opt">-&gt;</span>tmp <span class="hl opt">=</span> slist<span class="hl opt">;</span>
	    slist <span class="hl opt">=</span> s<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Do the splits.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>s<span class="hl opt">=</span>slist <span class="hl opt">;</span> s<span class="hl opt">!=</span>NULL <span class="hl opt">;</span> s<span class="hl opt">=</span>s2<span class="hl opt">) {</span>
	s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>nfa<span class="hl opt">);</span>

	<span class="hl kwd">copyouts</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> s<span class="hl opt">,</span> s2<span class="hl opt">);</span>
	<span class="hl kwa">for</span> <span class="hl opt">(</span>a<span class="hl opt">=</span>s<span class="hl opt">-&gt;</span>ins <span class="hl opt">;</span> a<span class="hl opt">!=</span>NULL <span class="hl opt">;</span> a<span class="hl opt">=</span>b<span class="hl opt">) {</span>
	    b <span class="hl opt">=</span> a<span class="hl opt">-&gt;</span>inchain<span class="hl opt">;</span>

	    <span class="hl kwa">if</span> <span class="hl opt">(</span>a<span class="hl opt">-&gt;</span>from <span class="hl opt">!=</span> pre<span class="hl opt">) {</span>
		<span class="hl kwd">cparc</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> a<span class="hl opt">,</span> a<span class="hl opt">-&gt;</span>from<span class="hl opt">,</span> s2<span class="hl opt">);</span>
		<span class="hl kwd">freearc</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> a<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	s2 <span class="hl opt">=</span> s<span class="hl opt">-&gt;</span>tmp<span class="hl opt">;</span>
	s<span class="hl opt">-&gt;</span>tmp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>		<span class="hl com">/* clean up while we're at it */</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - parse - parse an RE</span>
<span class="hl com"> * This is actually just the top level, which parses a bunch of branches tied</span>
<span class="hl com"> * together with '|'. They appear in the tree as the left children of a chain</span>
<span class="hl com"> * of '|' subres.</span>
<span class="hl com"> ^ static struct subre *parse(struct vars *, int, int, struct state *,</span>
<span class="hl com"> ^ 	struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span>
<span class="hl kwd">parse</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> stopper<span class="hl opt">,</span>		<span class="hl com">/* EOS or ')' */</span>
    <span class="hl kwb">int</span> type<span class="hl opt">,</span>			<span class="hl com">/* LACON (lookahead subRE) or PLAIN */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>init<span class="hl opt">,</span>		<span class="hl com">/* initial state */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>final<span class="hl opt">)</span>	<span class="hl com">/* final state */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>left<span class="hl opt">, *</span>right<span class="hl opt">;</span>	<span class="hl com">/* scaffolding for branch */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>branches<span class="hl opt">;</span>	<span class="hl com">/* top level */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>branch<span class="hl opt">;</span>	<span class="hl com">/* current branch */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">;</span>		<span class="hl com">/* temporary */</span>
    <span class="hl kwb">int</span> firstbranch<span class="hl opt">;</span>		<span class="hl com">/* is this the first branch? */</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>stopper <span class="hl opt">==</span> <span class="hl str">')'</span> <span class="hl opt">||</span> stopper <span class="hl opt">==</span> EOS<span class="hl opt">);</span>

    branches <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'|'</span><span class="hl opt">,</span> LONGER<span class="hl opt">,</span> init<span class="hl opt">,</span> final<span class="hl opt">);</span>
    <span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
    branch <span class="hl opt">=</span> branches<span class="hl opt">;</span>
    firstbranch <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwa">do</span> <span class="hl opt">{</span>	<span class="hl com">/* a branch */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>firstbranch<span class="hl opt">) {</span>
	    <span class="hl com">/*</span>
<span class="hl com">	     * Need a place to hang the branch.</span>
<span class="hl com">	     */</span>

	    branch<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'|'</span><span class="hl opt">,</span> LONGER<span class="hl opt">,</span> init<span class="hl opt">,</span> final<span class="hl opt">);</span>
	    <span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
	    branch <span class="hl opt">=</span> branch<span class="hl opt">-&gt;</span>right<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	firstbranch <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	left <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	right <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>init<span class="hl opt">,</span> left<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>right<span class="hl opt">,</span> final<span class="hl opt">);</span>
	<span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
	branch<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> <span class="hl kwd">parsebranch</span><span class="hl opt">(</span>v<span class="hl opt">,</span> stopper<span class="hl opt">,</span> type<span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
	<span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
	branch<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> <span class="hl kwd">UP</span><span class="hl opt">(</span>branch<span class="hl opt">-&gt;</span>flags <span class="hl opt">|</span> branch<span class="hl opt">-&gt;</span>left<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">((</span>branch<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;~</span> branches<span class="hl opt">-&gt;</span>flags<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>	<span class="hl com">/* new flags */</span>
	    <span class="hl kwa">for</span> <span class="hl opt">(</span>t <span class="hl opt">=</span> branches<span class="hl opt">;</span> t <span class="hl opt">!=</span> branch<span class="hl opt">;</span> t <span class="hl opt">=</span> t<span class="hl opt">-&gt;</span>right<span class="hl opt">) {</span>
		t<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> branch<span class="hl opt">-&gt;</span>flags<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span><span class="hl kwd">EAT</span><span class="hl opt">(</span><span class="hl str">'|'</span><span class="hl opt">));</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>stopper<span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">));</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>stopper<span class="hl opt">)) {</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>stopper <span class="hl opt">==</span> <span class="hl str">')'</span> <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">));</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_EPAREN<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Optimize out simple cases.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>branch <span class="hl opt">==</span> branches<span class="hl opt">) {</span>	<span class="hl com">/* only one branch */</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>branch<span class="hl opt">-&gt;</span>right <span class="hl opt">==</span> NULL<span class="hl opt">);</span>
	t <span class="hl opt">=</span> branch<span class="hl opt">-&gt;</span>left<span class="hl opt">;</span>
	branch<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> branches<span class="hl opt">);</span>
	branches <span class="hl opt">=</span> t<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(!</span><span class="hl kwd">MESSY</span><span class="hl opt">(</span>branches<span class="hl opt">-&gt;</span>flags<span class="hl opt">)) {</span>	<span class="hl com">/* no interesting innards */</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> branches<span class="hl opt">-&gt;</span>left<span class="hl opt">);</span>
	branches<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> branches<span class="hl opt">-&gt;</span>right<span class="hl opt">);</span>
	branches<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	branches<span class="hl opt">-&gt;</span>op <span class="hl opt">=</span> <span class="hl str">'='</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> branches<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - parsebranch - parse one branch of an RE</span>
<span class="hl com"> * This mostly manages concatenation, working closely with parseqatom().</span>
<span class="hl com"> * Concatenated things are bundled up as much as possible, with separate</span>
<span class="hl com"> * ',' nodes introduced only when necessary due to substructure.</span>
<span class="hl com"> ^ static struct subre *parsebranch(struct vars *, int, int, struct state *,</span>
<span class="hl com"> ^ 	struct state *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span>
<span class="hl kwd">parsebranch</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> stopper<span class="hl opt">,</span>		<span class="hl com">/* EOS or ')' */</span>
    <span class="hl kwb">int</span> type<span class="hl opt">,</span>			<span class="hl com">/* LACON (lookahead subRE) or PLAIN */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>left<span class="hl opt">,</span>		<span class="hl com">/* leftmost state */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>right<span class="hl opt">,</span>	<span class="hl com">/* rightmost state */</span>
    <span class="hl kwb">int</span> partial<span class="hl opt">)</span>		<span class="hl com">/* is this only part of a branch? */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">;</span>		<span class="hl com">/* left end of current construct */</span>
    <span class="hl kwb">int</span> seencontent<span class="hl opt">;</span>		<span class="hl com">/* is there anything in this branch yet? */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">;</span>

    lp <span class="hl opt">=</span> left<span class="hl opt">;</span>
    seencontent <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    t <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">);</span>	<span class="hl com">/* op '=' is tentative */</span>
    <span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
    <span class="hl kwa">while</span> <span class="hl opt">(!</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'|'</span><span class="hl opt">) &amp;&amp; !</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>stopper<span class="hl opt">) &amp;&amp; !</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">)) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>seencontent<span class="hl opt">) {</span>	<span class="hl com">/* implicit concat operator */</span>
	    lp <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	    <span class="hl kwd">NOERRN</span><span class="hl opt">();</span>
	    <span class="hl kwd">moveins</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> right<span class="hl opt">,</span> lp<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	seencontent <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl com">/* NB, recursion in parseqatom() may swallow rest of branch */</span>
	<span class="hl kwd">parseqatom</span><span class="hl opt">(</span>v<span class="hl opt">,</span> stopper<span class="hl opt">,</span> type<span class="hl opt">,</span> lp<span class="hl opt">,</span> right<span class="hl opt">,</span> t<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span>seencontent<span class="hl opt">) {</span>		<span class="hl com">/* empty branch */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>partial<span class="hl opt">) {</span>
	    <span class="hl kwd">NOTE</span><span class="hl opt">(</span>REG_UUNSPEC<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>lp <span class="hl opt">==</span> left<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>left<span class="hl opt">,</span> right<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> t<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - parseqatom - parse one quantified atom or constraint of an RE</span>
<span class="hl com"> * The bookkeeping near the end cooperates very closely with parsebranch(); in</span>
<span class="hl com"> * particular, it contains a recursion that can involve parsing the rest of</span>
<span class="hl com"> * the branch, making this function's name somewhat inaccurate.</span>
<span class="hl com"> ^ static void parseqatom(struct vars *, int, int, struct state *,</span>
<span class="hl com"> ^ 	struct state *, struct subre *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">parseqatom</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> stopper<span class="hl opt">,</span>		<span class="hl com">/* EOS or ')' */</span>
    <span class="hl kwb">int</span> type<span class="hl opt">,</span>			<span class="hl com">/* LACON (lookahead subRE) or PLAIN */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>		<span class="hl com">/* left state to hang it on */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">,</span>		<span class="hl com">/* right state to hang it on */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>top<span class="hl opt">)</span>		<span class="hl com">/* subtree top */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>s<span class="hl opt">;</span>		<span class="hl com">/* temporaries for new states */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>s2<span class="hl opt">;</span>
<span class="hl ppc">#define	ARCV(t, val)	newarc(v-&gt;nfa, t, val, lp, rp)</span>
    <span class="hl kwb">int</span> m<span class="hl opt">,</span> n<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>atom<span class="hl opt">;</span>		<span class="hl com">/* atom's subtree */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">;</span>
    <span class="hl kwb">int</span> cap<span class="hl opt">;</span>			<span class="hl com">/* capturing parens? */</span>
    <span class="hl kwb">int</span> pos<span class="hl opt">;</span>			<span class="hl com">/* positive lookahead? */</span>
    <span class="hl kwb">int</span> subno<span class="hl opt">;</span>			<span class="hl com">/* capturing-parens or backref number */</span>
    <span class="hl kwb">int</span> atomtype<span class="hl opt">;</span>
    <span class="hl kwb">int</span> qprefer<span class="hl opt">;</span>		<span class="hl com">/* quantifier short/long preference */</span>
    <span class="hl kwb">int</span> f<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">**</span>atomp<span class="hl opt">;</span>	<span class="hl com">/* where the pointer to atom is */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Initial bookkeeping.</span>
<span class="hl com">     */</span>

    atom <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>lp<span class="hl opt">-&gt;</span>nouts <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">);</span>	<span class="hl com">/* must string new code */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>rp<span class="hl opt">-&gt;</span>nins <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">);</span>	<span class="hl com">/* between lp and rp */</span>
    subno <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>			<span class="hl com">/* just to shut lint up */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * An atom or constraint...</span>
<span class="hl com">     */</span>

    atomtype <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nexttype<span class="hl opt">;</span>
    <span class="hl kwa">switch</span> <span class="hl opt">(</span>atomtype<span class="hl opt">) {</span>
	<span class="hl com">/* first, constraints, which end by returning */</span>
    <span class="hl kwa">case</span> <span class="hl str">'^'</span><span class="hl opt">:</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'^'</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLANCH<span class="hl opt">) {</span>
	    <span class="hl kwd">ARCV</span><span class="hl opt">(</span>BEHIND<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nlcolor<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'$'</span><span class="hl opt">:</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'$'</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLANCH<span class="hl opt">) {</span>
	    <span class="hl kwd">ARCV</span><span class="hl opt">(</span>AHEAD<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nlcolor<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> SBEGIN<span class="hl opt">:</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'^'</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>		<span class="hl com">/* BOL */</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'^'</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>		<span class="hl com">/* or BOS */</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> SEND<span class="hl opt">:</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'$'</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>		<span class="hl com">/* EOL */</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span><span class="hl str">'$'</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>		<span class="hl com">/* or EOS */</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'&lt;'</span><span class="hl opt">:</span>
	<span class="hl kwd">wordchrs</span><span class="hl opt">(</span>v<span class="hl opt">);</span>		<span class="hl com">/* does NEXT() */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'&gt;'</span><span class="hl opt">:</span>
	<span class="hl kwd">wordchrs</span><span class="hl opt">(</span>v<span class="hl opt">);</span>		<span class="hl com">/* does NEXT() */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> WBDRY<span class="hl opt">:</span>
	<span class="hl kwd">wordchrs</span><span class="hl opt">(</span>v<span class="hl opt">);</span>		<span class="hl com">/* does NEXT() */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> NWBDRY<span class="hl opt">:</span>
	<span class="hl kwd">wordchrs</span><span class="hl opt">(</span>v<span class="hl opt">);</span>		<span class="hl com">/* does NEXT() */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">word</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> BEHIND<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">nonword</span><span class="hl opt">(</span>v<span class="hl opt">,</span> AHEAD<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> LACON<span class="hl opt">:</span>			<span class="hl com">/* lookahead constraint */</span>
	pos <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	t <span class="hl opt">=</span> <span class="hl kwd">parse</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">')'</span><span class="hl opt">,</span> LACON<span class="hl opt">,</span> s<span class="hl opt">,</span> s2<span class="hl opt">);</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> t<span class="hl opt">);</span>	<span class="hl com">/* internal structure irrelevant */</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">')'</span><span class="hl opt">) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	n <span class="hl opt">=</span> <span class="hl kwd">newlacon</span><span class="hl opt">(</span>v<span class="hl opt">,</span> s<span class="hl opt">,</span> s2<span class="hl opt">,</span> pos<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">ARCV</span><span class="hl opt">(</span>LACON<span class="hl opt">,</span> n<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Then errors, to get them out of the way.</span>
<span class="hl com">	 */</span>

    <span class="hl kwa">case</span> <span class="hl str">'*'</span><span class="hl opt">:</span>
    <span class="hl kwa">case</span> <span class="hl str">'+'</span><span class="hl opt">:</span>
    <span class="hl kwa">case</span> <span class="hl str">'?'</span><span class="hl opt">:</span>
    <span class="hl kwa">case</span> <span class="hl str">'{'</span><span class="hl opt">:</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_BADRPT<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwa">default</span><span class="hl opt">:</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ASSERT<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Then plain characters, and minor variants on that theme.</span>
<span class="hl com">	 */</span>

    <span class="hl kwa">case</span> <span class="hl str">')'</span><span class="hl opt">:</span>			<span class="hl com">/* unbalanced paren */</span>
	<span class="hl kwa">if</span> <span class="hl opt">((</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ADVANCED<span class="hl opt">) !=</span> REG_EXTENDED<span class="hl opt">) {</span>
	    <span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_EPAREN<span class="hl opt">);</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Legal in EREs due to specification botch.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">NOTE</span><span class="hl opt">(</span>REG_UPBOTCH<span class="hl opt">);</span>
	<span class="hl com">/* fallthrough into case PLAIN */</span>
    <span class="hl kwa">case</span> PLAIN<span class="hl opt">:</span>
	<span class="hl kwd">onechr</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">okcolors</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'['</span><span class="hl opt">:</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nextvalue <span class="hl opt">==</span> <span class="hl num">1</span><span class="hl opt">) {</span>
	    <span class="hl kwd">bracket</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    <span class="hl kwd">cbracket</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">']'</span><span class="hl opt">) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'.'</span><span class="hl opt">:</span>
	<span class="hl kwd">rainbow</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span>
		<span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLSTOP<span class="hl opt">)</span> ? v<span class="hl opt">-&gt;</span>nlcolor <span class="hl opt">:</span> COLORLESS<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * And finally the ugly stuff.</span>
<span class="hl com">	 */</span>

    <span class="hl kwa">case</span> <span class="hl str">'('</span><span class="hl opt">:</span>			<span class="hl com">/* value flags as capturing or non */</span>
	cap <span class="hl opt">= (</span>type <span class="hl opt">==</span> LACON<span class="hl opt">)</span> ? <span class="hl num">0</span> <span class="hl opt">:</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>cap<span class="hl opt">) {</span>
	    v<span class="hl opt">-&gt;</span>nsubexp<span class="hl opt">++;</span>
	    subno <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nsubexp<span class="hl opt">;</span>
	    <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>subno <span class="hl opt">&gt;=</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">) {</span>
		<span class="hl kwd">moresubs</span><span class="hl opt">(</span>v<span class="hl opt">,</span> subno<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">assert</span><span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>subno <span class="hl opt">&lt;</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    atomtype <span class="hl opt">=</span> PLAIN<span class="hl opt">;</span>	<span class="hl com">/* something that's not '(' */</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Need new endpoints because tree will contain pointers.</span>
<span class="hl com">	 */</span>

	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s2<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	atom <span class="hl opt">=</span> <span class="hl kwd">parse</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">')'</span><span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> s<span class="hl opt">,</span> s2<span class="hl opt">);</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">')'</span><span class="hl opt">) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>cap<span class="hl opt">) {</span>
	    v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>subno<span class="hl opt">] =</span> atom<span class="hl opt">;</span>
	    t <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'('</span><span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>flags<span class="hl opt">|</span>CAP<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	    t<span class="hl opt">-&gt;</span>subno <span class="hl opt">=</span> subno<span class="hl opt">;</span>
	    t<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> atom<span class="hl opt">;</span>
	    atom <span class="hl opt">=</span> t<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Postpone everything else pending possible {0}.</span>
<span class="hl com">	 */</span>

	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> BACKREF<span class="hl opt">:</span>		<span class="hl com">/* the Feature From The Black Lagoon */</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>type <span class="hl opt">!=</span> LACON<span class="hl opt">,</span> REG_ESUBREG<span class="hl opt">);</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nextvalue <span class="hl opt">&lt;</span> v<span class="hl opt">-&gt;</span>nsubs<span class="hl opt">,</span> REG_ESUBREG<span class="hl opt">);</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">] !=</span> NULL<span class="hl opt">,</span> REG_ESUBREG<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nextvalue <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">);</span>
	atom <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'b'</span><span class="hl opt">,</span> BACKR<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	subno <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	atom<span class="hl opt">-&gt;</span>subno <span class="hl opt">=</span> subno<span class="hl opt">;</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>	<span class="hl com">/* temporarily, so there's something */</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * ...and an atom may be followed by a quantifier.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">switch</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nexttype<span class="hl opt">) {</span>
    <span class="hl kwa">case</span> <span class="hl str">'*'</span><span class="hl opt">:</span>
	m <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	n <span class="hl opt">=</span> INFINITY<span class="hl opt">;</span>
	qprefer <span class="hl opt">= (</span>v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">)</span> ? LONGER <span class="hl opt">:</span> SHORTER<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'+'</span><span class="hl opt">:</span>
	m <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
	n <span class="hl opt">=</span> INFINITY<span class="hl opt">;</span>
	qprefer <span class="hl opt">= (</span>v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">)</span> ? LONGER <span class="hl opt">:</span> SHORTER<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'?'</span><span class="hl opt">:</span>
	m <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	n <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
	qprefer <span class="hl opt">= (</span>v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">)</span> ? LONGER <span class="hl opt">:</span> SHORTER<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl str">'{'</span><span class="hl opt">:</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	m <span class="hl opt">=</span> <span class="hl kwd">scannum</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">EAT</span><span class="hl opt">(</span><span class="hl str">','</span><span class="hl opt">)) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>DIGIT<span class="hl opt">)) {</span>
		n <span class="hl opt">=</span> <span class="hl kwd">scannum</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
		n <span class="hl opt">=</span> INFINITY<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>m <span class="hl opt">&gt;</span> n<span class="hl opt">) {</span>
		<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_BADBR<span class="hl opt">);</span>
		<span class="hl kwa">return</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>

	    <span class="hl com">/*</span>
<span class="hl com">	     * {m,n} exercises preference, even if it's {m,m}</span>
<span class="hl com">	     */</span>

	    qprefer <span class="hl opt">= (</span>v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">)</span> ? LONGER <span class="hl opt">:</span> SHORTER<span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    n <span class="hl opt">=</span> m<span class="hl opt">;</span>
	    <span class="hl com">/*</span>
<span class="hl com">	     * {m} passes operand's preference through.</span>
<span class="hl com">	     */</span>

	    qprefer <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'}'</span><span class="hl opt">)) {</span>	<span class="hl com">/* catches errors too */</span>
	    <span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_BADBR<span class="hl opt">);</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">default</span><span class="hl opt">:</span>			<span class="hl com">/* no quantifier */</span>
	m <span class="hl opt">=</span> n <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
	qprefer <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Annoying special case: {0} or {0,0} cancels everything.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>m <span class="hl opt">==</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> n <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>atom <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> atom<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>atomtype <span class="hl opt">==</span> <span class="hl str">'('</span><span class="hl opt">) {</span>
	    v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>subno<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">delsub</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If not a messy case, avoid hard part.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">assert</span><span class="hl opt">(!</span><span class="hl kwd">MESSY</span><span class="hl opt">(</span>top<span class="hl opt">-&gt;</span>flags<span class="hl opt">));</span>
    f <span class="hl opt">=</span> top<span class="hl opt">-&gt;</span>flags <span class="hl opt">|</span> qprefer <span class="hl opt">| ((</span>atom <span class="hl opt">!=</span> NULL<span class="hl opt">)</span> ? atom<span class="hl opt">-&gt;</span>flags <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>atomtype <span class="hl opt">!=</span> <span class="hl str">'('</span> <span class="hl opt">&amp;&amp;</span> atomtype <span class="hl opt">!=</span> BACKREF <span class="hl opt">&amp;&amp; !</span><span class="hl kwd">MESSY</span><span class="hl opt">(</span><span class="hl kwd">UP</span><span class="hl opt">(</span>f<span class="hl opt">))) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!(</span>m <span class="hl opt">==</span> <span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> n <span class="hl opt">==</span> <span class="hl num">1</span><span class="hl opt">)) {</span>
	    <span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">,</span> m<span class="hl opt">,</span> n<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>atom <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> atom<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	top<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> f<span class="hl opt">;</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * hard part: something messy</span>
<span class="hl com">     * That is, capturing parens, back reference, short/long clash, or an atom</span>
<span class="hl com">     * with substructure containing one of those.</span>
<span class="hl com">     */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Now we'll need a subre for the contents even if they're boring.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>atom <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	atom <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Prepare a general-purpose state skeleton.</span>
<span class="hl com">     *</span>
<span class="hl com">     *    ---&gt; [s] ---prefix---&gt; [begin] ---atom---&gt; [end] ----rest---&gt; [rp]</span>
<span class="hl com">     *   /                                            /</span>
<span class="hl com">     * [lp] ----&gt; [s2] ----bypass---------------------</span>
<span class="hl com">     *</span>
<span class="hl com">     * where bypass is an empty, and prefix is some repetitions of atom</span>
<span class="hl com">     */</span>

    s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>	<span class="hl com">/* first, new endpoints for the atom */</span>
    s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
    <span class="hl kwd">moveins</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> rp<span class="hl opt">,</span> s2<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    atom<span class="hl opt">-&gt;</span>begin <span class="hl opt">=</span> s<span class="hl opt">;</span>
    atom<span class="hl opt">-&gt;</span>end <span class="hl opt">=</span> s2<span class="hl opt">;</span>
    s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>	<span class="hl com">/* and spots for prefix and bypass */</span>
    s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
    <span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s2<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Break remaining subRE into x{...} and what follows.</span>
<span class="hl com">     */</span>

    t <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'.'</span><span class="hl opt">,</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>qprefer<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>flags<span class="hl opt">),</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    t<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> atom<span class="hl opt">;</span>
    atomp <span class="hl opt">= &amp;</span>t<span class="hl opt">-&gt;</span>left<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Here we should recurse... but we must postpone that to the end.</span>
<span class="hl com">     */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Split top into prefix and remaining.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>top<span class="hl opt">-&gt;</span>op <span class="hl opt">==</span> <span class="hl str">'='</span> <span class="hl opt">&amp;&amp;</span> top<span class="hl opt">-&gt;</span>left <span class="hl opt">==</span> NULL <span class="hl opt">&amp;&amp;</span> top<span class="hl opt">-&gt;</span>right <span class="hl opt">==</span> NULL<span class="hl opt">);</span>
    top<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> top<span class="hl opt">-&gt;</span>flags<span class="hl opt">,</span> top<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> lp<span class="hl opt">);</span>
    top<span class="hl opt">-&gt;</span>op <span class="hl opt">=</span> <span class="hl str">'.'</span><span class="hl opt">;</span>
    top<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> t<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If it's a backref, now is the time to replicate the subNFA.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>atomtype <span class="hl opt">==</span> BACKREF<span class="hl opt">) {</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">-&gt;</span>nouts <span class="hl opt">==</span> <span class="hl num">1</span><span class="hl opt">);</span>	<span class="hl com">/* just the EMPTY */</span>
	<span class="hl kwd">delsub</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>subno<span class="hl opt">] !=</span> NULL<span class="hl opt">);</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * And here's why the recursion got postponed: it must wait until the</span>
<span class="hl com">	 * skeleton is filled in, because it may hit a backref that wants to</span>
<span class="hl com">	 * copy the filled-in skeleton.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">dupnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>subno<span class="hl opt">]-&gt;</span>begin<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>subs<span class="hl opt">[</span>subno<span class="hl opt">]-&gt;</span>end<span class="hl opt">,</span>
		atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * It's quantifier time; first, turn x{0,...} into x{1,...}|empty</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>m <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s2<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span><span class="hl com">/* the bypass */</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">PREF</span><span class="hl opt">(</span>qprefer<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">);</span>
	f <span class="hl opt">=</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>qprefer<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
	t <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'|'</span><span class="hl opt">,</span> f<span class="hl opt">,</span> lp<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	t<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> atom<span class="hl opt">;</span>
	t<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'|'</span><span class="hl opt">,</span> <span class="hl kwd">PREF</span><span class="hl opt">(</span>f<span class="hl opt">),</span> s2<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	t<span class="hl opt">-&gt;</span>right<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> s2<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl opt">*</span>atomp <span class="hl opt">=</span> t<span class="hl opt">;</span>
	atomp <span class="hl opt">= &amp;</span>t<span class="hl opt">-&gt;</span>left<span class="hl opt">;</span>
	m <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Deal with the rest of the quantifier.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>atomtype <span class="hl opt">==</span> BACKREF<span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Special case: backrefs have internal quantifiers.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">);</span>	<span class="hl com">/* empty prefix */</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Just stuff everything into atom.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> m<span class="hl opt">,</span> n<span class="hl opt">);</span>
	atom<span class="hl opt">-&gt;</span>min <span class="hl opt">= (</span><span class="hl kwb">short</span><span class="hl opt">)</span> m<span class="hl opt">;</span>
	atom<span class="hl opt">-&gt;</span>max <span class="hl opt">= (</span><span class="hl kwb">short</span><span class="hl opt">)</span> n<span class="hl opt">;</span>
	atom<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>qprefer<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>m <span class="hl opt">==</span> <span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> n <span class="hl opt">==</span> <span class="hl num">1</span><span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * No/vacuous quantifier: done.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">);</span>	<span class="hl com">/* empty prefix */</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Turn x{m,n} into x{m-1,n-1}x, with capturing parens in only second</span>
<span class="hl com">	 * x</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">dupnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">);</span>
	<span class="hl kwa">assert</span><span class="hl opt">(</span>m <span class="hl opt">&gt;=</span> <span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> m <span class="hl opt">!=</span> INFINITY <span class="hl opt">&amp;&amp;</span> n <span class="hl opt">&gt;=</span> <span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> m<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">, (</span>n <span class="hl opt">==</span> INFINITY<span class="hl opt">)</span> ? n <span class="hl opt">:</span> n<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">);</span>
	f <span class="hl opt">=</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>qprefer<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
	t <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'.'</span><span class="hl opt">,</span> f<span class="hl opt">,</span> s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">);</span>	<span class="hl com">/* prefix and atom */</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	t<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> <span class="hl kwd">PREF</span><span class="hl opt">(</span>f<span class="hl opt">),</span> s<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>begin<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	t<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> atom<span class="hl opt">;</span>
	<span class="hl opt">*</span>atomp <span class="hl opt">=</span> t<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * And finally, look after that postponed recursion.</span>
<span class="hl com">     */</span>

    t <span class="hl opt">=</span> top<span class="hl opt">-&gt;</span>right<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'|'</span><span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>stopper<span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">))) {</span>
	t<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> <span class="hl kwd">parsebranch</span><span class="hl opt">(</span>v<span class="hl opt">,</span> stopper<span class="hl opt">,</span> type<span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> rp<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>atom<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	t<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> <span class="hl kwd">subre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl str">'='</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> atom<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'|'</span><span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>stopper<span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">));</span>
    t<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>right<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
    top<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> <span class="hl kwd">COMBINE</span><span class="hl opt">(</span>top<span class="hl opt">-&gt;</span>flags<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>flags<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - nonword - generate arcs for non-word-character ahead or behind</span>
<span class="hl com"> ^ static void nonword(struct vars *, int, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">nonword</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> dir<span class="hl opt">,</span>			<span class="hl com">/* AHEAD or BEHIND */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> anchor <span class="hl opt">= (</span>dir <span class="hl opt">==</span> AHEAD<span class="hl opt">)</span> ? <span class="hl str">'$'</span> <span class="hl opt">:</span> <span class="hl str">'^'</span><span class="hl opt">;</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>dir <span class="hl opt">==</span> AHEAD <span class="hl opt">||</span> dir <span class="hl opt">==</span> BEHIND<span class="hl opt">);</span>
    <span class="hl kwd">newarc</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> anchor<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl kwd">newarc</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> anchor<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl kwd">colorcomplement</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> dir<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>wordchrs<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl com">/* (no need for special attention to \n) */</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - word - generate arcs for word character ahead or behind</span>
<span class="hl com"> ^ static void word(struct vars *, int, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">word</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> dir<span class="hl opt">,</span>			<span class="hl com">/* AHEAD or BEHIND */</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>dir <span class="hl opt">==</span> AHEAD <span class="hl opt">||</span> dir <span class="hl opt">==</span> BEHIND<span class="hl opt">);</span>
    <span class="hl kwd">cloneouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>wordchrs<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">,</span> dir<span class="hl opt">);</span>
    <span class="hl com">/* (no need for special attention to \n) */</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - scannum - scan a number</span>
<span class="hl com"> ^ static int scannum(struct vars *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>			<span class="hl com">/* value, &lt;= DUPMAX */</span>
<span class="hl kwd">scannum</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> n <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl kwa">while</span> <span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>DIGIT<span class="hl opt">) &amp;&amp;</span> n <span class="hl opt">&lt;</span> DUPMAX<span class="hl opt">) {</span>
	n <span class="hl opt">=</span> n<span class="hl opt">*</span><span class="hl num">10</span> <span class="hl opt">+</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>DIGIT<span class="hl opt">) ||</span> n <span class="hl opt">&gt;</span> DUPMAX<span class="hl opt">) {</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_BADBR<span class="hl opt">);</span>
	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> n<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - repeat - replicate subNFA for quantifiers</span>
<span class="hl com"> * The duplication sequences used here are chosen carefully so that any</span>
<span class="hl com"> * pointers starting out pointing into the subexpression end up pointing into</span>
<span class="hl com"> * the last occurrence. (Note that it may not be strung between the same left</span>
<span class="hl com"> * and right end states, however!) This used to be important for the subRE</span>
<span class="hl com"> * tree, although the important bits are now handled by the in-line code in</span>
<span class="hl com"> * parse(), and when this is called, it doesn't matter any more.</span>
<span class="hl com"> ^ static void repeat(struct vars *, struct state *, struct state *, int, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">repeat</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> m<span class="hl opt">,</span>
    <span class="hl kwb">int</span> n<span class="hl opt">)</span>
<span class="hl opt">{</span>
<span class="hl ppc">#define	SOME		2</span>
<span class="hl ppc">#define	INF		3</span>
<span class="hl ppc">#define	PAIR(x, y)	((x)*4 + (y))</span>
<span class="hl ppc">#define	REDUCE(x)	( ((x) == INFINITY) ? INF : (((x) &gt; 1) ? SOME : (x)) )</span>
    <span class="hl kwb">const int</span> rm <span class="hl opt">=</span> <span class="hl kwd">REDUCE</span><span class="hl opt">(</span>m<span class="hl opt">);</span>
    <span class="hl kwb">const int</span> rn <span class="hl opt">=</span> <span class="hl kwd">REDUCE</span><span class="hl opt">(</span>n<span class="hl opt">);</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>s<span class="hl opt">, *</span>s2<span class="hl opt">;</span>

    <span class="hl kwa">switch</span> <span class="hl opt">(</span><span class="hl kwd">PAIR</span><span class="hl opt">(</span>rm<span class="hl opt">,</span> rn<span class="hl opt">)) {</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">):</span>		<span class="hl com">/* empty string */</span>
	<span class="hl kwd">delsub</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">):</span>		<span class="hl com">/* do as x| */</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">,</span> SOME<span class="hl opt">):</span>		<span class="hl com">/* do as x{1,n}| */</span>
	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> n<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">,</span> INF<span class="hl opt">):</span>		<span class="hl com">/* loop x around */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">moveins</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> rp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">):</span>		<span class="hl com">/* no action required */</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,</span> SOME<span class="hl opt">):</span>		<span class="hl com">/* do as x{0,n-1}x = (x{1,n-1}|)x */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">dupnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> n<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,</span> INF<span class="hl opt">):</span>		<span class="hl com">/* add loopback arc */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	s2 <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">moveins</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> rp<span class="hl opt">,</span> s2<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s2<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwd">EMPTYARC</span><span class="hl opt">(</span>s2<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span>SOME<span class="hl opt">,</span> SOME<span class="hl opt">):</span>		<span class="hl com">/* do as x{m-1,n-1}x */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">dupnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">,</span> m<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">,</span> n<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> <span class="hl kwd">PAIR</span><span class="hl opt">(</span>SOME<span class="hl opt">,</span> INF<span class="hl opt">):</span>		<span class="hl com">/* do as x{m-1,}x */</span>
	s <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">moveouts</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">dupnfa</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> s<span class="hl opt">,</span> rp<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">repeat</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> s<span class="hl opt">,</span> m<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">,</span> n<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">default</span><span class="hl opt">:</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ASSERT<span class="hl opt">);</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - bracket - handle non-complemented bracket expression</span>
<span class="hl com"> * Also called from cbracket for complemented bracket expressions.</span>
<span class="hl com"> ^ static void bracket(struct vars *, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">bracket</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'['</span><span class="hl opt">));</span>
    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>
    <span class="hl kwa">while</span> <span class="hl opt">(!</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">']'</span><span class="hl opt">) &amp;&amp; !</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>EOS<span class="hl opt">)) {</span>
	<span class="hl kwd">brackpart</span><span class="hl opt">(</span>v<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">']'</span><span class="hl opt">) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
    <span class="hl kwd">okcolors</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - cbracket - handle complemented bracket expression</span>
<span class="hl com"> * We do it by calling bracket() with dummy endpoints, and then complementing</span>
<span class="hl com"> * the result. The alternative would be to invoke rainbow(), and then delete</span>
<span class="hl com"> * arcs as the b.e. is seen... but that gets messy.</span>
<span class="hl com"> ^ static void cbracket(struct vars *, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">cbracket</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>left <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>right <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>

    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">bracket</span><span class="hl opt">(</span>v<span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_NLSTOP<span class="hl opt">) {</span>
	<span class="hl kwd">newarc</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nlcolor<span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>lp<span class="hl opt">-&gt;</span>nouts <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">);</span>	<span class="hl com">/* all outarcs will be ours */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Easy part of complementing, and all there is to do since the MCCE code</span>
<span class="hl com">     * was removed.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">colorcomplement</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> left<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">dropstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> left<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>right<span class="hl opt">-&gt;</span>nins <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwd">freestate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> right<span class="hl opt">);</span>
    <span class="hl kwa">return</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - brackpart - handle one item (or range) within a bracket expression</span>
<span class="hl com"> ^ static void brackpart(struct vars *, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">brackpart</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    celt startc<span class="hl opt">,</span> endc<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> cvec <span class="hl opt">*</span>cv<span class="hl opt">;</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>startp<span class="hl opt">, *</span>endp<span class="hl opt">;</span>
    chr c<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">];</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Parse something, get rid of special cases, take shortcuts.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">switch</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nexttype<span class="hl opt">) {</span>
    <span class="hl kwa">case</span> RANGE<span class="hl opt">:</span>			<span class="hl com">/* a-b-c or other botch */</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ERANGE<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> PLAIN<span class="hl opt">:</span>
	c<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Shortcut for ordinary chr (not range).</span>
<span class="hl com">	 */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>RANGE<span class="hl opt">)) {</span>
	    <span class="hl kwd">onechr</span><span class="hl opt">(</span>v<span class="hl opt">,</span> c<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	startc <span class="hl opt">=</span> <span class="hl kwd">element</span><span class="hl opt">(</span>v<span class="hl opt">,</span> c<span class="hl opt">,</span> c<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> COLLEL<span class="hl opt">:</span>
	startp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
	endp <span class="hl opt">=</span> <span class="hl kwd">scanplain</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>startp <span class="hl opt">&lt;</span> endp<span class="hl opt">,</span> REG_ECOLLATE<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	startc <span class="hl opt">=</span> <span class="hl kwd">element</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startp<span class="hl opt">,</span> endp<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> ECLASS<span class="hl opt">:</span>
	startp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
	endp <span class="hl opt">=</span> <span class="hl kwd">scanplain</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>startp <span class="hl opt">&lt;</span> endp<span class="hl opt">,</span> REG_ECOLLATE<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	startc <span class="hl opt">=</span> <span class="hl kwd">element</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startp<span class="hl opt">,</span> endp<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	cv <span class="hl opt">=</span> <span class="hl kwd">eclass</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startc<span class="hl opt">, (</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ICASE<span class="hl opt">));</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">dovec</span><span class="hl opt">(</span>v<span class="hl opt">,</span> cv<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">case</span> CCLASS<span class="hl opt">:</span>
	startp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
	endp <span class="hl opt">=</span> <span class="hl kwd">scanplain</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	<span class="hl kwd">INSIST</span><span class="hl opt">(</span>startp <span class="hl opt">&lt;</span> endp<span class="hl opt">,</span> REG_ECTYPE<span class="hl opt">);</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	cv <span class="hl opt">=</span> <span class="hl kwd">cclass</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startp<span class="hl opt">,</span> endp<span class="hl opt">, (</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ICASE<span class="hl opt">));</span>
	<span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	<span class="hl kwd">dovec</span><span class="hl opt">(</span>v<span class="hl opt">,</span> cv<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl kwa">default</span><span class="hl opt">:</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ASSERT<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>RANGE<span class="hl opt">)) {</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	<span class="hl kwa">switch</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nexttype<span class="hl opt">) {</span>
	<span class="hl kwa">case</span> PLAIN<span class="hl opt">:</span>
	<span class="hl kwa">case</span> RANGE<span class="hl opt">:</span>
	    c<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> v<span class="hl opt">-&gt;</span>nextvalue<span class="hl opt">;</span>
	    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>
	    endc <span class="hl opt">=</span> <span class="hl kwd">element</span><span class="hl opt">(</span>v<span class="hl opt">,</span> c<span class="hl opt">,</span> c<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">);</span>
	    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	    <span class="hl kwa">break</span><span class="hl opt">;</span>
	<span class="hl kwa">case</span> COLLEL<span class="hl opt">:</span>
	    startp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
	    endp <span class="hl opt">=</span> <span class="hl kwd">scanplain</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
	    <span class="hl kwd">INSIST</span><span class="hl opt">(</span>startp <span class="hl opt">&lt;</span> endp<span class="hl opt">,</span> REG_ECOLLATE<span class="hl opt">);</span>
	    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	    endc <span class="hl opt">=</span> <span class="hl kwd">element</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startp<span class="hl opt">,</span> endp<span class="hl opt">);</span>
	    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
	    <span class="hl kwa">break</span><span class="hl opt">;</span>
	<span class="hl kwa">default</span><span class="hl opt">:</span>
	    <span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ERANGE<span class="hl opt">);</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	    <span class="hl kwa">break</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	endc <span class="hl opt">=</span> startc<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Ranges are unportable. Actually, standard C does guarantee that digits</span>
<span class="hl com">     * are contiguous, but making that an exception is just too complicated.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>startc <span class="hl opt">!=</span> endc<span class="hl opt">) {</span>
	<span class="hl kwd">NOTE</span><span class="hl opt">(</span>REG_UUNPORT<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    cv <span class="hl opt">=</span> <span class="hl kwd">range</span><span class="hl opt">(</span>v<span class="hl opt">,</span> startc<span class="hl opt">,</span> endc<span class="hl opt">, (</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ICASE<span class="hl opt">));</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    <span class="hl kwd">dovec</span><span class="hl opt">(</span>v<span class="hl opt">,</span> cv<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - scanplain - scan PLAIN contents of [. etc.</span>
<span class="hl com"> * Certain bits of trickery in lex.c know that this code does not try to look</span>
<span class="hl com"> * past the final bracket of the [. etc.</span>
<span class="hl com"> ^ static const chr *scanplain(struct vars *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static const</span> chr <span class="hl opt">*</span>		<span class="hl com">/* just after end of sequence */</span>
<span class="hl kwd">scanplain</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>endp<span class="hl opt">;</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>COLLEL<span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>ECLASS<span class="hl opt">) ||</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span>CCLASS<span class="hl opt">));</span>
    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>

    endp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>PLAIN<span class="hl opt">)) {</span>
	endp <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>now<span class="hl opt">;</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">SEE</span><span class="hl opt">(</span>END<span class="hl opt">) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>

    <span class="hl kwa">return</span> endp<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - onechr - fill in arcs for a plain character, and possible case complements</span>
<span class="hl com"> * This is mostly a shortcut for efficient handling of the common case.</span>
<span class="hl com"> ^ static void onechr(struct vars *, pchr, struct state *, struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">onechr</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    pchr c<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!(</span>v<span class="hl opt">-&gt;</span>cflags<span class="hl opt">&amp;</span>REG_ICASE<span class="hl opt">)) {</span>
	<span class="hl kwd">newarc</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> <span class="hl kwd">subcolor</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> c<span class="hl opt">),</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Rats, need general case anyway...</span>
<span class="hl com">     */</span>

    <span class="hl kwd">dovec</span><span class="hl opt">(</span>v<span class="hl opt">,</span> <span class="hl kwd">allcases</span><span class="hl opt">(</span>v<span class="hl opt">,</span> c<span class="hl opt">),</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - dovec - fill in arcs for each element of a cvec</span>
<span class="hl com"> ^ static void dovec(struct vars *, struct cvec *, struct state *,</span>
<span class="hl com"> ^ 	struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">dovec</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> cvec <span class="hl opt">*</span>cv<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>lp<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>rp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    chr ch<span class="hl opt">,</span> from<span class="hl opt">,</span> to<span class="hl opt">;</span>
    <span class="hl kwb">const</span> chr <span class="hl opt">*</span>p<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>p <span class="hl opt">=</span> cv<span class="hl opt">-&gt;</span>chrs<span class="hl opt">,</span> i <span class="hl opt">=</span> cv<span class="hl opt">-&gt;</span>nchrs<span class="hl opt">;</span> i <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">;</span> p<span class="hl opt">++,</span> i<span class="hl opt">--) {</span>
	ch <span class="hl opt">= *</span>p<span class="hl opt">;</span>
	<span class="hl kwd">newarc</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">,</span> PLAIN<span class="hl opt">,</span> <span class="hl kwd">subcolor</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> ch<span class="hl opt">),</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>p <span class="hl opt">=</span> cv<span class="hl opt">-&gt;</span>ranges<span class="hl opt">,</span> i <span class="hl opt">=</span> cv<span class="hl opt">-&gt;</span>nranges<span class="hl opt">;</span> i <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">;</span> p <span class="hl opt">+=</span> <span class="hl num">2</span><span class="hl opt">,</span> i<span class="hl opt">--) {</span>
	from <span class="hl opt">= *</span>p<span class="hl opt">;</span>
	to <span class="hl opt">= *(</span>p<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>from <span class="hl opt">&lt;=</span> to<span class="hl opt">) {</span>
	    <span class="hl kwd">subrange</span><span class="hl opt">(</span>v<span class="hl opt">,</span> from<span class="hl opt">,</span> to<span class="hl opt">,</span> lp<span class="hl opt">,</span> rp<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - wordchrs - set up word-chr list for word-boundary stuff, if needed</span>
<span class="hl com"> * The list is kept as a bunch of arcs between two dummy states; it's disposed</span>
<span class="hl com"> * of by the unreachable-states sweep in NFA optimization. Does NEXT(). Must</span>
<span class="hl com"> * not be called from any unusual lexical context. This should be reconciled</span>
<span class="hl com"> * with the \w etc. handling in lex.c, and should be cleaned up to reduce</span>
<span class="hl com"> * dependencies on input scanning.</span>
<span class="hl com"> ^ static void wordchrs(struct vars *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">wordchrs</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>left<span class="hl opt">, *</span>right<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>wordchrs <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">NEXT</span><span class="hl opt">();</span>		<span class="hl com">/* for consistency */</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    left <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    right <span class="hl opt">=</span> <span class="hl kwd">newstate</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Fine point: implemented with [::], and lexer will set REG_ULOCALE.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">lexword</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>savenow <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">'['</span><span class="hl opt">));</span>
    <span class="hl kwd">bracket</span><span class="hl opt">(</span>v<span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">((</span>v<span class="hl opt">-&gt;</span>savenow <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">SEE</span><span class="hl opt">(</span><span class="hl str">']'</span><span class="hl opt">)) ||</span> <span class="hl kwd">ISERR</span><span class="hl opt">());</span>
    <span class="hl kwd">NEXT</span><span class="hl opt">();</span>
    <span class="hl kwd">NOERR</span><span class="hl opt">();</span>
    v<span class="hl opt">-&gt;</span>wordchrs <span class="hl opt">=</span> left<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - subre - allocate a subre</span>
<span class="hl com"> ^ static struct subre *subre(struct vars *, int, int, struct state *,</span>
<span class="hl com"> ^	struct state *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static struct</span> subre <span class="hl opt">*</span>
<span class="hl kwd">subre</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">int</span> op<span class="hl opt">,</span>
    <span class="hl kwb">int</span> flags<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>begin<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>end<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>ret <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>treefree<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	v<span class="hl opt">-&gt;</span>treefree <span class="hl opt">=</span> ret<span class="hl opt">-&gt;</span>left<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	ret <span class="hl opt">= (</span><span class="hl kwb">struct</span> subre <span class="hl opt">*)</span> <span class="hl kwd">MALLOC</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre<span class="hl opt">));</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ESPACE<span class="hl opt">);</span>
	    <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	ret<span class="hl opt">-&gt;</span>chain <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>treechain<span class="hl opt">;</span>
	v<span class="hl opt">-&gt;</span>treechain <span class="hl opt">=</span> ret<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">strchr</span><span class="hl opt">(</span><span class="hl str">&quot;|.b(=&quot;</span><span class="hl opt">,</span> op<span class="hl opt">) !=</span> NULL<span class="hl opt">);</span>

    ret<span class="hl opt">-&gt;</span>op <span class="hl opt">=</span> op<span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> flags<span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>retry <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>subno <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>min <span class="hl opt">=</span> ret<span class="hl opt">-&gt;</span>max <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>right <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>begin <span class="hl opt">=</span> begin<span class="hl opt">;</span>
    ret<span class="hl opt">-&gt;</span>end <span class="hl opt">=</span> end<span class="hl opt">;</span>
    <span class="hl kwd">ZAPCNFA</span><span class="hl opt">(</span>ret<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">);</span>

    <span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - freesubre - free a subRE subtree</span>
<span class="hl com"> ^ static void freesubre(struct vars *, struct subre *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">freesubre</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>		<span class="hl com">/* might be NULL */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>sr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>sr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>sr<span class="hl opt">-&gt;</span>left <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> sr<span class="hl opt">-&gt;</span>left<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>sr<span class="hl opt">-&gt;</span>right <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>v<span class="hl opt">,</span> sr<span class="hl opt">-&gt;</span>right<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">freesrnode</span><span class="hl opt">(</span>v<span class="hl opt">,</span> sr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - freesrnode - free one node in a subRE subtree</span>
<span class="hl com"> ^ static void freesrnode(struct vars *, struct subre *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">freesrnode</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>		<span class="hl com">/* might be NULL */</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>sr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>sr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">NULLCNFA</span><span class="hl opt">(</span>sr<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">)) {</span>
	<span class="hl kwd">freecnfa</span><span class="hl opt">(&amp;</span>sr<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    sr<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>v <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	sr<span class="hl opt">-&gt;</span>left <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>treefree<span class="hl opt">;</span>
	v<span class="hl opt">-&gt;</span>treefree <span class="hl opt">=</span> sr<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl kwd">FREE</span><span class="hl opt">(</span>sr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - optst - optimize a subRE subtree</span>
<span class="hl com"> ^ static void optst(struct vars *, struct subre *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">optst</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/*</span>
<span class="hl com">     * DGP (2007-11-13): I assume it was the programmer's intent to eventually</span>
<span class="hl com">     * come back and add code to optimize subRE trees, but the routine coded</span>
<span class="hl com">     * just spends effort traversing the tree and doing nothing. We can do</span>
<span class="hl com">     * nothing with less effort.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">return</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - numst - number tree nodes (assigning retry indexes)</span>
<span class="hl com"> ^ static int numst(struct subre *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>			<span class="hl com">/* next number */</span>
<span class="hl kwd">numst</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">,</span>
    <span class="hl kwb">int</span> start<span class="hl opt">)</span>			<span class="hl com">/* starting point for subtree numbers */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>t <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    i <span class="hl opt">=</span> start<span class="hl opt">;</span>
    t<span class="hl opt">-&gt;</span>retry <span class="hl opt">= (</span><span class="hl kwb">short</span><span class="hl opt">)</span> i<span class="hl opt">++;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	i <span class="hl opt">=</span> <span class="hl kwd">numst</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left<span class="hl opt">,</span> i<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>right <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	i <span class="hl opt">=</span> <span class="hl kwd">numst</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>right<span class="hl opt">,</span> i<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> i<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - markst - mark tree nodes as INUSE</span>
<span class="hl com"> ^ static void markst(struct subre *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">markst</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>t <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    t<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> INUSE<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">markst</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>right <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">markst</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>right<span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - cleanst - free any tree nodes not marked INUSE</span>
<span class="hl com"> ^ static void cleanst(struct vars *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">cleanst</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>next<span class="hl opt">;</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>t <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>treechain<span class="hl opt">;</span> t <span class="hl opt">!=</span> NULL<span class="hl opt">;</span> t <span class="hl opt">=</span> next<span class="hl opt">) {</span>
	next <span class="hl opt">=</span> t<span class="hl opt">-&gt;</span>chain<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>INUSE<span class="hl opt">)) {</span>
	    <span class="hl kwd">FREE</span><span class="hl opt">(</span>t<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    v<span class="hl opt">-&gt;</span>treechain <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    v<span class="hl opt">-&gt;</span>treefree <span class="hl opt">=</span> NULL<span class="hl opt">;</span>		<span class="hl com">/* just on general principles */</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - nfatree - turn a subRE subtree into a tree of compacted NFAs</span>
<span class="hl com"> ^ static long nfatree(struct vars *, struct subre *, FILE *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static long</span>			<span class="hl com">/* optimize results from top node */</span>
<span class="hl kwd">nfatree</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">,</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>f<span class="hl opt">)</span>			<span class="hl com">/* for debug output */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>t <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> t<span class="hl opt">-&gt;</span>begin <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl opt">(</span>DISCARD<span class="hl opt">)</span> <span class="hl kwd">nfatree</span><span class="hl opt">(</span>v<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>left<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>right <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl opt">(</span>DISCARD<span class="hl opt">)</span> <span class="hl kwd">nfatree</span><span class="hl opt">(</span>v<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>right<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> <span class="hl kwd">nfanode</span><span class="hl opt">(</span>v<span class="hl opt">,</span> t<span class="hl opt">,</span> f<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - nfanode - do one NFA for nfatree</span>
<span class="hl com"> ^ static long nfanode(struct vars *, struct subre *, FILE *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static long</span>			<span class="hl com">/* optimize results */</span>
<span class="hl kwd">nfanode</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">,</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>f<span class="hl opt">)</span>			<span class="hl com">/* for debug output */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> nfa <span class="hl opt">*</span>nfa<span class="hl opt">;</span>
    <span class="hl kwb">long</span> ret <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwb">char</span> idbuf<span class="hl opt">[</span><span class="hl num">50</span><span class="hl opt">];</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>begin <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>f <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= TREE NODE %s ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
		<span class="hl kwd">stid</span><span class="hl opt">(</span>t<span class="hl opt">,</span> idbuf<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>idbuf<span class="hl opt">)));</span>
    <span class="hl opt">}</span>
    nfa <span class="hl opt">=</span> <span class="hl kwd">newnfa</span><span class="hl opt">(</span>v<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>cm<span class="hl opt">,</span> v<span class="hl opt">-&gt;</span>nfa<span class="hl opt">);</span>
    <span class="hl kwd">NOERRZ</span><span class="hl opt">();</span>
    <span class="hl kwd">dupnfa</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>begin<span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>end<span class="hl opt">,</span> nfa<span class="hl opt">-&gt;</span>init<span class="hl opt">,</span> nfa<span class="hl opt">-&gt;</span>final<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">ISERR</span><span class="hl opt">()) {</span>
	<span class="hl kwd">specialcolors</span><span class="hl opt">(</span>nfa<span class="hl opt">);</span>
	ret <span class="hl opt">=</span> <span class="hl kwd">optimize</span><span class="hl opt">(</span>nfa<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">ISERR</span><span class="hl opt">()) {</span>
	<span class="hl kwd">compact</span><span class="hl opt">(</span>nfa<span class="hl opt">, &amp;</span>t<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">freenfa</span><span class="hl opt">(</span>nfa<span class="hl opt">);</span>
    <span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - newlacon - allocate a lookahead-constraint subRE</span>
<span class="hl com"> ^ static int newlacon(struct vars *, struct state *, struct state *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>			<span class="hl com">/* lacon number */</span>
<span class="hl kwd">newlacon</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> vars <span class="hl opt">*</span>v<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>begin<span class="hl opt">,</span>
    <span class="hl kwb">struct</span> state <span class="hl opt">*</span>end<span class="hl opt">,</span>
    <span class="hl kwb">int</span> pos<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>sub<span class="hl opt">;</span>
    <span class="hl kwb">int</span> n<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">= (</span><span class="hl kwb">struct</span> subre <span class="hl opt">*)</span> <span class="hl kwd">MALLOC</span><span class="hl opt">(</span><span class="hl num">2</span> <span class="hl opt">*</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre<span class="hl opt">));</span>
	n <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>		<span class="hl com">/* skip 0th */</span>
	v<span class="hl opt">-&gt;</span>nlacons <span class="hl opt">=</span> <span class="hl num">2</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">= (</span><span class="hl kwb">struct</span> subre <span class="hl opt">*)</span> <span class="hl kwd">REALLOC</span><span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>lacons<span class="hl opt">,</span>
		<span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)*</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> subre<span class="hl opt">));</span>
	n <span class="hl opt">=</span> v<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">++;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>v<span class="hl opt">-&gt;</span>lacons <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">ERR</span><span class="hl opt">(</span>REG_ESPACE<span class="hl opt">);</span>
	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    sub <span class="hl opt">= &amp;</span>v<span class="hl opt">-&gt;</span>lacons<span class="hl opt">[</span>n<span class="hl opt">];</span>
    sub<span class="hl opt">-&gt;</span>begin <span class="hl opt">=</span> begin<span class="hl opt">;</span>
    sub<span class="hl opt">-&gt;</span>end <span class="hl opt">=</span> end<span class="hl opt">;</span>
    sub<span class="hl opt">-&gt;</span>subno <span class="hl opt">=</span> pos<span class="hl opt">;</span>
    <span class="hl kwd">ZAPCNFA</span><span class="hl opt">(</span>sub<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">);</span>
    <span class="hl kwa">return</span> n<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - freelacons - free lookahead-constraint subRE vector</span>
<span class="hl com"> ^ static void freelacons(struct subre *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">freelacons</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>subs<span class="hl opt">,</span>
    <span class="hl kwb">int</span> n<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>sub<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>n <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>sub<span class="hl opt">=</span>subs<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">,</span> i<span class="hl opt">=</span>n<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span> i<span class="hl opt">&gt;</span><span class="hl num">0</span><span class="hl opt">;</span> sub<span class="hl opt">++,</span> i<span class="hl opt">--) {</span>	<span class="hl com">/* no 0th */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">NULLCNFA</span><span class="hl opt">(</span>sub<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">)) {</span>
	    <span class="hl kwd">freecnfa</span><span class="hl opt">(&amp;</span>sub<span class="hl opt">-&gt;</span>cnfa<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">FREE</span><span class="hl opt">(</span>subs<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - rfree - free a whole RE (insides of regfree)</span>
<span class="hl com"> ^ static void rfree(regex_t *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">rfree</span><span class="hl opt">(</span>
    regex_t <span class="hl opt">*</span>re<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> guts <span class="hl opt">*</span>g<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>re <span class="hl opt">==</span> NULL <span class="hl opt">||</span> re<span class="hl opt">-&gt;</span>re_magic <span class="hl opt">!=</span> REMAGIC<span class="hl opt">) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    re<span class="hl opt">-&gt;</span>re_magic <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>	<span class="hl com">/* invalidate RE */</span>
    g <span class="hl opt">= (</span><span class="hl kwb">struct</span> guts <span class="hl opt">*)</span> re<span class="hl opt">-&gt;</span>re_guts<span class="hl opt">;</span>
    re<span class="hl opt">-&gt;</span>re_guts <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    re<span class="hl opt">-&gt;</span>re_fns <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    g<span class="hl opt">-&gt;</span>magic <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwd">freecm</span><span class="hl opt">(&amp;</span>g<span class="hl opt">-&gt;</span>cmap<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>tree <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freesubre</span><span class="hl opt">(</span>NULL<span class="hl opt">,</span> g<span class="hl opt">-&gt;</span>tree<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>lacons <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">freelacons</span><span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>lacons<span class="hl opt">,</span> g<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">NULLCNFA</span><span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">)) {</span>
	<span class="hl kwd">freecnfa</span><span class="hl opt">(&amp;</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">FREE</span><span class="hl opt">(</span>g<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - dump - dump an RE in human-readable form</span>
<span class="hl com"> ^ static void dump(regex_t *, FILE *);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">dump</span><span class="hl opt">(</span>
    regex_t <span class="hl opt">*</span>re<span class="hl opt">,</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>f<span class="hl opt">)</span>
<span class="hl opt">{</span>
<span class="hl ppc">#ifdef REG_DEBUG</span>
    <span class="hl kwb">struct</span> guts <span class="hl opt">*</span>g<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>re<span class="hl opt">-&gt;</span>re_magic <span class="hl opt">!=</span> REMAGIC<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;bad magic number (0x%x not 0x%x)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
		re<span class="hl opt">-&gt;</span>re_magic<span class="hl opt">,</span> REMAGIC<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>re<span class="hl opt">-&gt;</span>re_guts <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;NULL guts!!!</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    g <span class="hl opt">= (</span><span class="hl kwb">struct</span> guts <span class="hl opt">*)</span> re<span class="hl opt">-&gt;</span>re_guts<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>magic <span class="hl opt">!=</span> GUTSMAGIC<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;bad guts magic number (0x%x not 0x%x)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
		g<span class="hl opt">-&gt;</span>magic<span class="hl opt">,</span> GUTSMAGIC<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n\n\n</span><span class="hl str">========= DUMP ==========</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;nsub %d, info 0%lo, csize %d, ntree %d</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
	    re<span class="hl opt">-&gt;</span>re_nsub<span class="hl opt">,</span> re<span class="hl opt">-&gt;</span>re_info<span class="hl opt">,</span> re<span class="hl opt">-&gt;</span>re_csize<span class="hl opt">,</span> g<span class="hl opt">-&gt;</span>ntree<span class="hl opt">);</span>

    <span class="hl kwd">dumpcolors</span><span class="hl opt">(&amp;</span>g<span class="hl opt">-&gt;</span>cmap<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">NULLCNFA</span><span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">)) {</span>
	<span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">search:</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">dumpcnfa</span><span class="hl opt">(&amp;</span>g<span class="hl opt">-&gt;</span>search<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> g<span class="hl opt">-&gt;</span>nlacons<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">la%d (%s):</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">,</span>
		<span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>lacons<span class="hl opt">[</span>i<span class="hl opt">].</span>subno<span class="hl opt">)</span> ? <span class="hl str">&quot;positive&quot;</span> <span class="hl opt">:</span> <span class="hl str">&quot;negative&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">dumpcnfa</span><span class="hl opt">(&amp;</span>g<span class="hl opt">-&gt;</span>lacons<span class="hl opt">[</span>i<span class="hl opt">].</span>cnfa<span class="hl opt">,</span> f<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">dumpst</span><span class="hl opt">(</span>g<span class="hl opt">-&gt;</span>tree<span class="hl opt">,</span> f<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - dumpst - dump a subRE tree</span>
<span class="hl com"> ^ static void dumpst(struct subre *, FILE *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">dumpst</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">,</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>f<span class="hl opt">,</span>
    <span class="hl kwb">int</span> nfapresent<span class="hl opt">)</span>		<span class="hl com">/* is the original NFA still around? */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;null tree</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl kwd">stdump</span><span class="hl opt">(</span>t<span class="hl opt">,</span> f<span class="hl opt">,</span> nfapresent<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">fflush</span><span class="hl opt">(</span>f<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> - stdump - recursive guts of dumpst</span>
<span class="hl com"> ^ static void stdump(struct subre *, FILE *, int);</span>
<span class="hl com"> */</span>
<span class="hl kwb">static void</span>
<span class="hl kwd">stdump</span><span class="hl opt">(</span>
    <span class="hl kwb">struct</span> subre <span class="hl opt">*</span>t<span class="hl opt">,</span>
    <span class="hl kwb">FILE</span> <span class="hl opt">*</span>f<span class="hl opt">,</span>
    <span class="hl kwb">int</span> nfapresent<span class="hl opt">)</span>		<span class="hl com">/* is the original NFA still around? */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span> idbuf<span class="hl opt">[</span><span class="hl num">50</span><span class="hl opt">];</span>

    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;%s. `%c'&quot;</span><span class="hl opt">,</span> <span class="hl kwd">stid</span><span class="hl opt">(</span>t<span class="hl opt">,</span> idbuf<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>idbuf<span class="hl opt">)),</span> t<span class="hl opt">-&gt;</span>op<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>LONGER<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; longest&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>SHORTER<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; shortest&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>MIXED<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; hasmixed&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>CAP<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; hascapture&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>BACKR<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; hasbackref&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!(</span>t<span class="hl opt">-&gt;</span>flags<span class="hl opt">&amp;</span>INUSE<span class="hl opt">)) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; UNUSED&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>subno <span class="hl opt">!=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; (#%d)&quot;</span><span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>subno<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>min <span class="hl opt">!=</span> <span class="hl num">1</span> <span class="hl opt">||</span> t<span class="hl opt">-&gt;</span>max <span class="hl opt">!=</span> <span class="hl num">1</span><span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; {%d,&quot;</span><span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>min<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>max <span class="hl opt">!=</span> INFINITY<span class="hl opt">) {</span>
	    <span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;%d&quot;</span><span class="hl opt">,</span> t<span class="hl opt">-&gt;</span>max<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot;}&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>nfapresent<span class="hl opt">) {</span>
	<span class="hl kwd">fprintf</span><span class="hl opt">(</span>f<span class="hl opt">,</span> <span class="hl str">&quot; %ld-%ld&quot;</span><span class="hl opt">, (</span><span class="hl kwb">long</span><span class="hl opt">)</span>t<span class="hl opt">-&gt;</span>begin<span class="hl opt">-&gt;</span>no<span class="hl opt">, (</span><span class="hl kwb">long</span><span class="hl opt">)</span>t<span class="hl opt">-&gt;</span>end<span class="hl opt">-&gt;</span>no<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>t<span class="hl opt">-&gt;</span>left <span class="hl opt">!=</span> NULL<span class="hl opt">) {