path: root/ds9/parsers/threedsendparser.tcl

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

    namespace export yylex
}

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

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

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

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

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

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

array set threedsend::table {
  0:257 shift
  0:258 shift
  0:259 shift
  5:0,target 2
  15:0,target 10
  9:0 reduce
  0:266,target 9
  0:261 shift
  6:260,target 16
  11:0 accept
  0:262 shift
  6:269,target 17
  0:263 shift
  0:264 shift
  4:260 shift
  0:265 shift
  15:0 reduce
  0:266 shift
  6:260 shift
  0:267 shift
  0:268 goto
  0:265,target 8
  4:271,target 15
  6:0,target 11
  16:0,target 12
  2:0 reduce
  4:271 goto
  6:0 reduce
  0:264,target 7
  4:260,target 14
  6:269 goto
  7:0,target 7
  17:0,target 8
  12:0 reduce
  10:0,target 3
  0:263,target 6
  16:0 reduce
  8:0,target 5
  3:0 reduce
  1:0,target 1
  11:0,target 0
  0:262,target 5
  7:0 reduce
  3:260 shift
  13:0 reduce
  9:0,target 4
  0:261,target 4
  2:0,target 6
  12:0,target 14
  17:0 reduce
  0:259,target 3
  3:270 goto
  4:0 reduce
  3:0,target 13
  13:0,target 9
  8:0 reduce
  10:0 reduce
  0:258,target 2
  0:268,target 11
  14:0 reduce
  3:260,target 12
  3:270,target 13
  4:0,target 15
  14:0,target 16
  0:257,target 1
  1:0 reduce
  0:267,target 10
  5:0 reduce
}

array set threedsend::rules {
  9,l 268
  11,l 269
  15,l 271
  2,l 268
  6,l 268
  12,l 269
  16,l 271
  3,l 268
  7,l 268
  13,l 270
  0,l 272
  4,l 268
  8,l 268
  10,l 268
  14,l 270
  1,l 268
  5,l 268
}

array set threedsend::rules {
  5,dc 1
  0,dc 1
  12,dc 1
  8,dc 2
  3,dc 1
  15,dc 0
  10,dc 2
  6,dc 1
  1,dc 1
  13,dc 0
  9,dc 2
  4,dc 1
  16,dc 1
  11,dc 0
  7,dc 1
  2,dc 1
  14,dc 1
}

array set threedsend::rules {
  13,line 39
  7,line 29
  10,line 32
  4,line 26
  1,line 23
  15,line 43
  9,line 31
  12,line 36
  6,line 28
  3,line 25
  14,line 40
  8,line 30
  11,line 35
  5,line 27
  2,line 24
  16,line 44
}

array set threedsend::lr1_table {
  13,trans {}
  17 {{8 0 2}}
  0 {{0 0 0} {1 0 0} {2 0 0} {3 0 0} {4 0 0} {5 0 0} {6 0 0} {7 0 0} {8 0 0} {9 0 0} {10 0 0}}
  14,trans {}
  1 {{1 0 1}}
  15,trans {}
  2 {{6 0 1}}
  16,trans {}
  3 {{9 0 1} {13 0 0} {14 0 0}}
  17,trans {}
  0,trans {{257 1} {258 2} {259 3} {261 4} {262 5} {263 6} {264 7} {265 8} {266 9} {267 10} {268 11}}
  4 {{10 0 1} {15 0 0} {16 0 0}}
  1,trans {}
  5 {{2 0 1}}
  2,trans {}
  6 {{8 0 1} {11 0 0} {12 0 0}}
  3,trans {{260 12} {270 13}}
  7 {{7 0 1}}
  4,trans {{260 14} {271 15}}
  8 {{5 0 1}}
  5,trans {}
  9 {{4 0 1}}
  10 {{3 0 1}}
  6,trans {{260 16} {269 17}}
  11 {{0 0 1}}
  7,trans {}
  12 {{14 0 1}}
  8,trans {}
  13 {{9 0 2}}
  10,trans {}
  9,trans {}
  14 {{16 0 1}}
  11,trans {}
  15 {{10 0 2}}
  12,trans {}
  16 {{12 0 1}}
}

array set threedsend::token_id_table {
  264,line 15
  270,t 1
  269,t 1
  265,title METHOD
  261,line 12
  257,t 0
  270,title {}
  269,title {}
  257,line 8
  262,t 0
  270,line 38
  269,line 34
  259,title BORDER
  260,title COLOR
  266,t 0
  271,t 1
  264,title LOCK
  266,line 17
  error error
  268,title {}
  error,line 21
  258,t 0
  263,line 14
  error,title {}
  263,t 0
  259,line 10
  260,line 11
  258,title BG
  272,line 45
  267,t 0
  263,title HIGHLITE
  272,t 1
  268,line 22
  267,title VIEW
  257 AZ_
  258 BG_
  259,t 0
  259 BORDER_
  260 COLOR_
  260,t 0
  272,title {}
  261 COMPASS_
  265,line 16
  262 EL_
  263 HIGHLITE_
  257,title AZ
  264 LOCK_
  264,t 0
  265 METHOD_
  262,line 13
  266 SCALE_
  267 VIEW_
  268,t 1
  268 threedsend
  262,title EL
  0 {$}
  0,t 0
  270 border
  269 highlite
  271 compass
  error,t 0
  272 start'
  258,line 9
  266,title SCALE
  271,line 42
  271,title {}
  261,t 0
  267,line 18
  265,t 0
  261,title COMPASS
}

proc threedsend::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 { ProcessSendCmdGet threed az }
                    2 { ProcessSendCmdGet threed el }
                    3 { ProcessSendCmdGet2 threed az el }
                    4 { ProcessSendCmdGet threed scale }
                    5 { ProcessSendCmdGet threed method }
                    6 { ProcessSendCmdGet threed background }
                    7 { ProcessSendCmdYesNo threed lock }
                    11 { ProcessSendCmdYesNo threed highlite }
                    12 { ProcessSendCmdGet threed highlite,color }
                    13 { ProcessSendCmdYesNo threed border }
                    14 { ProcessSendCmdGet threed border,color }
                    15 { ProcessSendCmdYesNo threed compass }
                    16 { ProcessSendCmdGet threed compass,color }
                }
                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 threedsend::yyerror {msg} {
     variable yycnt
     variable yy_current_buffer
     variable index_

     ParserError $msg $yycnt $yy_current_buffer $index_
}