package provide DS9 1.0

######
# Begin autogenerated taccle (version 1.3) routines.
# Although taccle itself is protected by the GNU Public License (GPL)
# all user-supplied functions are protected by their respective
# author's license.  See http://mini.net/tcl/taccle for other details.
######

namespace eval smooth {
    variable yylval {}
    variable table
    variable rules
    variable token {}
    variable yycnt 0
    variable yyerr 0
    variable save_state 0

    namespace export yylex
}

proc smooth::YYABORT {} {
    return -code return 1
}

proc smooth::YYACCEPT {} {
    return -code return 0
}

proc smooth::YYERROR {} {
    variable yyerr
    set yyerr 1
}

proc smooth::yyclearin {} {
    variable token
    variable yycnt
    set token {}
    incr yycnt -1
}

proc smooth::yyerror {s} {
    puts stderr $s
}

proc smooth::setupvalues {stack pointer numsyms} {
    upvar 1 1 y
    set y {}
    for {set i 1} {$i <= $numsyms} {incr i} {
        upvar 1 $i y
        set y [lindex $stack $pointer]
        incr pointer
    }
}

proc smooth::unsetupvalues {numsyms} {
    for {set i 1} {$i <= $numsyms} {incr i} {
        upvar 1 $i y
        unset y
    }
}

array set smooth::table {
  7:264,target 21
  10:280,target 28
  9:285 goto
  27:0 reduce
  10:258,target 2
  17:265 reduce
  23:265,target 24
  9:271,target 25
  0:275,target 13
  6:0,target 7
  2:0 reduce
  6:265 reduce
  12:265,target 14
  16:281,target 32
  26:265 reduce
  24:0 reduce
  25:0,target 27
  3:265,target 3
  17:0,target 13
  10:0,target 1
  7:281,target 22
  0:273,target 11
  21:0 reduce
  24:265,target 25
  14:263 shift
  3:265 reduce
  17:0 reduce
  23:265 reduce
  9:285,target 27
  4:265,target 6
  3:0,target 3
  13:263,target 29
  32:265 reduce
  0:268,target 8
  29:0,target 19
  30:0,target 20
  22:0,target 23
  25:265,target 27
  0:257 shift
  0:258 shift
  11:265 reduce
  0:260 shift
  0:259 shift
  0:261 shift
  0:266,target 7
  0:262 shift
  11:0 reduce
  0:265 reduce
  5:265,target 4
  32:0 reduce
  0:266 shift
  19:265 reduce
  20:265 reduce
  0:268 shift
  0:270 shift
  19:283,target 33
  0:272 shift
  14:263,target 30
  0:273 shift
  0:274 shift
  8:265 reduce
  0:275 shift
  6:0 reduce
  0:276 shift
  28:265 reduce
  0:277 shift
  26:265,target 26
  0:278 shift
  0:280 goto
  28:0 reduce
  0:0,target 1
  0:282 goto
  0:284 goto
  19:283 goto
  34:0,target 12
  3:0 reduce
  26:0,target 26
  18:0,target 0
  0:262,target 6
  11:0,target 16
  6:265,target 7
  25:0 reduce
  16:263 shift
  16:264 shift
  15:263,target 20
  0:0 reduce
  27:265,target 18
  5:265 reduce
  0:260,target 4
  0:259,target 3
  22:0 reduce
  25:265 reduce
  10:262,target 6
  16:281 goto
  0:278,target 16
  4:0,target 6
  0:257,target 1
  18:0 accept
  10:259,target 3
  10:260,target 4
  16:263,target 20
  13:263 shift
  31:0,target 21
  23:0,target 24
  0:276,target 14
  28:265,target 17
  7:263,target 20
  2:265 reduce
  17:265,target 13
  22:265 reduce
  10:257,target 1
  9:269,target 24
  0:274,target 12
  8:265,target 15
  31:265 reduce
  12:0 reduce
  10:257 shift
  10:258 shift
  10:259 shift
  10:260 shift
  10:261 shift
  8:0,target 15
  9:267,target 23
  10:262 shift
  29:265,target 19
  30:265,target 20
  1:0,target 2
  0:272,target 10
  10:265 reduce
  29:0 reduce
  30:0 reduce
  27:0,target 18
  19:0,target 10
  20:0,target 8
  12:0,target 14
  7:263 shift
  7:264 shift
  10:280 goto
  0:270,target 9
  4:0 reduce
  27:265 reduce
  26:0 reduce
  31:265,target 21
  1:0 reduce
  7:281 goto
  19:265,target 11
  20:265,target 8
  23:0 reduce
  5:0,target 4
  15:263 shift
  15:264 shift
  0:265,target 1
  32:0,target 22
  4:265 reduce
  24:0,target 25
  19:0 reduce
  20:0 reduce
  24:265 reduce
  32:265,target 22
  9:279,target 26
  0:284,target 19
  15:281 goto
  33:265 shift
  21:265,target 9
  10:265,target 1
  15:264,target 21
  0:282,target 18
  12:265 reduce
  1:265,target 2
  0:261,target 5
  2:0,target 5
  33:265,target 34
  1:265 reduce
  34:0 reduce
  21:265 reduce
  22:265,target 23
  0:280,target 17
  28:0,target 17
  21:0,target 9
  8:0 reduce
  9:267 shift
  29:265 reduce
  30:265 reduce
  10:0 reduce
  0:258,target 2
  9:269 shift
  11:265,target 16
  9:271 shift
  15:281,target 31
  31:0 reduce
  10:261,target 5
  16:264,target 21
  2:265,target 5
  0:277,target 15
  9:279 shift
  5:0 reduce
}

array set smooth::rules {
  27,l 285
  9,l 281
  11,l 283
  15,l 284
  20,l 284
  19,l 284
  2,l 280
  24,l 285
  6,l 280
  12,l 282
  16,l 284
  21,l 284
  3,l 280
  25,l 285
  7,l 280
  13,l 284
  0,l 286
  17,l 284
  22,l 284
  4,l 280
  26,l 285
  8,l 281
  10,l 282
  14,l 284
  18,l 284
  1,l 280
  23,l 284
  5,l 280
}

array set smooth::rules {
  23,dc 2
  5,dc 1
  0,dc 1
  17,dc 2
  12,dc 3
  26,dc 1
  8,dc 1
  21,dc 2
  3,dc 1
  15,dc 1
  10,dc 1
  24,dc 1
  6,dc 1
  18,dc 2
  1,dc 0
  13,dc 1
  27,dc 1
  9,dc 1
  22,dc 2
  4,dc 1
  16,dc 1
  11,dc 0
  25,dc 1
  7,dc 1
  20,dc 2
  19,dc 2
  2,dc 1
  14,dc 1
}

array set smooth::rules {
  13,line 67
  25,line 81
  7,line 56
  10,line 62
  22,line 76
  4,line 53
  18,line 72
  1,line 50
  15,line 69
  27,line 83
  9,line 59
  12,line 63
  24,line 80
  6,line 55
  21,line 75
  3,line 52
  17,line 71
  14,line 68
  26,line 82
  8,line 58
  11,line 62
  23,line 77
  5,line 54
  20,line 74
  19,line 73
  2,line 51
  16,line 70
  11,e 1
}

array set smooth::lr1_table {
  14,trans {{263 30}}
  33,trans {{265 34}}
  18,trans {}
  1,trans {}
  23,trans {}
  5,trans {}
  27,trans {}
  9,trans {{267 23} {269 24} {271 25} {279 26} {285 27}}
  13,trans {{263 29}}
  32,trans {}
  17,trans {}
  0,trans {{257 1} {258 2} {259 3} {260 4} {261 5} {262 6} {266 7} {268 8} {270 9} {272 10} {273 11} {274 12} {275 13} {276 14} {277 15} {278 16} {280 17} {282 18} {284 19}}
  22,trans {}
  4,trans {}
  26,trans {}
  8,trans {}
  12,trans {}
  31,trans {}
  16,trans {{263 20} {264 21} {281 32}}
  21,trans {}
  3,trans {}
  10 {{17 {0 265} 1} {1 {0 265} 0} {2 {0 265} 0} {3 {0 265} 0} {4 {0 265} 0} {5 {0 265} 0} {6 {0 265} 0} {7 {0 265} 0}}
  11 {{16 {0 265} 1}}
  25,trans {}
  12 {{14 {0 265} 1}}
  7,trans {{263 20} {264 21} {281 22}}
  13 {{19 {0 265} 1}}
  14 {{20 {0 265} 1}}
  15 {{21 {0 265} 1} {8 {0 265} 0} {9 {0 265} 0}}
  11,trans {}
  30,trans {}
  29,trans {}
  16 {{22 {0 265} 1} {8 {0 265} 0} {9 {0 265} 0}}
  0 {{0 0 0} {10 0 0} {12 0 0} {13 {0 265} 0} {14 {0 265} 0} {15 {0 265} 0} {16 {0 265} 0} {17 {0 265} 0} {18 {0 265} 0} {19 {0 265} 0} {20 {0 265} 0} {21 {0 265} 0} {22 {0 265} 0} {23 {0 265} 0} {1 {0 265} 0} {2 {0 265} 0} {3 {0 265} 0} {4 {0 265} 0} {5 {0 265} 0} {6 {0 265} 0} {7 {0 265} 0}}
  17 {{13 {0 265} 1}}
  1 {{2 {0 265} 1}}
  18 {{0 0 1}}
  2 {{5 {0 265} 1}}
  19 {{10 0 1} {12 0 1} {11 265 0}}
  20 {{8 {0 265} 1}}
  15,trans {{263 20} {264 21} {281 31}}
  34,trans {}
  3 {{3 {0 265} 1}}
  21 {{9 {0 265} 1}}
  4 {{6 {0 265} 1}}
  22 {{23 {0 265} 2}}
  5 {{4 {0 265} 1}}
  23 {{24 {0 265} 1}}
  20,trans {}
  19,trans {{283 33}}
  6 {{7 {0 265} 1}}
  2,trans {}
  24 {{25 {0 265} 1}}
  7 {{23 {0 265} 1} {8 {0 265} 0} {9 {0 265} 0}}
  25 {{27 {0 265} 1}}
  8 {{15 {0 265} 1}}
  26 {{26 {0 265} 1}}
  9 {{18 {0 265} 1} {24 {0 265} 0} {25 {0 265} 0} {26 {0 265} 0} {27 {0 265} 0}}
  27 {{18 {0 265} 2}}
  24,trans {}
  6,trans {}
  28 {{17 {0 265} 2}}
  29 {{19 {0 265} 2}}
  30 {{20 {0 265} 2}}
  31 {{21 {0 265} 2}}
  32 {{22 {0 265} 2}}
  10,trans {{257 1} {258 2} {259 3} {260 4} {261 5} {262 6} {280 28}}
  28,trans {}
  33 {{12 0 2}}
  34 {{12 0 3}}
}

array set smooth::token_id_table {
  286,t 1
  286 start'
  280,title {}
  279,title TOPHAT
  264,line 15
  270,t 0
  269,t 0
  276,line 31
  265,title string
  284,title {}
  274,t 0
  261,line 11
  257,t 0
  270,title FUNCTION
  269,title ELLIPTIC
  273,line 28
  278,t 0
  257,line 7
  262,t 0
  285,line 79
  274,title OPEN
  283,t 1
  270,line 25
  269,line 24
  259,title ON
  260,title OFF
  266,t 0
  278,title SIGMAMINOR
  282,line 61
  error error
  271,t 0
  264,title float
  266,line 21
  283,title {}
  278,line 33
  error,line 48
  275,t 0
  268,title CLOSE
  258,t 0
  263,line 14
  error,title {}
  280,t 1
  279,t 0
  275,line 30
  273,title MATCH
  263,t 0
  259,line 9
  260,line 10
  258,title NO
  284,t 1
  277,title SIGMA
  272,line 27
  267,t 0
  263,title integer
  284,line 66
  282,title {}
  272,t 0
  268,line 23
  267,title BOXCAR
  286,title {}
  257 YES_
  281,line 57
  276,t 0
  258 NO_
  259,t 0
  259 ON_
  260 OFF_
  260,t 0
  272,title LOCK
  261 TRUE_
  265,line 17
  262 FALSE_
  281,t 1
  263 INT_
  277,line 32
  257,title YES
  264 REAL_
  264,t 0
  276,title RADIUSMINOR
  265 STRING_
  262,line 12
  266 ANGLE_
  285,t 1
  267 BOXCAR_
  0,t 0
  0 {$}
  262,title FALSE
  268 CLOSE_
  268,t 0
  281,title {}
  274,line 29
  270 FUNCTION_
  269 ELLIPTIC_
  error,t 0
  271 GAUSSIAN_
  272 LOCK_
  258,line 8
  286,line 84
  273,t 0
  273 MATCH_
  266,title ANGLE
  285,title {}
  274 OPEN_
  275 RADIUS_
  271,line 26
  276 RADIUSMINOR_
  277,t 0
  277 SIGMA_
  271,title GAUSSIAN
  283,line 62
  278 SIGMAMINOR_
  261,t 0
  280 yesno
  279 TOPHAT_
  281 numeric
  267,line 22
  282,t 1
  282 command
  275,title RADIUS
  283 @PSEUDO1
  265,t 0
  284 smooth
  280,line 49
  279,line 34
  285 function
  261,title TRUE
}

proc smooth::yyparse {} {
    variable yylval
    variable table
    variable rules
    variable token
    variable yycnt
    variable lr1_table
    variable token_id_table
    variable yyerr
    variable save_state

    set yycnt 0
    set state_stack {0}
    set value_stack {{}}
    set token ""
    set accepted 0
    set yyerr 0
    set save_state 0

    while {$accepted == 0} {
        set state [lindex $state_stack end]
        if {$token == ""} {
            set yylval ""
            set token [yylex]
            set buflval $yylval
	    if {$token>0} {
	        incr yycnt
            }
        }
        if {![info exists table($state:$token)] || $yyerr} {
	    if {!$yyerr} {
	        set save_state $state
	    }
            # pop off states until error token accepted
            while {[llength $state_stack] > 0 && \
                       ![info exists table($state:error)]} {
                set state_stack [lrange $state_stack 0 end-1]
                set value_stack [lrange $value_stack 0 \
                                       [expr {[llength $state_stack] - 1}]]
                set state [lindex $state_stack end]
            }
            if {[llength $state_stack] == 0} {
 
	        set rr { }
                if {[info exists lr1_table($save_state,trans)] && [llength $lr1_table($save_state,trans)] >= 1} {
                    foreach trans $lr1_table($save_state,trans) {
                        foreach {tok_id nextstate} $trans {
			    set ss $token_id_table($tok_id,title)
			    if {$ss != {}} {
			        append rr "$ss, "
                            }
                        }
                    }
                }
		set rr [string trimleft $rr { }]
		set rr [string trimright $rr {, }]
                yyerror "parse error, expecting: $rr"


                return 1
            }
            lappend state_stack [set state $table($state:error,target)]
            lappend value_stack {}
            # consume tokens until it finds an acceptable one
            while {![info exists table($state:$token)]} {
                if {$token == 0} {
                    yyerror "end of file while recovering from error"
                    return 1
                }
                set yylval {}
                set token [yylex]
                set buflval $yylval
            }
            continue
        }
        switch -- $table($state:$token) {
            shift {
                lappend state_stack $table($state:$token,target)
                lappend value_stack $buflval
                set token ""
            }
            reduce {
                set rule $table($state:$token,target)
                set ll $rules($rule,l)
                if {[info exists rules($rule,e)]} {
                    set dc $rules($rule,e)
                } else {
                    set dc $rules($rule,dc)
                }
                set stackpointer [expr {[llength $state_stack]-$dc}]
                setupvalues $value_stack $stackpointer $dc
                set _ $1
                set yylval [lindex $value_stack end]
                switch -- $rule {
                    1 { set _ 1 }
                    2 { set _ 1 }
                    3 { set _ 1 }
                    4 { set _ 1 }
                    5 { set _ 0 }
                    6 { set _ 0 }
                    7 { set _ 0 }
                    8 { set _ $1 }
                    9 { set _ $1 }
                    11 { global ds9; if {!$ds9(init)} {YYERROR} else {yyclearin; YYACCEPT} }
                    13 { ProcessCmdSet smooth view $1 SmoothUpdate }
                    14 { SmoothDialog }
                    15 { SmoothDestroyDialog }
                    16 { MatchSmoothCurrent }
                    17 { ProcessCmdSet smooth lock $2 LockSmoothCurrent }
                    18 { ProcessCmdSet smooth function $2 SmoothUpdate }
                    19 { ProcessCmdSet smooth radius $2 SmoothUpdate }
                    20 { ProcessCmdSet smooth radius,minor $2 SmoothUpdate }
                    21 { ProcessCmdSet smooth sigma $2 SmoothUpdate }
                    22 { ProcessCmdSet smooth sigma,minor $2 SmoothUpdate }
                    23 { ProcessCmdSet smooth angle $2 SmoothUpdate }
                    24 { set _ boxcar }
                    25 { set _ elliptic }
                    26 { set _ tophat }
                    27 { set _ gaussian }
                }
                unsetupvalues $dc
                # pop off tokens from the stack if normal rule
                if {![info exists rules($rule,e)]} {
                    incr stackpointer -1
                    set state_stack [lrange $state_stack 0 $stackpointer]
                    set value_stack [lrange $value_stack 0 $stackpointer]
                }
                # now do the goto transition
                lappend state_stack $table([lindex $state_stack end]:$ll,target)
                lappend value_stack $_
            }
            accept {
                set accepted 1
            }
            goto -
            default {
                puts stderr "Internal parser error: illegal command $table($state:$token)"
                return 2
            }
        }
    }
    return 0
}

######
# end autogenerated taccle functions
######

proc smooth::yyerror {msg} {
     variable yycnt
     variable yy_current_buffer
     variable index_

     ParserError $msg $yycnt $yy_current_buffer $index_
}
