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 block {
    variable yylval {}
    variable table
    variable rules
    variable token {}
    variable yycnt 0
    variable yyerr 0
    variable save_state 0

    namespace export yylex
}

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

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

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

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

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

proc block::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 block::unsetupvalues {numsyms} {
    for {set i 1} {$i <= $numsyms} {incr i} {
        upvar 1 $i y
        unset y
    }
}

array set block::table {
  12:277,target 24
  23:0,target 21
  5:0,target 1
  15:0,target 3
  13:265 reduce
  0:266,target 3
  2:264,target 9
  11:0 accept
  0:276,target 11
  15:265 reduce
  0:263 shift
  0:264 shift
  23:265,target 21
  17:265 reduce
  5:265,target 1
  2:263 reduce
  15:0 reduce
  0:266 shift
  2:264 reduce
  20:265 reduce
  19:265 reduce
  2:265 reduce
  17:265,target 4
  0:268 shift
  2:263,target 9
  22:265 reduce
  6:0,target 15
  0:269 shift
  0:270 shift
  0:275,target 10
  4:265 reduce
  20:0 reduce
  19:0 reduce
  16:0,target 6
  0:271 shift
  2:0 reduce
  24:265 shift
  12:265,target 11
  6:265 reduce
  0:272 shift
  0:273 shift
  8:265 reduce
  5:274,target 19
  9:279,target 22
  6:0 reduce
  0:275 goto
  0:276 goto
  0:264,target 2
  8:265,target 18
  0:278 goto
  25:0,target 23
  7:0,target 13
  21:265,target 22
  17:0,target 4
  12:0 reduce
  3:265,target 14
  21:275,target 25
  10:0,target 20
  15:265,target 3
  0:263,target 1
  16:0 reduce
  0:273,target 9
  10:265,target 20
  21:264,target 2
  10:275,target 23
  5:262,target 18
  26:0,target 12
  21:0 reduce
  9:267,target 20
  8:0,target 18
  3:0 reduce
  18:0,target 7
  10:263 shift
  1:0,target 8
  11:0,target 0
  10:264 shift
  24:265,target 26
  10:265 reduce
  6:265,target 15
  0:272,target 8
  25:0 reduce
  7:0 reduce
  12:265 reduce
  10:264,target 2
  21:263,target 1
  18:265,target 7
  5:261,target 17
  1:265,target 8
  14:265 reduce
  5:257 shift
  16:265 reduce
  13:265,target 2
  13:0 reduce
  5:258 shift
  1:263 reduce
  20:0,target 24
  19:0,target 16
  5:260 shift
  5:259 shift
  0:271,target 7
  1:264 reduce
  2:0,target 9
  21:263 shift
  18:265 reduce
  12:0,target 10
  5:261 shift
  1:265 reduce
  21:264 shift
  10:263,target 1
  10:275 goto
  5:262 shift
  21:265 reduce
  17:0 reduce
  5:260,target 16
  5:259,target 15
  1:264,target 8
  3:265 reduce
  23:265 reduce
  9:275,target 21
  5:265 reduce
  12:277 goto
  25:265 reduce
  22:265,target 19
  22:0 reduce
  9:263 shift
  7:265 reduce
  4:265,target 17
  0:270,target 6
  0:269,target 5
  4:0 reduce
  9:264 shift
  21:0,target 22
  3:0,target 14
  16:265,target 6
  13:0,target 2
  5:258,target 14
  1:263,target 8
  26:0 reduce
  9:264,target 2
  9:267 shift
  8:0 reduce
  21:275 goto
  10:0 reduce
  5:274 goto
  0:268,target 4
  0:278,target 12
  14:0 reduce
  5:257,target 13
  25:265,target 23
  22:0,target 19
  9:263,target 1
  9:275 goto
  7:265,target 13
  4:0,target 17
  14:0,target 5
  18:0 reduce
  1:0 reduce
  20:265,target 24
  19:265,target 16
  2:265,target 9
  9:279 goto
  23:0 reduce
  14:265,target 5
  5:0 reduce
}

array set block::rules {
  9,l 275
  11,l 277
  15,l 278
  20,l 278
  19,l 278
  2,l 274
  24,l 279
  6,l 274
  12,l 276
  16,l 278
  21,l 278
  3,l 274
  7,l 274
  13,l 278
  0,l 280
  17,l 278
  22,l 279
  4,l 274
  8,l 275
  10,l 276
  14,l 278
  18,l 278
  1,l 274
  23,l 279
  5,l 274
}

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

array set block::rules {
  13,line 60
  7,line 50
  10,line 56
  22,line 71
  4,line 47
  18,line 65
  1,line 44
  15,line 62
  9,line 53
  12,line 57
  24,line 73
  6,line 49
  21,line 68
  3,line 46
  17,line 64
  14,line 61
  8,line 52
  11,line 56
  23,line 72
  5,line 48
  20,line 67
  19,line 66
  2,line 45
  16,line 63
  11,e 1
}

array set block::lr1_table {
  14,trans {}
  1,trans {}
  18,trans {}
  23,trans {}
  5,trans {{257 13} {258 14} {259 15} {260 16} {261 17} {262 18} {274 19}}
  27,trans {}
  9,trans {{263 1} {264 2} {267 20} {275 21} {279 22}}
  13,trans {}
  0,trans {{263 1} {264 2} {266 3} {268 4} {269 5} {270 6} {271 7} {272 8} {273 9} {275 10} {276 11} {278 12}}
  17,trans {}
  22,trans {}
  4,trans {}
  26,trans {{265 28}}
  8,trans {}
  12,trans {{277 26}}
  16,trans {}
  21,trans {{263 23} {264 24} {275 27}}
  3,trans {}
  10 {{20 {0 265} 1} {21 {0 265} 1} {8 {0 265} 0} {9 {0 265} 0}}
  11 {{0 0 1}}
  25,trans {}
  12 {{10 0 1} {12 0 1} {11 265 0}}
  7,trans {}
  13 {{2 {0 265} 1}}
  14 {{5 {0 265} 1}}
  15 {{3 {0 265} 1}}
  11,trans {}
  16 {{6 {0 265} 1}}
  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} {8 {0 263 264 265} 0} {9 {0 263 264 265} 0}}
  17 {{4 {0 265} 1}}
  1 {{8 {0 263 264 265} 1}}
  18 {{7 {0 265} 1}}
  2 {{9 {0 263 264 265} 1}}
  19 {{16 {0 265} 2}}
  20 {{24 {0 265} 1}}
  15,trans {}
  3 {{14 {0 265} 1}}
  21 {{22 {0 265} 1} {23 {0 265} 1} {8 {0 265} 0} {9 {0 265} 0}}
  4 {{17 {0 265} 1}}
  22 {{19 {0 265} 2}}
  5 {{16 {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}}
  23 {{8 {0 265} 1}}
  6 {{15 {0 265} 1}}
  2,trans {}
  24 {{9 {0 265} 1}}
  19,trans {}
  20,trans {}
  7 {{13 {0 265} 1}}
  25 {{21 {0 265} 2}}
  8 {{18 {0 265} 1}}
  26 {{12 0 2}}
  27 {{23 {0 265} 2}}
  9 {{19 {0 265} 1} {22 {0 265} 0} {23 {0 265} 0} {24 {0 265} 0} {8 {0 263 264 265} 0} {9 {0 263 264 265} 0}}
  28 {{12 0 3}}
  24,trans {}
  6,trans {}
  10,trans {{263 23} {264 24} {275 25}}
  28,trans {}
}

array set block::token_id_table {
  280,title {}
  279,title {}
  264,line 15
  270,t 0
  269,t 0
  276,line 55
  265,title string
  274,t 1
  261,line 11
  257,t 0
  270,title MATCH
  269,title LOCK
  273,line 28
  278,t 1
  257,line 7
  262,t 0
  274,title {}
  270,line 25
  269,line 24
  259,title ON
  260,title OFF
  266,t 0
  278,title {}
  error error
  271,t 0
  264,title float
  266,line 21
  278,line 59
  275,t 1
  error,line 42
  268,title IN
  258,t 0
  263,line 14
  error,title {}
  280,t 1
  279,t 1
  275,line 51
  273,title TO
  263,t 0
  259,line 9
  260,line 10
  258,title NO
  277,title {}
  272,line 27
  267,t 0
  263,title integer
  272,t 0
  268,line 23
  267,title FIT
  257 YES_
  276,t 1
  258 NO_
  259,t 0
  259 ON_
  260 OFF_
  260,t 0
  272,title OUT
  261 TRUE_
  265,line 17
  262 FALSE_
  263 INT_
  277,line 56
  257,title YES
  264 REAL_
  264,t 0
  276,title {}
  265 STRING_
  262,line 12
  266 CLOSE_
  267 FIT_
  0,t 0
  0 {$}
  262,title FALSE
  268 IN_
  268,t 0
  274,line 43
  270 MATCH_
  269 LOCK_
  error,t 0
  271 OPEN_
  272 OUT_
  258,line 8
  273,t 0
  273 TO_
  266,title CLOSE
  274 yesno
  275 numeric
  271,line 26
  276 command
  277,t 1
  277 @PSEUDO1
  271,title OPEN
  278 block
  261,t 0
  280 start'
  279 blockTo
  267,line 22
  275,title {}
  265,t 0
  280,line 74
  279,line 70
  261,title TRUE
}

proc block::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 { BlockDialog }
                    14 { BlockDestroyDialog }
                    15 { MatchBlockCurrent }
                    16 { ProcessCmdSet block lock $2 LockBlockCurrent }
                    17 { Block .5 .5 }
                    18 { Block 2 2 }
                    20 { Block $1 $1 }
                    21 { Block $1 $2 }
                    22 { ProcessCmdSet block factor "$1 $1" ChangeBlock }
                    23 { ProcessCmdSet block factor "$1 $2" ChangeBlock }
                    24 { BlockToFit }
                }
                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 block::yyerror {msg} {
     variable yycnt
     variable yy_current_buffer
     variable index_

     ParserError $msg $yycnt $yy_current_buffer $index_
}
