Merge branch 'devel'

79 files changed, 490 insertions, 6966 deletions

diff --git a/ds9/library/2mass.tcl b/ds9/library/2mass.tcl
index aaf315f..cb2fa23 100644
--- a/ds9/library/2mass.tcl
+++ b/ds9/library/2mass.tcl
@@ -133,15 +133,10 @@ proc Process2MASSCmd {varname iname} {
 
     2MASSDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	twomass::YY_FLUSH_BUFFER
-	twomass::yy_scan_string [lrange $var $i end]
-	twomass::yyparse
-	incr i [expr $twomass::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dtwomass
-    }
+    twomass::YY_FLUSH_BUFFER
+    twomass::yy_scan_string [lrange $var $i end]
+    twomass::yyparse
+    incr i [expr $twomass::yycnt-1]
 }
 
 proc ProcessSend2MASSCmd {proc id param} {
diff --git a/ds9/library/3d.tcl b/ds9/library/3d.tcl
index 6dd7fde..78a6c2a 100644
--- a/ds9/library/3d.tcl
+++ b/ds9/library/3d.tcl
@@ -465,107 +465,10 @@ proc Process3DCmd {varname iname} {
 
     3DDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	threed::YY_FLUSH_BUFFER
-	threed::yy_scan_string [lrange $var $i end]
-	threed::yyparse
-	incr i [expr $threed::yycnt-1]
-    } else {
-
-    global threed
-    switch -- [string tolower [lindex $var $i]] {
-	open {}
-	close {3DDestroyDialog}
-	az {
-	    incr i
-	    set threed(az) [lindex $var $i]
-	    3DViewPoint
-	}
-	el {
-	    incr i
-	    set threed(el) [lindex $var $i]
-	    3DViewPoint
-	}
-	view -
-	vp {
-	    incr i
-	    set threed(az) [lindex $var $i]
-	    incr i
-	    set threed(el) [lindex $var $i]
-	    3DViewPoint
-	}
-	scale {
-	    incr i
-	    set threed(scale) [lindex $var $i]
-	    3DScale
-	}
-	method {
-	    incr i
-	    set threed(method) [lindex $var $i]
-	    3DRenderMethod
-	}
-	background {
-	    incr i
-	    set threed(background) [lindex $var $i]
-	    3DBackground
-	}
-	highlite {
-	    incr i
-	    switch [string tolower [lindex $var $i]] {
-		color {
-		    incr i
-		    set threed(highlite,color) [lindex $var $i]
-		    3DHighliteColor
-		}
-		default {
-		    set threed(highlite) [FromYesNo [lindex $var $i]]
-		    3DHighlite
-		}
-	    }
-	}
-	border {
-	    incr i
-	    switch [string tolower [lindex $var $i]] {
-		color {
-		    incr i
-		    set threed(border,color) [lindex $var $i]
-		    3DBorderColor
-		}
-		default {
-		    set threed(border) [FromYesNo [lindex $var $i]]
-		    3DBorder
-		}
-	    }
-	}
-	compass {
-	    incr i
-	    switch [string tolower [lindex $var $i]] {
-		color {
-		    incr i
-		    set threed(compass,color) [lindex $var $i]
-		    3DCompassColor
-		}
-		default {
-		    set threed(compass) [FromYesNo [lindex $var $i]]
-		    3DCompass
-		}
-	    }
-	}
-	match {Match3DCurrent}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set threed(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set threed(lock) 1
-		incr i -1
-	    }
-	    Lock3DCurrent
-	}
-	default {Create3DFrame; incr i -1}
-    }
-}
+    threed::YY_FLUSH_BUFFER
+    threed::yy_scan_string [lrange $var $i end]
+    threed::yyparse
+    incr i [expr $threed::yycnt-1]
 }
 
 proc ThreedCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/analysis.tcl b/ds9/library/analysis.tcl
index 2312966..eaba1fb 100644
--- a/ds9/library/analysis.tcl
+++ b/ds9/library/analysis.tcl
@@ -1769,8 +1769,6 @@ proc ProcessAnalysisCmd {varname iname buf fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
 	global parse
 	set parse(buf) $buf
 	set parse(fn) $fn
@@ -1779,148 +1777,6 @@ proc ProcessAnalysisCmd {varname iname buf fn} {
 	analysis::yy_scan_string [lrange $var $i end]
 	analysis::yyparse
 	incr i [expr $analysis::yycnt-1]
-    } else {
-
-    global ime
-    global ianalysis
-
-    switch -- [string tolower [lindex $var $i]] {
-	message {
-	    incr i
-	    switch [string tolower [lindex $var $i]] {
-		ok -
-		okcancel -
-		retrycancel -
-		yesno -
-		yesnocancel {
-		    AnalysisMessage [lindex $var $i] [lindex $var [expr $i+1]]
-		    incr i
-		}
-		default {
-		    AnalysisMessage ok [lindex $var $i]
-		}
-	    }
-	}
-	text {
-	    if {$buf != {}} {
-		AnalysisText apXPA Analysis $buf append
-	    } elseif {$fn != {}} {
-		if {[file exists $fn]} {
-		    set ch [open $fn r]
-		    set txt [read $ch]
-		    close $ch
-		    AnalysisText apXPA Analysis $txt append
-		}
-	    } else {
-		incr i
-		AnalysisText apXPA Analysis [lindex $var $i] append
-	    }
-	}
-	plot {
-	    # for backward compatibility
-	    # used by chandra-ed
-	    # use xpa plot instead
-
-	    incr i
-	    if {$buf != {}} {
-		ProcessAnalysisPlotCmd $varname $iname $buf
-	    } elseif {$fn != {}} {
-		if {[file exists $fn]} {
-		    set ch [open $fn r]
-		    set rr [read $ch]
-		    close $ch
-		    ProcessAnalysisPlotCmd $varname $iname $rr
-		}
-	    } else {
-		ProcessAnalysisPlotCmd $varname $iname {}
-	    }
-	}
-	load {
-	    if {$buf != {}} {
-		ProcessAnalysis buf
-	    } elseif {$fn != {}} {
-		ProcessAnalysisFile $fn
-	    } else {
-		incr i
-		ProcessAnalysisFile [lindex $var $i]
-	    }
-	}
-	clear {
-	    ClearAnalysis
-	    incr i
-	    switch -- [lindex $var $i] {
-		load {
-		    if {$buf != {}} {
-			ProcessAnalysis buf
-		    } elseif {$fn != {}} {
-			ProcessAnalysisFile $fn
-		    } else {
-			incr i
-			ProcessAnalysisFile [lindex $var $i]
-		    }
-		}
-		default {incr i -1}
-	    }
-	}
-	mode {
-	    incr i
-	    switch -- [lindex $var $i] {
-		stats -
-		statistics {set ime(task) stats}
-		hist -
-		histogram {set ime(task) hist}
-		radial -
-		radialprofile {set ime(task) radial}
-		2d -
-		plot2d {set ime(task) plot2d}
-		3d -
-		plot3d {set ime(task) plot3d}
-	    }
-
-	    ProcessRealizeDS9
-	    IMEChangeTask
-	}
-	task {
-	    incr i
-	    if {[string is integer [lindex $var $i]]} {
-		AnalysisTask [lindex $var $i] menu
-	    } else {
-		# invoke by name
-		for {set ii 0} {$ii<$ianalysis(menu,count)} {incr ii} {
-		    if {[string equal -nocase $ianalysis(menu,$ii,item) [lindex $var $i]]} {
-			AnalysisTask $ii menu
-		    }
-		}
-	    }
-	}
-	default {
-	    if {[string is integer [lindex $var $i]]} {
-		AnalysisTask [lindex $var $i] menu
-	    } else {
-		ProcessAnalysisFile [lindex $var $i]
-	    }
-	}
-    }
-}
-}
-
-proc ProcessAnalysisPlotCmd {varname iname buf} {
-    upvar 2 $varname var
-    upvar 2 $iname i
-
-    global iap
-    switch -- [string tolower [lindex $var $i]] {
-	stdin {AnalysisPlotStdin line $iap(tt) {} $buf}
-	default {
-	    PlotLine $iap(tt) Plot \
-		[lindex $var [expr $i+0]] \
-		[lindex $var [expr $i+1]] \
-		[lindex $var [expr $i+2]] \
-		[lindex $var [expr $i+3]] \
-		$buf
-	    incr i 3
-	}
-    }
 }
 
 proc AnalysisCmdTask {task} {
diff --git a/ds9/library/array.tcl b/ds9/library/array.tcl
index 5ee12a6..6b02983 100644
--- a/ds9/library/array.tcl
+++ b/ds9/library/array.tcl
@@ -76,55 +76,14 @@ proc ProcessArrayCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	array::YY_FLUSH_BUFFER
-	array::yy_scan_string [lrange $var $i end]
-	array::yyparse
-	incr i [expr $array::yycnt-1]
-    } else {
-
-    if {[ProcessArrayBackwardCmd $varname $iname $sock $fn]} {
-	return
-    }
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not suppported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![ImportArraySocket $sock $param $layer]} {
-	    InitError xpa
-	    ImportArrayFile $param $layer
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    ImportArrayAlloc $fn $param $layer
-	} else {
-	    ImportArrayFile $param $layer
-	}
-    }
-    FinishLoad
-}
+    array::YY_FLUSH_BUFFER
+    array::yy_scan_string [lrange $var $i end]
+    array::yyparse
+    incr i [expr $array::yycnt-1]
 }
 
 proc ArrayCmdLoad {param layer} {
@@ -164,32 +123,3 @@ proc ProcessSendArrayCmd {proc id param sock fn} {
 	$proc $id {} $fn
     }
 }
-
-# backward compatibility
-proc ProcessArrayBackwardCmd {varname iname sock fn} {
-    upvar 2 $varname var
-    upvar 2 $iname i
-
-    set vvar $var
-    set ii $i
-
-    switch -- [string tolower [lindex $var $i]] {
-	rgb {
-	    set vvar [lreplace $var 0 0]
-	    ProcessRGBArrayCmd vvar ii $sock $fn
-	    return 1
-	}
-	new {
-	    switch -- [string tolower [lindex $var [expr $i+1]]] {
-		rgb {
-		    set vvar [lreplace $var 1 1]
-		    ProcessRGBArrayCmd vvar ii $sock $fn
-		    return 1
-		}
-	    }
-	}
-    }
-
-    return 0
-}
-
diff --git a/ds9/library/backup.tcl b/ds9/library/backup.tcl
index 954fa3d..3ad1c27 100644
--- a/ds9/library/backup.tcl
+++ b/ds9/library/backup.tcl
@@ -783,22 +783,10 @@ proc ProcessBackupCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	backup::YY_FLUSH_BUFFER
-	backup::yy_scan_string [lrange $var $i end]
-	backup::yyparse
-	incr i [expr $backup::yycnt-1]
-    } else {
-
-    set fn [lindex $var $i]
-    if {$fn != {}} {
-	FileLast backupfbox $fn
-	Backup $fn
-    } else {
-	Error [msgcat::mc {Unable to open file}]
-    }
-}
+    backup::YY_FLUSH_BUFFER
+    backup::yy_scan_string [lrange $var $i end]
+    backup::yyparse
+    incr i [expr $backup::yycnt-1]
 }
 
 proc BackupCmd {fn} {
@@ -810,22 +798,10 @@ proc ProcessRestoreCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	restore::YY_FLUSH_BUFFER
-	restore::yy_scan_string [lrange $var $i end]
-	restore::yyparse
-	incr i [expr $restore::yycnt-1]
-    } else {
-
-    set fn [lindex $var $i]
-    if {$fn != {}} {
-	FileLast backupfbox $fn
-	Restore $fn
-    } else {
-	Error [msgcat::mc {Unable to open file}]
-    }
-}
+    restore::YY_FLUSH_BUFFER
+    restore::yy_scan_string [lrange $var $i end]
+    restore::yyparse
+    incr i [expr $restore::yycnt-1]
 }
 
 proc RestoreCmd {fn} {
diff --git a/ds9/library/bin.tcl b/ds9/library/bin.tcl
index 3cf60bd..d8dfd42 100644
--- a/ds9/library/bin.tcl
+++ b/ds9/library/bin.tcl
@@ -723,90 +723,10 @@ proc ProcessBinCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	bin::YY_FLUSH_BUFFER
-	bin::yy_scan_string [lrange $var $i end]
-	bin::yyparse
-	incr i [expr $bin::yycnt-1]
-    } else {
-
-    global bin
-    switch -- [string tolower [lindex $var $i]] {
-	close {BinDestroyDialog}
-	open {BinDialog}
-	match {MatchBinCurrent}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set bin(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set bin(lock) 1
-		incr i -1
-	    }
-	    LockBinCurrent
-	}
-	about {
-	    incr i
-	    switch [lindex $var $i] {
-		center {
-		    BinAboutCenter
-		}
-		default {
-		    BinAbout [lindex $var [expr $i+0]] [lindex $var [expr $i+1]]
-		    incr i
-		}
-	    } 
-	}
-	buffersize {
-	    incr i
-	    set bin(buffersize) [lindex $var $i]
-	    ChangeBinBufferSize
-	}
-	cols {
-	    BinCols \"[lindex $var [expr $i+1]]\" \"[lindex $var [expr $i+2]]\" \"\"
-	    incr i 2
-	}
-	colsz {
-	    BinCols \"[lindex $var [expr $i+1]]\" \"[lindex $var [expr $i+2]]\" \"[lindex $var [expr $i+3]]\"
-	    incr i 3
-	}
-	factor {
-	    incr i
-	    set bx [lindex $var $i]
-	    set by [lindex $var [expr $i+1]]
-	    # note: the spaces are needed so that the menus are in sync
-	    if {$by != {} && [string is double $by]} {
-		set bin(factor) "$bx $by"
-		incr i
-	    } else {
-		set bin(factor) "$bx $bx"
-	    }
-	    ChangeBinFactor
-	}
-	depth {
-	    incr i
-	    set bin(depth) [lindex $var $i]
-	    ChangeBinDepth
-	}
-	filter {
-	    incr i
-	    BinFilter [lindex $var $i]
-	}
-	function {
-	    incr i
-	    set bin(function) [string tolower [lindex $var $i]]
-	    ChangeBinFunction
-	}
-	in {Bin .5 .5}
-	out {Bin 2 2}
-	to {
-	    # eat the 'fit'
-	    incr i
-	    BinToFit
-	}
-    }
-}
+    bin::YY_FLUSH_BUFFER
+    bin::yy_scan_string [lrange $var $i end]
+    bin::yyparse
+    incr i [expr $bin::yycnt-1]
 }
 
 proc BinCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/block.tcl b/ds9/library/block.tcl
index 8a03620..214604c 100644
--- a/ds9/library/block.tcl
+++ b/ds9/library/block.tcl
@@ -289,63 +289,10 @@ proc ProcessBlockCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	block::YY_FLUSH_BUFFER
-	block::yy_scan_string [lrange $var $i end]
-	block::yyparse
-	incr i [expr $block::yycnt-1]
-    } else {
-
-    global block
-    switch -- [string tolower [lindex $var $i]] {
-	open {BlockDialog}
-	close {BlockDestroyDialog}
-	match {MatchBlockCurrent}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set block(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set block(lock) 1
-		incr i -1
-	    }
-	    LockBlockCurrent
-	}
-	in {Block .5 .5}
-	out {Block 2 2}
-	to {
-	    switch -- [string tolower [lindex $var [expr $i+1]]] {
-		fit {
-		    BlockToFit
-		    incr i
-		}
-		default {
-		    set b1 [lindex $var [expr $i+1]]
-		    set b2 [lindex $var [expr $i+2]]
-		    if {[string is double $b2] && $b2 != {}} {
-			set block(factor) "$b1 $b2"
-			incr i 2
-		    } else {
-			set block(factor) "$b1 $b1"
-			incr i
-		    }
-		    ChangeBlock
-		}
-	    }
-	}
-	default {
-	    set b1 [lindex $var $i]
-	    set b2 [lindex $var [expr $i+1]]
-	    if {[string is double $b2] && $b2 != {}} {
-		Block $b1 $b2
-		incr i
-	    } else {
-		Block $b1 $b1
-	    }
-	}
-    }
-}
+    block::YY_FLUSH_BUFFER
+    block::yy_scan_string [lrange $var $i end]
+    block::yyparse
+    incr i [expr $block::yycnt-1]
 }
 
 proc BlockCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/cat.tcl b/ds9/library/cat.tcl
index 5ad5c90..81da9ad 100644
--- a/ds9/library/cat.tcl
+++ b/ds9/library/cat.tcl
@@ -1243,586 +1243,15 @@ proc ProcessCatalogCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global icat
-	set ref [lindex $icat(cats) end]
-	global cvarname
-	set cvarname $ref
-
-	cat::YY_FLUSH_BUFFER
-	cat::yy_scan_string [lrange $var $i end]
-	cat::yyparse
-	incr i [expr $cat::yycnt-1]
-    } else {
-
     global icat
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	{} {CATTool}
-
-	file -
-	import -
-	load {
-	    incr i
-	    set reader VOTRead
-	    switch -- [lindex $var $i] {
-		xml -
-		vot {incr i; set reader VOTRead}
-		sb -
-		starbase {incr i; set reader starbase_read}
-		csv -
-		tsv {incr i; set reader TSVRead}
-	    }
-
-	    set fn [lindex $var $i]
-	    if {$fn != {}} {
-		CATDialog cattool {} {} {} none
-		CATLoadFn [lindex $icat(cats) end] $fn $reader
-		FileLast catfbox $fn
-	    }
-	}
-
-	allcols -
-	allrows -
-	cancel -
-	clear -
-	close -
-	coordinate -
-	crosshair -
-	dec -
-	edit -
-	export -
-	filter -
-	header -
-	hide -
-	location -
-	match -
-	maxrows -
-	name -
-	panto -
-	plot -
-	print -
-	psky -
-	psystem -
-	ra -
-	regions -
-	retrieve -
-	samp -
-	save -
-	server -
-	show -
-	size -
-	sky -
-	skyformat -
-	sort -
-	symbol -
-	system -
-	update -
-	x -
-	y {ProcessCatalog $varname $iname [lindex $icat(cats) end]}
-
-	default {
-	    # another command
-	    if {[string range $item 0 0] == "-"} {
-		CATTool
-		incr i -1
-		return
-	    }
-
-	    # existing cat or load new one?
-	    set ref $item
-
-	    # backward compatibility
-	    if {[string range $ref 0 2] == {cat}} {
-		set ref [string range $ref 3 end]
-	    }
-
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    switch -- $item {
-		file -
-		import -
-		load {incr i -1}
-
-		allcols -
-		allrows -
-		cancel -
-		clear -
-		close -
-		coordinate -
-		crosshair -
-		dec -
-		edit -
-		export -
-		filter -
-		header -
-		hide -
-		location -
-		match -
-		maxrows -
-		name -
-		panto -
-		plot -
-		print -
-		psky -
-		psystem -
-		ra -
-		regions -
-		retrieve -
-		samp -
-		save -
-		server -
-		show -
-		size -
-		sky -
-		skyformat -
-		sort -
-		symbol -
-		system -
-		update -
-		x -
-		y {ProcessCatalog $varname $iname cat${ref}}
-
-		default {
-		    # ok, new catalog
-		    incr i -1
-		    set item [string tolower [lindex $var $i]]
-
-		    # backward compatibility
-		    switch $item {
-			cds {incr i; set item [string tolower [lindex $var $i]]}
-			cxc {set item csc}
-		    }
-
-		    # see if its from our list of cats
-		    foreach mm $icat(def) {
-			set ll [lindex $mm 0]
-			set ww [lindex $mm 1]
-			set ss [lindex $mm 2]
-			set cc [lindex $mm 3]
-
-			if {$ll != {-} && "cat${item}" == $ww} {
-			    CATDialog $ww $ss $cc $ll sync
-			    return
-			}
-		    }
-
-		    # not a default, assume other name
-		    CATDialog catcds cds $item $item sync
-		}
-	    }
-	}
-    }
-}
-}
-
-proc ProcessCatalog {varname iname cvarname} {
-    upvar 2 $varname var
-    upvar 2 $iname i
-
-    global icat
-    global pcat
-    global current
-
-    # we should have a catalog now
-    global $cvarname
-    upvar #0 $cvarname cvar
-
-    if {![info exists cvar(top)]} {
-	Error "[msgcat::mc {Unable to find catalog window}] $cvarname"
-	return
-    }
-    if {![winfo exists $cvar(top)]} {
-	Error "[msgcat:: mc {Unable to find catalog window}] $cvarname"
-	return
-    }
-
-    # now, process it
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	allrows {set cvar(allrows) 1}
-	allcols {set cvar(allcols) 1}
-	cancel {ARCancel $cvarname}
-	clear {CATOff $cvarname}
-	close {CATDestroy $cvarname}
-	coordinate {
-	    incr i
-	    set cvar(x) [lindex $var $i]
-	    incr i
-	    set cvar(y) [lindex $var $i]
-	    incr i
-	    set cvar(sky) [lindex $var $i]
-	}
-	crosshair {CATCrosshair $cvarname}
-	edit {
-	    incr i
-	    set cvar(edit) [FromYesNo [lindex $var $i]]
-	    CATEdit $cvarname
-	}
-	export -
-	save {
-	    incr i
-	    set writer VOTWrite
-	    switch -- [lindex $var $i] {
-		xml -
-		vot {incr i; set writer VOTWrite}
-		sb -
-		starbase {incr i; set writer starbase_write}
-		csv -
-		tsv {incr i; set writer TSVWrite}
-	    }
+    set ref [lindex $icat(cats) end]
+    global cvarname
+    set cvarname $ref
 
-	    set fn [lindex $var $i]
-	    CATSaveFn $cvarname $fn $writer
-	    FileLast catfbox $fn
-	}
-	filter {
-	    incr i
-	    set item [lindex $var $i]
-	    switch -- $item {
-		load {
-		    incr i
-		    set fn [lindex $var $i]
-		    if {[catch {open $fn r} fp]} {
-			Error "[msgcat::mc {Unable to open file}] $fn: $fp"
-			return
-		    }
-		    set flt [read -nonewline $fp]
-		    catch {regsub {\n} $flt " " $flt}
-		    set cvar(filter) [string trim $flt]
-		    catch {close $fp}
-		}
-		default {
-		    set cvar(filter) $item
-		}
-	    }
-	    CATTable $cvarname
-	}
-	header {CATHeader $cvarname}
-	hide {
-	    set cvar(show) 0
-	    CATGenerate $cvarname
-	}
-	location {
-	    incr i
-	    set cvar(loc) [lindex $var $i]
-	    CATGenerate $cvarname
-	}
-	match {
-	    incr i
-	    set item [lindex $var $i]
-	    switch -- $item {
-		error {
-		    incr i
-		    set icat(error) [lindex $var $i]
-		    incr i
-		    set icat(eformat) [lindex $var $i]
-		}
-		function {incr i; set icat(function) [lindex $var $i]}
-		unique {incr i; set icat(unique) [FromYesNo [lindex $var $i]]}
-		return {incr i; set icat(return) [lindex $var $i]}
-		default {
-		    set icat(match1) {}
-		    set icat(match2) {}
-		    set m1 [lindex $var $i]
-		    set m2 [lindex $var [expr $i+1]]
-		    if {$m1 != {}} {
-			if {[string range $m1 0 0] != {-}} {
-			    if {$m2 != {}} {
-				if {[string range $m2 0 0] != {-}} {
-				    incr i
-				    set icat(match1) "cat$m1"
-				    set icat(match2) "cat$m2"
-				    CATMatch $current(frame) \
-					$icat(match1) $icat(match2)
-				    return
-				}
-			    } else {
-				# error
-				return
-			    }
-			}
-		    }
-		    incr i -1
-		    # find them
-		    set ll [llength $icat(cats)]
-		    if {$ll>1} {
-			set icat(match1) [lindex $icat(cats) [expr $ll-2]]
-			set icat(match2) [lindex $icat(cats) [expr $ll-1]]
-			CATMatch $current(frame) $icat(match1) $icat(match2)
-		    } else {
-			# error
-		    }
-		}
-	    }
-	}
-	maxrows {
-	    incr i
-	    set cvar(max) [lindex $var $i]
-	}
-	name {
-	    incr i
-	    set cvar(name) [lindex $var $i]
-	}
-	panto {
-	    incr i
-	    set cvar(panto) [FromYesNo [lindex $var $i]]
-	}
-	plot {
-	    incr i
-	    set cvar(plot,x) [lindex $var $i]
-	    incr i
-	    set cvar(plot,y) [lindex $var $i]
-	    set cvar(plot,xerr) {}
-	    set cvar(plot,yerr) {}
-	    set xerr [lindex $var [expr $i+1]]
-	    set yerr [lindex $var [expr $i+2]]
-	    if {$xerr != {}} {
-		if {[string range $xerr 0 0 ] != {-}} {
-		    incr i
-		    set cvar(plot,xerr) $xerr
-		    if {$yerr != {}} {
-			if {[string range $yerr 0 0 ] != {-}} {
-			    incr i
-			    set cvar(plot,yerr) $yerr
-			}
-		    }
-		}
-	    }
-	    CATPlotGenerate $cvarname
-	}
-	print {CATPrint $cvarname}
-	psky {
-	    incr i
-	    set cvar(psky) [lindex $var $i]
-	    CATGenerate $cvarname
-	}
-	psystem {
-	    incr i
-	    set cvar(psystem) [lindex $var $i]
-	    CATGenerate $cvarname
-	}
-	regions {CATGenerateRegions $cvarname}
-	retrieve {CATApply $cvarname 1}
-	samp {
-	    global ds9
-	    global samp
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		send {
-		    incr i
-		    set name [string tolower [lindex $var $i]]
-		    if {[info exists samp]} {
-			foreach arg $samp(apps,votable) {
-			    foreach {key val} $arg {
-				if {[string tolower $val] == $name} {
-				    SAMPSendTableLoadVotable $key $cvarname
-				    break
-				}
-			    }
-			}
-		    } else {
-			Error [msgcat::mc {SAMP: not connected}]
-		    }
-		}
-		broadcast {SAMPSendTableLoadVotable {} $cvarname}
-		default {
-		    SAMPSendTableLoadVotable {} $cvarname
-		    incr i -1
-		}
-	    }
-	}
-	server {
-	    incr i
-	    set cvar(server) [lindex $var $i]
-	}
-	size {
-	    incr i
-	    set cvar(width) [lindex $var $i]
-	    incr i
-	    set cvar(height) [lindex $var $i]
-	    incr i
-	    set cvar(rformat) [lindex $var $i]
-	    set cvar(rformat,msg) $cvar(rformat)
-	}
-	show {
-	    set cvar(show) 1
-	    CATGenerate $cvarname
-	}
-	sky {
-	    incr i
-	    set cvar(sky) [lindex $var $i]
-	    CoordMenuButtonCmd $cvarname system sky \
-		[list CATWCSMenuUpdate $cvarname]
-	}
-	skyformat {
-	    incr i
-	    set cvar(skyformat) [lindex $var $i]
-	}
-	sort {
-	    incr i
-	    set cvar(sort) [lindex $var $i]
-	    incr i
-	    switch -- [lindex $var $i] {
-		incr {
-		    set cvar(sort,dir) "-increasing"
-		}
-		decr {
-		    set cvar(sort,dir) "-decreasing"
-		}
-	    }
-	    CATTable $cvarname
-	}
-	symbol {
-	    global $cvar(symdb)
-	    set row 1
-	    incr i
-	    if {[string is integer [lindex $var $i]]} {
-		set row [lindex $var $i]
-		incr i
-	    }
-	    switch -- [lindex $var $i] {
-		add {
-		    set row [expr [starbase_nrows $cvar(symdb)]+1]
-		    starbase_rowins $cvar(symdb) $row
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) shape] $pcat(sym,shape)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) color] $pcat(sym,color)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) width] $pcat(sym,width)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) font] $pcat(sym,font)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontsize] \
-			$pcat(sym,font,size)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontweight] \
-			$pcat(sym,font,weight)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontslant] \
-			$pcat(sym,font,slant)
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) units] $pcat(sym,units)
-		    CATGenerate $cvarname
-		}
-		angle {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) angle] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		color {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) color] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		condition {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) condition] \
-			[lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		font {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) font] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		fontsize {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontsize] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		fontweight {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontweight] \
-			[lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		fontslant {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) fontslant] \
-			[lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		load {
-		    incr i
-		    set fn [lindex $var $i]
-		    if {[file exists $fn]} {
-			starbase_read $cvar(symdb) $fn
-			CATGenerate $cvarname
-		    } else {
-			Error "[msgcat::mc {Unable to open file}] $fn"
-			return
-		    }
-		}
-		remove {
-		    starbase_rowdel $cvar(symdb) $row
-		    CATGenerate $cvarname
-		}
-		save {
-		    incr i
-		    starbase_write $cvar(symdb) [lindex $var $i]
-		}
-		size {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) size] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		size2 {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) size2] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		shape {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) shape] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		text {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) text] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-		units {
-		    incr i
-		    starbase_set $cvar(symdb) $row \
-			[starbase_colnum $cvar(symdb) units] [lindex $var $i]
-		    CATGenerate $cvarname
-		}
-	    }
-	}
-	system {
-	    incr i
-	    set cvar(system) [lindex $var $i]
-	    CoordMenuButtonCmd $cvarname system sky \
-		[list CATWCSMenuUpdate $cvarname]
-	}
-	update {CATUpdate $cvarname}
-	x -
-	ra {
-	    incr i
-	    set cvar(colx) [lindex $var $i]
-	    CATGenerate $cvarname
-	}
-	y -
-	dec {
-	    incr i
-	    set cvar(coly) [lindex $var $i]
-	    CATGenerate $cvarname
-	}
-    }
+    cat::YY_FLUSH_BUFFER
+    cat::yy_scan_string [lrange $var $i end]
+    cat::yyparse
+    incr i [expr $cat::yycnt-1]
 }
 
 proc CatalogCmdCheck {} {
@@ -1831,14 +1260,13 @@ proc CatalogCmdCheck {} {
 
     if {![info exists cvar(top)]} {
 	Error "[msgcat::mc {Unable to find catalog window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
     if {![winfo exists $cvar(top)]} {
 	Error "[msgcat:: mc {Unable to find catalog window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
+    return 1
 }
 
 proc CatalogCmdRef {ref} {
diff --git a/ds9/library/colorbar.tcl b/ds9/library/colorbar.tcl
index a5ee821..8575336 100644
--- a/ds9/library/colorbar.tcl
+++ b/ds9/library/colorbar.tcl
@@ -1188,115 +1188,10 @@ proc ProcessCmapCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	cmap::YY_FLUSH_BUFFER
-	cmap::yy_scan_string [lrange $var $i end]
-	cmap::yyparse
-	incr i [expr $cmap::yycnt-1]
-    } else {
-	
-    global colorbar
-    global current
-
-    global ds9
-    global current
-    global rgb
-
-    switch -- [string tolower [lindex $var $i]] {
-	open {ColormapDialog}
-	close {ColormapDestroyDialog}
-	match {
-	    # backward compatibility
-	    MatchColorCurrent
-	}
-	lock {
-	    # backward compatibility
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set colorbar(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set colorbar(lock) 1
-		incr i -1
-	    }
-	    LockColorCurrent
-	}
-	load -
-	file {
-	    incr i
-	    set fn [lindex $var $i]
-	    LoadColormapFile $fn
-	    FileLast colormapfbox $fn
-	}
-	save {
-	    incr i
-	    set fn [lindex $var $i]
-	    SaveColormapFile $fn
-	    FileLast colormapfbox $fn
-	}
-	invert {
-	    incr i
-	    set colorbar(invert) [FromYesNo [lindex $var $i]]
-	    InvertColorbar
-	}
-	tag {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    switch $item {
-		load {incr i; LoadColorTag [lindex $var $i]}
-		save {incr i; $current(colorbar) tag save [lindex $var $i]}
-		delete {DeleteColorTag}
-	    }
-	}
-	value {
-	    incr i
-	    set c [lindex $var $i]
-	    incr i
-	    set b [lindex $var $i]
-	    if {$current(frame) != {}} {
-		RGBEvalLockColorbar [list $current(colorbar) adjust $c $b]
-		RGBEvalLockCurrent rgb(lock,colorbar) [list $current(frame) colormap begin]
-		RGBEvalLockCurrent rgb(lock,colorbar) [list $current(frame) colormap motion [$current(colorbar) get colormap]]
-		RGBEvalLockCurrent rgb(lock,colorbar) [list $current(frame) colormap end]
-	    }
-	    LockColorCurrent
-	    UpdateColorDialog
-	}
-	default {
-	    switch -- [$current(frame) get type] {
-		base -
-		3d {
-		    set cmap [lindex $var $i]
-		    # common variants on spellings
-		    switch -- [string tolower $cmap] {
-			gray {set cmap grey}
-		    }
-
-		    set id [colorbar list id]
-		    set found 0
-		    foreach ii $id {
-			set title [colorbar get name $ii]
-			if {[string equal -nocase $title $cmap]} {
-			    set colorbar(map) $title
-			    colorbar map "{$colorbar(map)}"
-			    $current(frame) colormap [colorbar get colormap]
-			    set colorbar(invert) [colorbar get invert]
-
-			    set found 1
-			    break
-			}
-		    }
-		    if {!$found} {
-			Error "[msgcat::mc {Unknown Colormap}] $cmap"
-		    }
-		}
-		rgb {}
-	    }
-	    LockColorCurrent
-	    UpdateColorDialog
-	}
-    }
-}
+    cmap::YY_FLUSH_BUFFER
+    cmap::yy_scan_string [lrange $var $i end]
+    cmap::yyparse
+    incr i [expr $cmap::yycnt-1]
 }
 
 proc CmapCmd {item} {
@@ -1366,122 +1261,10 @@ proc ProcessColorbarCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	colorbar::YY_FLUSH_BUFFER
-	colorbar::yy_scan_string [lrange $var $i end]
-	colorbar::yyparse
-	incr i [expr $colorbar::yycnt-1]
-    } else {
-	
-    global colorbar
-    global view
-
-    set item [string tolower [lindex $var $i]]
-
-    switch  -- $item {
-	match {
-	    MatchColorCurrent
-	}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set colorbar(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set colorbar(lock) 1
-		incr i -1
-	    }
-	    LockColorCurrent
-	}
-	numerics {
-	    incr i
-	    set yesno [string tolower [lindex $var $i]]
-	    set colorbar(numerics) [FromYesNo $yesno]
-	    UpdateView
-	}
-	space {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		value {set item 1}
-		default {set item 0}
-	    }
-	    set colorbar(space) $item
-	    UpdateView
-	}
-	font {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    set colorbar(font) $item
-	    UpdateView
-	}
-	fontsize {
-	    incr i
-	    set item [lindex $var $i]
-	    set colorbar(font,size) $item
-	    UpdateView
-	}
-	fontweight {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    set colorbar(font,weight) $item
-	    UpdateView
-	}
-	fontslant {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    set colorbar(font,slant) $item
-	    UpdateView
-	}
-	fontstyle {
-	    # backward compatibility
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    switch $item {
-		normal {
-		    set colorbar(font,weight) normal
-		    set colorbar(font,slant) roman
-		}
-		bold {
-		    set colorbar(font,weight) bold
-		    set colorbar(font,slant) roman
-		}
-		italic {
-		    set colorbar(font,weight) normal
-		    set colorbar(font,slant) italic
-		}
-	    }
-	    UpdateView
-	}
-	orientation {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    set colorbar(orientation) $item
-	    UpdateView
-	}
-	vertical -
-	horizontal {
-	    set colorbar(orientation) $item
-	    UpdateView
-	}
-	size {
-	    incr i
-	    set item [lindex $var $i]
-	    set colorbar(size) $item
-	    UpdateView
-	}
-	ticks {
-	    incr i
-	    set item [lindex $var $i]
-	    set colorbar(ticks) $item
-	    UpdateView
-	}
-	default {
-	    set yesno [string tolower [lindex $var $i]]
-	    set view(colorbar) [FromYesNo $yesno]
-	    UpdateView
-	}
-    }
-}
+    colorbar::YY_FLUSH_BUFFER
+    colorbar::yy_scan_string [lrange $var $i end]
+    colorbar::yyparse
+    incr i [expr $colorbar::yycnt-1]
 }
 
 proc ColorbarCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/contour.tcl b/ds9/library/contour.tcl
index d55e3c9..2e23cee 100644
--- a/ds9/library/contour.tcl
+++ b/ds9/library/contour.tcl
@@ -1054,232 +1054,10 @@ proc ProcessContourCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	contour::YY_FLUSH_BUFFER
-	contour::yy_scan_string [lrange $var $i end]
-	contour::yyparse
-	incr i [expr $contour::yycnt-1]
-    } else {
-
-    global contour
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	open {ContourDialog}
-	close {ContourDestroyDialog}
-	clear {ContourOffDialog}
-	load {
-	    incr i
-	    set fn [lindex $var $i]
-	    if {$fn != {}} {
-		if {[file extension $fn] == {.con}} {
-		    # backward compatibility
-		    incr i
-		    set sys [lindex $var $i]
-		    incr i
-		    set sky [lindex $var $i]
-		    incr i
-		    set color [lindex $var $i]
-		    incr i
-		    set width [lindex $var $i]
-		    incr i
-		    set dash [lindex $var $i]
-		    incr i [ProcessContourFix sys sky color width dash]
-		    $current(frame) contour load $color $width $dash \
-			"\{$fn\}" $sys $sky
-		} else {
-		    incr i
-		    set color [lindex $var $i]
-		    if {$color == {} || [string range $color 0 0] == "-"} {
-			$current(frame) contour load "\{$fn\}"
-			incr i -1
-		    } else {
-			incr i
-			set width [lindex $var $i]
-			incr i
-			set dash [FromYesNo [lindex $var $i]]
-			$current(frame) contour load "\{$fn\}" \
-			    $color $width $dash
-		    }
-		}
-	    }
-	    FileLast contourlfbox $fn
-	    UpdateContourDialog
-	}
-	save {
-	    incr i
-	    set fn [lindex $var $i]
-	    incr i
-	    set sys [lindex $var $i]
-	    incr i
-	    set sky [lindex $var $i]
-	    # Backward compatibility
-	    incr i
-	    set color {}
-	    incr i
-	    set width {}
-	    incr i
-	    set dash {}
-	    incr i [ProcessContourFix sys sky color width dash]
-	    if {$fn != {}} {
-		$current(frame) contour save "\{$fn\}" $sys $sky
-	    }
-	    FileLast contoursfbox $fn
-	}
-	convert {Contour2Polygons}
-	loadlevels {
-	    ContourDialog
-	    incr i
-	    ContourLoadLevelsNow [lindex $var $i]
-	    UpdateContour
-	}
-	savelevels {
-	    ContourDialog
-	    incr i
-	    ContourSaveLevelsNow [lindex $var $i]
-	}
-	copy {ContourCCopyDialog}
-	paste {
-	    incr i
-	    set sys [lindex $var $i]
-	    incr i
-	    set sky [lindex $var $i]
-	    incr i
-	    # backward compatibility
-	    set color [lindex $var $i]
-	    incr i
-	    set width [lindex $var $i]
-	    incr i
-	    set dash [lindex $var $i]
-	    incr i [ProcessContourFix sys sky color width dash]
-	    if {$current(frame) != {} && $contour(copy) != {}} {
-		set cc [$contour(copy) get contour $sys $sky]
-		$current(frame) contour paste cc $color $width $dash
-	    }
-	}
-	color {
-	    ContourDialog
-	    incr i
-	    set contour(color) [lindex $var $i]
-	    UpdateContour
-	}
-	width {
-	    ContourDialog
- 	    incr i
-	    set contour(width) [lindex $var $i]
-	    UpdateContour
-	}
-	dash {
-	    ContourDialog
-	    incr i
-	    set contour(dash) [FromYesNo [lindex $var $i]]
-	    UpdateContour
-	}
-	smooth {
-	    ContourDialog
-	    incr i
-	    set contour(smooth) [lindex $var $i]
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	method {
-	    ContourDialog
-	    incr i
-	    set contour(method) [lindex $var $i]
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	nlevels {
-	    ContourDialog
-	    incr i
-	    set contour(numlevel) [lindex $var $i]
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	scale {
-	    set contour(init,scale) 1
-	    ContourDialog
-	    incr i
-	    set contour(scale) [string tolower [lindex $var $i]]
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	log {
-	    set contour(init,scale) 1
-	    ContourDialog
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		exp {
-		    incr i
-		    set contour(log) [string tolower [lindex $var $i]]
-		}
-		default {
-		    incr i -1
-		    set contour(log) [string tolower [lindex $var $i]]
-		}
-	    }
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	mode {
-	    set contour(init,mode) 1
-	    ContourDialog
-	    incr i
-	    set contour(mode) [lindex $var $i]
-	    ContourModeDialog
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	scope {
-	    set contour(init,scope) 1
-	    ContourDialog
-	    incr i
-	    set contour(scope) [lindex $var $i]
-	    ContourModeDialog
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	limits {
-	    set contour(init,limits) 1
-	    ContourDialog
-	    incr i
-	    set contour(min) [lindex $var $i]
-	    incr i
-	    set contour(max) [lindex $var $i]
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	levels {
-	    ContourDialog
-	    global dcontour
-	    $dcontour(txt) delete 1.0 end
-	    incr i
-	    $dcontour(txt) insert end [lindex $var $i]
-	    UpdateContour
-	}
-	generate {
-	    ContourDialog
-	    ContourGenerateDialog
-	    UpdateContour
-	}
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    set contour(view) [FromYesNo [lindex $var $i]]
-	    UpdateContour
-	}
-	default {
-	    set contour(view) 1
-	    UpdateContour
-	    incr i -1
-	}
-    }
-}
+    contour::YY_FLUSH_BUFFER
+    contour::yy_scan_string [lrange $var $i end]
+    contour::yyparse
+    incr i [expr $contour::yycnt-1]
 }
 
 proc ContourCmdLoad {fn} {
diff --git a/ds9/library/crop.tcl b/ds9/library/crop.tcl
index 14a73ba..e4a2c01 100644
--- a/ds9/library/crop.tcl
+++ b/ds9/library/crop.tcl
@@ -393,56 +393,10 @@ proc ProcessCropCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	crop::YY_FLUSH_BUFFER
-	crop::yy_scan_string [lrange $var $i end]
-	crop::yyparse
-	incr i [expr $crop::yycnt-1]
-    } else {
-
-    global crop
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	match {
-	    incr i
-	    MatchCropCurrent [lindex $var $i]
-	}
-	lock {
-	    incr i
-	    set crop(lock) [lindex $var $i]
-	    LockCropCurrent
-	}
-	open {CropDialog}
-	close {CropDestroyDialog}
-	reset {CropReset}
-	3d {
-	    incr i 1
-	    set zmin [lindex $var [expr $i+0]]
-	    set zmax [lindex $var [expr $i+1]]
-	    set sys [lindex $var [expr $i+2]]
-
-	    incr i 1
-	    incr i [FixSpecSystem sys physical]
-
-	    $current(frame) crop 3d $zmin $zmax $sys
-	}
-	default {
-	    set x [lindex $var [expr $i+0]]
-	    set y [lindex $var [expr $i+1]]
-	    set w [lindex $var [expr $i+2]]
-	    set h [lindex $var [expr $i+3]]
-	    set sys [lindex $var [expr $i+4]]
-	    set sky [lindex $var [expr $i+5]]
-	    set dformat [lindex $var [expr $i+6]]
-
-	    incr i 3
-	    incr i [FixSpec sys sky dformat physical fk5 degrees]
-
-	    $current(frame) crop center $x $y $sys $sky $w $h $sys $dformat
-	}
-    }
-}
+    crop::YY_FLUSH_BUFFER
+    crop::yy_scan_string [lrange $var $i end]
+    crop::yyparse
+    incr i [expr $crop::yycnt-1]
 }
 
 proc CropCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/crosshair.tcl b/ds9/library/crosshair.tcl
index 13264fe..18c9466 100644
--- a/ds9/library/crosshair.tcl
+++ b/ds9/library/crosshair.tcl
@@ -263,39 +263,10 @@ proc ProcessCrosshairCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	crosshair::YY_FLUSH_BUFFER
-	crosshair::yy_scan_string [lrange $var $i end]
-	crosshair::yyparse
-	incr i [expr $crosshair::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	match {
-	    incr i
-	    MatchCrosshairCurrent [lindex $var $i]
-	}
-	lock {
-	    incr i
-	    set crosshair(lock) [lindex $var $i]
-	    LockCrosshairCurrent
-	}
-	default {
-	    set x [lindex $var [expr $i+0]]
-	    set y [lindex $var [expr $i+1]]
-	    set sys [lindex $var [expr $i+2]]
-	    set sky [lindex $var [expr $i+3]]
-	    set format {}
-
-	    incr i 1
-	    incr i [FixSpec sys sky format physical fk5 degrees]
-
-	    CrosshairTo $x $y $sys $sky
-	    UpdateCrosshairDialog
-	}
-    }
-}
+    crosshair::YY_FLUSH_BUFFER
+    crosshair::yy_scan_string [lrange $var $i end]
+    crosshair::yyparse
+    incr i [expr $crosshair::yycnt-1]
 }
 
 proc CrosshairCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/cube.tcl b/ds9/library/cube.tcl
index e43bc4b..6fe09ec 100644
--- a/ds9/library/cube.tcl
+++ b/ds9/library/cube.tcl
@@ -707,147 +707,10 @@ proc ProcessCubeCmd {varname iname} {
 
     CubeDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	cube::YY_FLUSH_BUFFER
-	cube::yy_scan_string [lrange $var $i end]
-	cube::yyparse
-	incr i [expr $cube::yycnt-1]
-    } else {
-
-    global cube
-    global dcube
-
-    global blink
-    global current
-    global rgb
-
-    switch -- [string tolower [lindex $var $i]] {
-	match {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		switch -- [lindex $var $i] {
-		    {} {MatchCubeCurrent image}
-		    default {MatchCubeCurrent [lindex $var $i]}
-		}
-	    } else {
-		MatchCubeCurrent image
-		incr i -1
-	    }
-	}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		switch -- [lindex $var $i] {
-		    {} -
-		    yes -
-		    1 {set cube(lock) image}
-		    no -
-		    0 {set cube(lock) none}
-		    default {set cube(lock) [lindex $var $i]}
-		}
-	    } else {
-		set cube(lock) image
-		incr i -1
-	    }
-	    LockCubeCurrent
-	}
-	open {}
-	close {CubeDestroyDialog}
-	play {CubePlay}
-	stop {CubeStop}
-	next {CubeNext}
-	prev {CubePrev}
-	first {CubeFirst}
-	last {CubeLast}
-	interval {
-	    incr i
-	    set blink(interval) [expr int([lindex $var $i]*1000)]
-	}
-	axis {
-	    incr i; 
-	    set item [lindex $var $i]
-	    if {[string is integer $item]} {
-		set cube(axis) [expr $item-1]
-		if {$cube(axis) < 2} {
-		    set cube(axis) 2
-		}
-	    }
-	}
-	axes -
-	order {
-	    incr i; 
-	    switch -- [string tolower [lindex $var $i]] {
-		lock {
-		    incr i; 
-		    if {!([string range [lindex $var $i] 0 0] == "-")} {
-			set cube(lock,axes) [FromYesNo [lindex $var $i]]
-		    } else {
-			set cube(lock,axes) 1
-			incr i -1
-		    }
-		    LockAxesCurrent
-		}
-		default {
-		    set cube(axes) [lindex $var $i]
-		    CubeAxes
-		}
-	    }
-	}
-    	default {
-	    # defaults
-	    set ss 1
-	    set sys image
-	    set axis 2
-
-	    # slice
-	    set item [lindex $var $i]
-	    if {$item != {}} {
-		if {!([string range $item 0 0] == "-")} {
-		    if {[string is double $item]} {
-			set ss $item
-		    } else {
-			set sys $item
-		    }
-
-		    # sys
-		    set item [lindex $var [expr $i+1]]
-		    if {$item != {}} {
-			if {!([string range $item 0 0] == "-")} {
-			    incr i
-			    if {[string is integer $item]} {
-				set axis [expr $item-1]
-			    } else {
-				set sys $item
-			    }
-
-			    # axis
-			    set item [lindex $var [expr $i+1]]
-			    if {$item != {}} {
-				if {!([string range $item 0 0] == "-")} {
-				    incr i
-				    if {[string is integer $item]} {
-					set axis [expr $item-1]
-				    }
-				}
-			    }
-			}
-		    }
-		} else {
-		    incr i -1
-		}
-	    }
-
-	    set dcube(wcs,$axis) $ss
-	    set cube(system) $sys
-	    set cube(axis) $axis
-	    if {$cube(axis) < 2} {
-		set cube(axis) 2
-	    }
-	    CubeApply $cube(axis)
-	}
-    }
-}
+    cube::YY_FLUSH_BUFFER
+    cube::yy_scan_string [lrange $var $i end]
+    cube::yyparse
+    incr i [expr $cube::yycnt-1]
 }
 
 proc CubeCmdCoord {ss sys axis} {
diff --git a/ds9/library/debug.tcl b/ds9/library/debug.tcl
index 3706199..4ee3892 100644
--- a/ds9/library/debug.tcl
+++ b/ds9/library/debug.tcl
@@ -23,7 +23,6 @@ proc DebugDef {} {
     set debug(tcl,http) 0
     set debug(tcl,ftp) 0
     set debug(tcl,xpa) 0
-    set debug(tcl,parser) 1
     set debug(tcl,image) 0
 
     set debug(tksao,ast) 0
@@ -98,8 +97,6 @@ proc DebugMenu {} {
 	-variable debug(tcl,ftp)
     $ds9(mb).debug.tcl add checkbutton -label {XPA} \
 	-variable debug(tcl,xpa)
-    $ds9(mb).debug.tcl add checkbutton -label {TclParser} \
-	-variable debug(tcl,parser)
     $ds9(mb).debug.tcl add checkbutton -label {IMAGE} \
 	-variable debug(tcl,image)
 
@@ -196,10 +193,6 @@ proc ProcessDebugTclCmd {varname iname} {
 	http {set debug(tcl,http) 1}
 	ftp {set debug(tcl,ftp) 1}
 	xpa {set debug(tcl,xpa) 1}
-	tclparser {
-	    incr i
-	    set debug(tcl,parser) [FromYesNo [lindex $var $i]]
-	}
 	image {
 	    set debug(tcl,hv) 1
 	    set debug(tcl,http) 1
diff --git a/ds9/library/envi.tcl b/ds9/library/envi.tcl
index 43459b6..1f3d755 100644
--- a/ds9/library/envi.tcl
+++ b/ds9/library/envi.tcl
@@ -35,37 +35,10 @@ proc ProcessENVICmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
 	envi::YY_FLUSH_BUFFER
 	envi::yy_scan_string [lrange $var $i end]
 	envi::yyparse
 	incr i [expr $envi::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    set fn [lindex $var $i]
-    set fn2 [lindex $var [expr $i+1]]
-    if {$fn2 == {}} {
-	set fn2 [FindENVIDataFile $fn]
-    }
-    ImportENVIFile $fn $fn2
-    FinishLoad
-}
 }
 
 proc FindENVIDataFile {fn} {
diff --git a/ds9/library/eso.tcl b/ds9/library/eso.tcl
index b7b7c6a..ab7c199 100644
--- a/ds9/library/eso.tcl
+++ b/ds9/library/eso.tcl
@@ -162,15 +162,10 @@ proc ProcessESOCmd {varname iname} {
 
     ESODialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	dsseso::YY_FLUSH_BUFFER
-	dsseso::yy_scan_string [lrange $var $i end]
-	dsseso::yyparse
-	incr i [expr $dsseso::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname deso
-    }
+    dsseso::YY_FLUSH_BUFFER
+    dsseso::yy_scan_string [lrange $var $i end]
+    dsseso::yyparse
+    incr i [expr $dsseso::yycnt-1]
 }
 
 proc ProcessSendESOCmd {proc id param} {
diff --git a/ds9/library/export.tcl b/ds9/library/export.tcl
index eff40ea..0188f1e 100644
--- a/ds9/library/export.tcl
+++ b/ds9/library/export.tcl
@@ -36,144 +36,10 @@ proc ProcessExportCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
 	export::YY_FLUSH_BUFFER
 	export::yy_scan_string [lrange $var $i end]
 	export::yyparse
 	incr i [expr $export::yycnt-1]
-    } else {
-
-    set format {}
-    set fn [lindex $var $i]
-    set fn2 {}
-    if {$fn == {}} {
-	return
-    }
-
-    switch -- $fn {
-	array -
-	rgbarray -
-	nrrd -
-	envi -
-	gif -
-	tiff -
-	jpeg -
-	png {
-	    set format $fn
-	    set fn {}
-	    incr i
-	}
-	jpg {
-	    set format jpeg
-	    set fn {}
-	    incr i
-	}
-	tif {
-	    set format tiff
-	    set fn {}
-	    incr i
-	}
-    }
-
-    # one last time
-    if {$fn == {}} {
-	set fn [lindex $var $i]
-	if {$fn == {}} {
-	    return
-	}
-    }
-
-    if {$format == {}} {
-	set format [ExtToFormat $fn]
-    }
-
-    global export
-    set param [string tolower [lindex $var [expr $i+1]]]
-    switch $format {
-	array -
-	rgbarray -
-	nrrd {
-	    switch $param {
-		native -
-		big -
-		bigendian -
-		little -
-		littleendian {
-		    set export(endian) $param
-		    incr i
-		}
-	    }
-	}
-	envi {
-	    switch $param {
-		{} {set fn2 "[file rootname $fn].bsq"}
-		native -
-		big -
-		bigendian -
-		little -
-		littleendian {
-		    set fn2 "[file rootname $fn].bsq"
-		    set export(endian) $param
-		    incr i
-		}
-		default {
-		    if {[string range $param 0 0] == {-}} {
-			set fn2 "[file rootname $fn].bsq"
-		    } else {
-			set fn2 $param
-			incr i
-			set param [string tolower [lindex $var [expr $i+1]]]
-			switch $param {
-			    native -
-			    big -
-			    bigendian -
-			    little -
-			    littleendian {
-				set export(endian) $param
-				incr i
-			    }
-			}
-		    }
-		}
-	    }
-	}
-	gif {}
-	jpeg {
-	    if {$param != {} && [string is integer $param]} {
-		set export(jpeg,quality) $param
-		incr i
-	    }
-	}
-	tiff {
-	    switch $param {
-		none -
-		jpeg -
-		packbits -
-		deflate {
-		    set export(tiff,compress) $param
-		    incr i
-		}
-	    }
-	}
-	png {}
-    }
-
-    switch -- $format {
-	array {FileLast arrayfbox $fn}
-	rgbarray {FileLast rgbarrayfbox $fn}
-	nrrd {FileLast nrrdfbox $fn}
-	envi {
-	    FileLast envifbox $fn
-	    FileLast envi2fbox $fn2
-	}
-	gif {FileLast giffbox $fn}
-	jpeg {FileLast jpegfbox $fn}
-	tiff {FileLast tifffbox $fn}
-	png {FileLast pngfbox $fn}
-    }
-    Export $fn $format $fn2
-}
 }
 
 proc ExportCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/fits.tcl b/ds9/library/fits.tcl
index 36548cd..86f02a3 100644
--- a/ds9/library/fits.tcl
+++ b/ds9/library/fits.tcl
@@ -107,52 +107,14 @@ proc ProcessFitsCmd {varname iname sock fn} {
 	return
     }
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	fits::YY_FLUSH_BUFFER
-	fits::yy_scan_string [lrange $var $i end]
-	fits::yyparse
-	incr i [expr $fits::yycnt-1]
-    } else {
-
-    set layer {}
-    set mode {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    set mode slice
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadFitsSocket $sock $param $layer $mode]} {
-	    InitError xpa
-	    LoadFitsFile $param $layer $mode
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadFitsAlloc $fn $param $layer $mode
-	} else {
-	    LoadFitsFile $param $layer $mode
-	}
-    }
-    FinishLoad
-}
+    fits::YY_FLUSH_BUFFER
+    fits::yy_scan_string [lrange $var $i end]
+    fits::yyparse
+    incr i [expr $fits::yycnt-1]
 }
 
 proc FitsCmdLoad {param layer mode} {
diff --git a/ds9/library/frame.tcl b/ds9/library/frame.tcl
index 2d13398..2bbbe91 100644
--- a/ds9/library/frame.tcl
+++ b/ds9/library/frame.tcl
@@ -2056,167 +2056,10 @@ proc ProcessFrameCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	frame::YY_FLUSH_BUFFER
-	frame::yy_scan_string [lrange $var $i end]
-	frame::yyparse
-	incr i [expr $frame::yycnt-1]
-    } else {
-
-    global current
-    global active
-    global panzoom
-
-    catch {
-	switch -- [string tolower [lindex $var $i]] {
-	    match {
-		incr i
-		MatchFrameCurrent [lindex $var $i]
-	    }
-	    lock {
-		incr i
-		set panzoom(lock) [lindex $var $i]
-		LockFrameCurrent
-	    }
-	    center {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {CenterAllFrame}
-		    {} {CenterCurrentFrame; incr i -1}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    CenterFrame $f
-			} else {
-			    CenterCurrentFrame; incr i -1
-			}
-		    }
-		}
-	    }
-	    clear {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {ClearAllFrame}
-		    {} {ClearCurrentFrame; incr i -1}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    ClearFrame $f
-			} else {
-			    ClearCurrentFrame; incr i -1
-			}
-		    }
-		}
-	    }
-	    delete {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {DeleteAllFrames}
-		    {} {DeleteCurrentFrame; incr i -1}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    DeleteSingleFrame $f
-			} else {
-			    DeleteCurrentFrame; incr i -1
-			}
-		    }
-		}
-	    }
-	    new {
-		incr i
-		switch -- [lindex $var $i] {
-		    rgb {CreateRGBFrame}
-		    3d {Create3DFrame}
-		    default {CreateFrame; incr i -1}
-		}
-	    }
-	    reset {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {ResetAllFrame}
-		    {} {ResetCurrentFrame; incr i -1}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    ResetFrame $f
-			} else {
-			    ResetCurrentFrame; incr i -1
-			}
-		    }
-		}
-	    }
-	    refresh {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {UpdateAllFrame}
-		    {} {UpdateCurrentFrame; incr i -1}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    UpdateFrame $f
-			} else {
-			    UpdateCurrentFrame; incr i -1
-			}
-		    }
-		}
-	    }
-	    hide {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {ActiveFrameNone}
-		    {} {
-			set active($current(frame)) 0
-			UpdateActiveFrames
-			incr i -1
-		    }
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    set active($f) 0
-			    UpdateActiveFrames
-			} else {
-			    set active($current(frame)) 0
-			    UpdateActiveFrames
-			    incr i -1
-			}
-		    }
-		}
-	    }
-	    show {
-		incr i
-		switch -- [lindex $var $i] {
-		    all {ActiveFrameAll}
-		    default {
-			if {[string is integer [lindex $var $i]]} {
-			    set f "Frame[lindex $var $i]"
-			    set active($f) 1
-			    UpdateActiveFrames
-			} else {
-			    incr i -1
-			}
-		    }
-		}
-	    }
-	    move {
-		incr i
-		switch -- [lindex $var $i] {
-		    first {MoveFirstFrame}
-		    back {MovePrevFrame}
-		    forward {MoveNextFrame}
-		    last {MoveLastFrame}
-		}
-	    }
-	    first {FirstFrame}
-	    prev {PrevFrame}
-	    next {NextFrame}
-	    last {LastFrame}
-	    frameno {incr i; CreateGotoFrame [lindex $var $i] base}
-	    default {CreateGotoFrame [lindex $var $i] base}
-	}
-    }
-}
+    frame::YY_FLUSH_BUFFER
+    frame::yy_scan_string [lrange $var $i end]
+    frame::yyparse
+    incr i [expr $frame::yycnt-1]
 }
 
 proc ActiveCmdSet {which value {cmd {}}} {
@@ -2337,81 +2180,10 @@ proc ProcessTileCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	tile::YY_FLUSH_BUFFER
-	tile::yy_scan_string [lrange $var $i end]
-	tile::yyparse
-	incr i [expr $tile::yycnt-1]
-    } else {
-	
-    global current
-    global tile
-
-    switch -- [string tolower [lindex $var $i]] {
-	mode {
-	    incr i
-	    set tile(mode) [lindex $var $i]
-	}
-	grid {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		mode {
-		    incr i
-		    set tile(grid,mode) [lindex $var $i]
-		}
-		direction {
-		    incr i
-		    set tile(grid,dir) [lindex $var $i]
-		}
-		layout {
-		    incr i
-		    set tile(grid,col) [lindex $var $i]
-		    incr i
-		    set tile(grid,row) [lindex $var $i]
-		    set tile(grid,mode) {manual}
-		}
-		gap {
-		    incr i
-		    set tile(grid,gap) [lindex $var $i]
-		}
-		default {
-		    if {[string range [lindex $var $i] 0 0] != {-}} {
-			set tile(mode) grid
-		    } else {
-			incr i -1
-		    }
-		}
-	    }
-	}
-	column {
-	    set tile(mode) column
-	}
-	row {
-	    set tile(mode) row
-	}
-
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    if {[FromYesNo [lindex $var $i]]} {
-		set current(display) tile
-	    } else {
-		set current(display) single
-	    }
-	}
-	default {
-	    set current(display) tile
-	    incr i -1
-	}
-    }
-    DisplayMode
-}
+    tile::YY_FLUSH_BUFFER
+    tile::yy_scan_string [lrange $var $i end]
+    tile::yyparse
+    incr i [expr $tile::yycnt-1]
 }
 
 proc TileCmdSet {which value {cmd {}}} {
@@ -2451,43 +2223,10 @@ proc ProcessBlinkCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	blink::YY_FLUSH_BUFFER
-	blink::yy_scan_string [lrange $var $i end]
-	blink::yyparse
-	incr i [expr $blink::yycnt-1]
-    } else {
-
-    global current
-    global blink
-
-    switch -- [string tolower [lindex $var $i]] {
-	interval {
-	    incr i
-	    set blink(interval) [expr int([lindex $var $i]*1000)]
-	}
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    if {[FromYesNo [lindex $var $i]]} {
-		set current(display) blink
-	    } else {
-		set current(display) single
-	    }
-	}
-	default {
-	    set current(display) blink
-	    incr i -1
-	}
-    }
-    DisplayMode
-}
+    blink::YY_FLUSH_BUFFER
+    blink::yy_scan_string [lrange $var $i end]
+    blink::yyparse
+    incr i [expr $blink::yycnt-1]
 }
 
 proc BlinkCmdSet {which value {cmd {}}} {
@@ -2519,154 +2258,13 @@ proc ProcessLockCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global panzoom
-    global crop
-    global crosshair
-    global cube
-    global ime
-    global bin
-    global scale
-    global colorbar
-    global block
-    global smooth
-    global threed
-
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	lock::YY_FLUSH_BUFFER
-	lock::yy_scan_string [lrange $var $i end]
-	lock::yyparse
-	incr i [expr $lock::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	frame -
-	frames {
-	    incr i
-	    set panzoom(lock) [lindex $var $i]
-	    LockFrameCurrent
-	}
-	crosshair -
-	crosshairs {
-	    incr i
-	    set crosshair(lock) [lindex $var $i]
-	    LockCrosshairCurrent
-	}
-	crop {
-	    incr i
-	    set crop(lock) [lindex $var $i]
-	    LockCropCurrent
-	}
-	slice -
-	cube -
-	datacube {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		switch -- [lindex $var $i] {
-		    {} -
-		    yes -
-		    1 {set cube(lock) image}
-		    no -
-		    0 {set cube(lock) none}
-		    default {set cube(lock) [lindex $var $i]}
-		}
-	    } else {
-		set cube(lock) image
-		incr i -1
-	    }
-	    LockCubeCurrent
-	}
-	bin {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set bin(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set bin(lock) 1
-		incr i -1
-	    }
-	    LockBinCurrent
-	}
-	axes -
-	order {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set cube(lock,axes) [FromYesNo [lindex $var $i]]
-	    } else {
-		set cube(lock,axes) 1
-		incr i -1
-	    }
-	    LockAxesCurrent
-	}
-	scale -
-	scales {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set scale(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set scale(lock) 1
-		incr i -1
-	    }
-	    LockScaleCurrent
-	}
-	limits -
-	scalelimits {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set scale(lock,limits) [FromYesNo [lindex $var $i]]
-	    } else {
-		set scale(lock,limits) 1
-		incr i -1
-	    }
-	    LockScaleLimitsCurrent
-	}
-	color -
-	colormap -
-	colorbar -
-	colorbars {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set colorbar(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set colorbar(lock) 1
-		incr i -1
-	    }
-	    LockColorCurrent
-	}
-	block {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set block(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set block(lock) 1
-		incr i -1
-	    }
-	    LockBlockCurrent
-	}
-	smooth {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set smooth(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set smooth(lock) 1
-		incr i -1
-	    }
-	    LockSmoothCurrent
-	}
-	3d {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set threed(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set threed(lock) 1
-		incr i -1
-	    }
-	    Lock3DCurrent
-	}
-    }
-}
+    lock::YY_FLUSH_BUFFER
+    lock::yy_scan_string [lrange $var $i end]
+    lock::yyparse
+    incr i [expr $lock::yycnt-1]
 }
 
 proc ProcessSendLockCmd {proc id param} {
@@ -2717,57 +2315,8 @@ proc ProcessMatchCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	match::YY_FLUSH_BUFFER
-	match::yy_scan_string [lrange $var $i end]
-	match::yyparse
-	incr i [expr $match::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	frame -
-	frames {
-	    incr i
-	    MatchFrameCurrent [lindex $var $i]
-	}
-	crosshair -
-	crosshairs {
-	    incr i
-	    MatchCrosshairCurrent [lindex $var $i]
-	}
-	crop {
-	    incr i
-	    MatchCropCurrent [lindex $var $i]
-	}
-	slice -
-	cube -
-	datacube {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		switch -- [lindex $var $i] {
-		    {} {MatchCubeCurrent image}
-		    default {MatchCubeCurrent [lindex $var $i]}
-		}
-	    } else {
-		MatchCubeCurrent image
-		incr i -1
-	    }
-	}
-	bin {MatchBinCurrent}
-	axes -
-	order {MatchAxesCurrent}
-	scale -
-	scales {MatchScaleCurrent}
-	limits -
-	scalelimits {MatchScaleLimitsCurrent}
-	color -
-	colormap -
-	colorbar -
-	colorbars {MatchColorCurrent}
-	block {MatchBlockCurrent}
-	smooth {MatchSmoothCurrent}
-	3d {Match3DCurrent}
-    }
-}
+    match::YY_FLUSH_BUFFER
+    match::yy_scan_string [lrange $var $i end]
+    match::yyparse
+    incr i [expr $match::yycnt-1]
 }
diff --git a/ds9/library/grid.tcl b/ds9/library/grid.tcl
index 9816168..3333e84 100644
--- a/ds9/library/grid.tcl
+++ b/ds9/library/grid.tcl
@@ -1140,284 +1140,10 @@ proc ProcessGridCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	grid::YY_FLUSH_BUFFER
-	grid::yy_scan_string [lrange $var $i end]
-	grid::yyparse
-	incr i [expr $grid::yycnt-1]
-    } else {
-	
-    global grid
-    switch -- [string tolower [lindex $var $i]] {
-	open {GridDialog}
-	close {GridDestroyDialog}
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    set grid(view) [FromYesNo [lindex $var $i]]
-	    GridUpdateCurrent
-	}
-	type {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		axes {
-		    # backward compatible
-		    incr i; set grid(axes,type) [lindex $var $i]
-		}
-		numerics {
-		    # backward compatible
-		    incr i; set grid(numlab,type) [lindex $var $i]
-		}
-		default {set grid(type) [lindex $var $i]}
-	    }
-	    GridUpdateCurrent
-	}
-	system {incr i; set grid(system) [lindex $var $i]; GridUpdateCurrent}
-	sky {incr i
-	    set grid(sky) [string tolower [lindex $var $i]]
-	    GridUpdateCurrent
-	}
-	skyformat {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		deg -
-		degree -
-		degrees {set grid(skyformat) degrees}
-		default {set grid(skyformat) [string tolower [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	grid {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		color {incr i; set grid(grid,color) [lindex $var $i]}
-		width {incr i; set grid(grid,width) [lindex $var $i]}
-		dash {incr i; set grid(grid,style) [FromYesNo [lindex $var $i]]}
-		style {
-		    # backward compatibility
-		    incr i; set grid(grid,style) [lindex $var $i]
-		}
-		gap1 {incr i; set grid(grid,gap1) [lindex $var $i]}
-		gap2 {incr i; set grid(grid,gap2) [lindex $var $i]}
-		gap3 {incr i; set grid(grid,gap3) [lindex $var $i]}
-		default {set grid(grid) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	axes {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		color {incr i; set grid(axes,color) [lindex $var $i]}
-		width {incr i; set grid(axes,width) [lindex $var $i]}
-		dash {incr i; set grid(axes,style) [FromYesNo [lindex $var $i]]}
-		style {
-		    # backward compatibility
-		    incr i; set grid(axes,style) [lindex $var $i]
-		}
-		type {incr i; set grid(axes,type) [lindex $var $i]}
-		origin {incr i; set grid(axes,origin) [lindex $var $i]}
-		default {set grid(axes) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	format1 {
-	    incr i; set grid(format1) [lindex $var $i]
-	    GridUpdateCurrent
-	}
-	format2 {
-	    incr i; set grid(format2) [lindex $var $i]
-	    GridUpdateCurrent
-	}
-	tickmark -
-	tickmarks -
-	tick {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		color {incr i; set grid(tick,color) [lindex $var $i]}
-		width {incr i; set grid(tick,width) [lindex $var $i]}
-		dash {incr i; set grid(tick,style) [FromYesNo [lindex $var $i]]}
-		style {
-		    # backward compatibility
-		    incr i; set grid(tick,style) [lindex $var $i]
-		}
-		default {set grid(tick) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	border {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		color {incr i; set grid(border,color) [lindex $var $i]}
-		width {incr i; set grid(border,width) [lindex $var $i]}
-		dash {incr i; set grid(border,style) [FromYesNo [lindex $var $i]]}
-		style {
-		    # backward compatibility
-		    incr i; set grid(border,style) [lindex $var $i]
-		}
-		default {set grid(border) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	numeric -
-	numerics -
-	numlab {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		font {incr i; set grid(numlab,font) [lindex $var $i]}
-		fontsize {incr i; set grid(numlab,size) [lindex $var $i]}
-		fontweight {incr i; set grid(numlab,weight) [lindex $var $i]}
-		fontslant {incr i; set grid(numlab,slant) [lindex $var $i]}
-		fontstyle {
-		    # backward compatibility
-		    incr i
-		    switch [lindex $var $i] {
-			normal {
-			    set grid(numlab,weight) normal
-			    set grid(numlab,slant) roman
-			}
-			bold {
-			    set grid(numlab,weight) bold
-			    set grid(numlab,slant) roman
-			}
-			italic {
-			    set grid(numlab,weight) normal
-			    set grid(numlab,slant) italic
-			}
-		    }
-		}
-		color {incr i; set grid(numlab,color) [lindex $var $i]}
-		gap1 {incr i; set grid(numlab,gap1) [lindex $var $i]}
-		gap2 {incr i; set grid(numlab,gap2) [lindex $var $i]}
-		gap3 {incr i; set grid(numlab,gap3) [lindex $var $i]}
-		type {incr i; set grid(numlab,type) [lindex $var $i]}
-		vertical {incr i; set grid(numlab,vertical) [FromYesNo [lindex $var $i]]}
-		default {set grid(numlab) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	title {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		text {incr i; set grid(title,text) [lindex $var $i]}
-		def {incr i; set grid(title,def) [FromYesNo [lindex $var $i]]}
-		gap {incr i; set grid(title,gap) [lindex $var $i]}
-		font {incr i; set grid(title,font) [lindex $var $i]}
-		fontsize {incr i; set grid(title,size) [lindex $var $i]}
-		fontweight {incr i; set grid(title,weight) [lindex $var $i]}
-		fontslant {incr i; set grid(title,slant) [lindex $var $i]}
-		fontstyle {
-		    # backward compatibility
-		    incr i
-		    switch [lindex $var $i] {
-			normal {
-			    set grid(title,weight) normal
-			    set grid(title,slant) roman
-			}
-			bold {
-			    set grid(title,weight) bold
-			    set grid(title,slant) roman
-			}
-			italic {
-			    set grid(title,weight) normal
-			    set grid(title,slant) italic
-			}
-		    }
-		}
-		color {incr i; set grid(title,color) [lindex $var $i]}
-		default {set grid(title) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	label -
-	labels -
-	textlab {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		text1 {incr i; set grid(textlab,text1) [lindex $var $i]}
-		text2 {incr i; set grid(textlab,text2) [lindex $var $i]}
-		def1 {incr i; set grid(textlab,def1) [FromYesNo [lindex $var $i]]}
-		def2 {incr i; set grid(textlab,def2) [FromYesNo [lindex $var $i]]}
-		gap1 {incr i; set grid(textlab,gap1) [lindex $var $i]}
-		gap2 {incr i; set grid(textlab,gap2) [lindex $var $i]}
-		font {incr i; set grid(textlab,font) [lindex $var $i]}
-		fontsize {incr i; set grid(textlab,size) [lindex $var $i]}
-		fontweight {incr i; set grid(textlab,weight) [lindex $var $i]}
-		fontslant {incr i; set grid(textlab,slant) [lindex $var $i]}
-		fontstyle {
-		    # backward compatibility
-		    incr i
-		    switch [lindex $var $i] {
-			normal {
-			    set grid(textlab,weight) normal
-			    set grid(textlab,slant) roman
-			}
-			bold {
-			    set grid(textlab,weight) bold
-			    set grid(textlab,slant) roman
-			}
-			italic {
-			    set grid(textlab,weight) normal
-			    set grid(textlab,slant) italic
-			}
-		    }
-		}
-		color {incr i; set grid(textlab,color) [lindex $var $i]}
-		default {set grid(textlab) [FromYesNo [lindex $var $i]]}
-	    }
-	    GridUpdateCurrent
-	}
-	view {
-	    # backward compatable
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		grid {incr i; set grid(grid) [FromYesNo [lindex $var $i]]}
-		axes {
-		    incr i
-		    switch -- [string tolower [lindex $var $i]] {
-			numbers {incr i; set grid(numlab) \
-				     [FromYesNo [lindex $var $i]]}
-			tickmarks {incr i; set grid(tick) \
-				       [FromYesNo [lindex $var $i]]}
-			label {incr i; set grid(textlab) \
-				   [FromYesNo [lindex $var $i]]}
-			default {set grid(axes) [FromYesNo [lindex $var $i]]}
-		    }
-		}
-		title {incr i; set grid(title) [FromYesNo [lindex $var $i]]}
-		border {incr i; set grid(border) [FromYesNo [lindex $var $i]]}
-		vertical {
-		    incr i
-		    set grid(numlab,vertical) [FromYesNo [lindex $var $i]]
-		}
-	    }
-	    GridUpdateCurrent
-	}
-	reset {GridResetDialog}
-	load {
-	    incr i
-	    set fn [lindex $var $i]
-	    FileLast gridfbox $fn
-	    GridLoad $fn
-	}
-	save {
-	    incr i
-	    set fn [lindex $var $i]
-	    FileLast gridfbox $fn
-	    GridSave $fn
-	}
-	default {
-	    set grid(view) 1
-	    GridUpdateCurrent
-	    incr i -1
-	}
-    }
-}
+    grid::YY_FLUSH_BUFFER
+    grid::yy_scan_string [lrange $var $i end]
+    grid::yyparse
+    incr i [expr $grid::yycnt-1]
 }
 
 proc GridCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/header.tcl b/ds9/library/header.tcl
index 6762bea..ab15a77 100644
--- a/ds9/library/header.tcl
+++ b/ds9/library/header.tcl
@@ -64,22 +64,27 @@ proc DisplayHeaderMenu {} {
 	}
 
 	if {$slb(count) <= 1} {
-	    DisplayHeader $current(frame) 1 $fn
+	    DisplayHeader 1 $fn
 	} else {
 	    if {[SLBDialog slb {Select Header} 40]} {
-		DisplayHeader $current(frame) $slb(value) $slb(item)
+		DisplayHeader $slb(value) $slb(item)
 	    }
 	}
     }
 }
 
-proc DisplayHeader {frame id title} {
+proc DisplayHeader {id title} {
     global current
 
-    set varname "hd-$frame-$id"
+    set frame $current(frame)
+    set varname "hd-$current(frame)-$id"
     global $varname
-    SimpleTextDialog $varname $title 80 40 insert top \
-	[$current(frame) get fits header $id]
+
+    set hh {}
+    if {[$frame has fits]} {
+	set hh [$frame get fits header $id]
+    }
+    SimpleTextDialog $varname $title 80 40 insert top $hh
 
     # create a special text tag for keywords
     upvar #0 $varname var
@@ -143,65 +148,16 @@ proc ProcessHeaderCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	header::YY_FLUSH_BUFFER
-	header::yy_scan_string [lrange $var $i end]
-	header::yyparse
-	incr i [expr $header::yycnt-1]
-    } else {
-	
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	close -
-	save {incr i}
-    }
-
-    if {[lindex $var $i] != {} && [string is integer [lindex $var $i]]} {
-	set jj [lindex $var $i]
-	incr i
-    } else {
-	set jj 1
-    }
-
-    global current
-    if {$current(frame) != {}} {
-	switch -- $item {
-	    close {
-		set vvarname "hd[string range $current(frame) end end]-$jj"
-		upvar #0 $vvarname vvar
-		global $vvarname
-
-		if {[info exists vvar(top)]} {
-		    SimpleTextDestroy $vvarname
-		}
-		incr i -1
-	    }
-	    save {
-		set fn [lindex $var $i]
-		if {$fn != {}} {
-		    if {[catch {set ch [open "| cat > \"$fn\"" w]}]} {
-			Error [msgcat::mc {An error has occurred while saving}]
-			return
-		    }
-		    puts -nonewline $ch [$current(frame) get fits header $jj]
-		    close $ch
-		}
-	    }
-	    default {
-		catch {DisplayHeader $current(frame) $jj \
-			   [$current(frame) get fits file name $jj]}
-		incr i -1
-	    }
-	}
-    }
-}
+    header::YY_FLUSH_BUFFER
+    header::yy_scan_string [lrange $var $i end]
+    header::yyparse
+    incr i [expr $header::yycnt-1]
 }
 
 proc DisplayHeaderCmd {id} {
     global current
 
-    DisplayHeader $current(frame) $id [$current(frame) get fits file name $id]
+    DisplayHeader $id [$current(frame) get fits file name $id]
 }
 
 proc CloseHeaderCmd {id} {
diff --git a/ds9/library/hv.tcl b/ds9/library/hv.tcl
index a197300..c167a5d 100644
--- a/ds9/library/hv.tcl
+++ b/ds9/library/hv.tcl
@@ -825,100 +825,14 @@ proc ProcessWebCmd {varname iname} {
     upvar $iname i
     global ihv
 
-    global debug
-    if {$debug(tcl,parser)} {
-	set ref [lindex $ihv(windows) end]
-	global cvarname
-	set cvarname $ref
-
-	web::YY_FLUSH_BUFFER
-	web::yy_scan_string [lrange $var $i end]
-	web::yyparse
-	incr i [expr $web::yycnt-1]
-    } else {
-
-    set w {hvweb}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    set ii [lsearch $ihv(windows) $w]
-	    if {$ii>=0} {
-		append w $ihv(unique)
-		incr ihv(unique)
-	    }
-	}
-	close -
-	clear -
-	click {set w [lindex $ihv(windows) end]}
-
-	default {
-	    set ii [lsearch $ihv(windows) [lindex $var $i]]
-	    if {$ii>=0} {
-		set w [lindex $var $i]
-		incr i
-	    }
-	}
-    }
+    set ref [lindex $ihv(windows) end]
+    global cvarname
+    set cvarname $ref
 
-    switch -- [string tolower [lindex $var $i]] {
-	close {HVDestroy $w}
-	clear {HVClearCmd $w}
-	click {
-	    set vvarname $w
-	    upvar #0 $vvarname vvar
-	    global $vvarname
-
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		back {HVBackCmd $vvarname}
-		forward {HVForwardCmd $vvarname}
-		stop {HVStopCmd $vvarname}
-		reload {HVReloadCmd $vvarname}
-		default {
-		    set id [lindex $var $i]
-
-		    if {![info exists vvar(widget)]} {
-			return
-		    }
-
-		    set tokens [$vvar(widget) token list 1.0 end]
-		    set cnt 0
-		    for {set ii 0} {$ii<[llength $tokens]} {incr ii} {
-			set tok [lindex $tokens $ii]
-			if {[string tolower [lindex $tok 0]] == "markup" && 
-			    [string tolower [lindex $tok 2]] == "href"} {
-			    set url [lindex $tok 3]
-			    incr cnt
-			    if {$cnt == $id} {
-				HVResolveURL $vvarname [$vvar(widget) resolve $url]
-				break;
-			    }
-			}
-		    }
-		}
-	    }
-	}
-	default {
-	    set url [lindex $var $i]
-	    if {[string length $url] == 0} {
-		HV $w Web {} {} 1
-	    } else {
-		ParseURL $url r
-		switch -- $r(scheme) {
-		    {} {
-			# append 'http://' if needed
-			if {[string range $r(path) 0 0] == "/"} {
-			    set url "http:/$url"
-			} else {
-			    set url "http://$url"
-			}
-		    }
-		}
-		HV $w Web $url {} 1
-	    }
-	}
-    }
-}
+    web::YY_FLUSH_BUFFER
+    web::yy_scan_string [lrange $var $i end]
+    web::yyparse
+    incr i [expr $web::yycnt-1]
 }
 
 proc WebCmdCheck {} {
@@ -927,14 +841,13 @@ proc WebCmdCheck {} {
 
     if {![info exists cvar(top)]} {
 	Error "[msgcat::mc {Unable to find web window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
     if {![winfo exists $cvar(top)]} {
 	Error "[msgcat:: mc {Unable to find web window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
+    return 1
 }
 
 proc WebCmdRef {ref} {
@@ -944,11 +857,11 @@ proc WebCmdRef {ref} {
     # look for reference in current list
     if {[lsearch $ihv(windows) $ref] < 0} {
 	Error "[msgcat::mc {Unable to find web window}] $ref"
-	plot::YYABORT
-	return
+	return 0
     }
+
     set cvarname $ref
-    WebCmdCheck
+    return [WebCmdCheck]
 }
 
 proc WebCmdNew {url {ww {hvweb}}} {
diff --git a/ds9/library/iis.tcl b/ds9/library/iis.tcl
index 54b6ed6..1cda226 100644
--- a/ds9/library/iis.tcl
+++ b/ds9/library/iis.tcl
@@ -362,32 +362,10 @@ proc ProcessIISCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	iis::YY_FLUSH_BUFFER
-	iis::yy_scan_string [lrange $var $i end]
-	iis::yyparse
-	incr i [expr $iis::yycnt-1]
-    } else {
-
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	filename {
-	    if {[string is integer [lindex $var [expr $i+2]]]} {
-		if {$current(frame) != {}} {
-		    $current(frame) iis set file name \
-			[lindex $var [expr $i+1]] [lindex $var [expr $i+2]]
-		}
-		incr i 2
-	    } else {
-		if {$current(frame) != {}} {
-		    $current(frame) iis set file name [lindex $var [expr $i+1]]
-		}
-		incr i
-	    }
-	}
-    }
-}
+    iis::YY_FLUSH_BUFFER
+    iis::yy_scan_string [lrange $var $i end]
+    iis::yyparse
+    incr i [expr $iis::yycnt-1]
 }
 
 proc IISCmd {filename {which {}}} {
diff --git a/ds9/library/imgsvr.tcl b/ds9/library/imgsvr.tcl
index 2375731..6ebec9d 100644
--- a/ds9/library/imgsvr.tcl
+++ b/ds9/library/imgsvr.tcl
@@ -483,91 +483,6 @@ proc IMGSVRProgress {varname token totalsize currentsize} {
     }
 }
 
-proc IMGSVRProcessCmd {varname iname vvarname} {
-    upvar 2 $varname var
-    upvar 2 $iname i
-
-    upvar #0 $vvarname vvar
-
-    switch -- [string tolower [lindex $var $i]] {
-	{} {
-	    if {$vvar(name) != {} || ($vvar(x) != {} && $vvar(y) != {})} {
-		IMGSVRApply $vvarname 1
-	    }
-	}
-	open {}
-	close {ARDestroy $vvarname}
-	save {
-	    incr i
-	    set vvar(save) [FromYesNo [lindex $var $i]]
-	}
-	frame {
-	    incr i
-	    set vvar(mode) [string tolower [lindex $var $i]]
-	}
-	survey {
-	    incr i
-	    set vvar(survey) [lindex $var $i]
-	}
-	size {
-	    incr i
-	    set vvar(width) [lindex $var $i]
-	    incr i
-	    set vvar(height) [lindex $var $i]
-	    incr i
-	    if {[lindex $var $i] != {} && \
-		    [string range [lindex $var $i] 0 0] != {-}} {
-		set vvar(rformat) [lindex $var $i]
-		set vvar(rformat,msg) $vvar(rformat)
-	    } else {
-		incr i -1
-	    }
-	}
-	pixels {
-	    incr i
-	    set vvar(width,pixels) [lindex $var $i]
-	    incr i
-	    set vvar(height,pixels) [lindex $var $i]
-	}
-	update {
-	    incr i
-	    switch [string tolower [lindex $var $i]] {
-		frame {IMGSVRUpdate $vvarname}
-		crosshair {IMGSVRCrosshair $vvarname}
-	    }
-	    IMGSVRApply $vvarname 1
-	}
-	coord {
-	    incr i
-	    set vvar(x) [lindex $var $i]
-	    incr i
-	    set vvar(y) [lindex $var $i]
-	    incr i
-	    if {[lindex $var $i] != {} && \
-		    [string range [lindex $var $i] 0 0] != {-}} {
-		set vvar(skyformat) [lindex $var $i]
-		set vvar(skyformat,msg) $vvar(skyformat)
-	    } else {
-		incr i -1
-	    }
-	    IMGSVRApply $vvarname 1
-	}
-	name {
-	    incr i
-	    set vvar(name) [lindex $var $i]
-	    if {$vvar(name) != {}} {
-		IMGSVRApply $vvarname 1
-	    }
-	}
-	default {
-	    set vvar(name) [lindex $var $i]
-	    if {$vvar(name) != {}} {
-		IMGSVRApply $vvarname 1
-	    }
-	}
-    }
-}
-
 proc IMGSVRCmd {varname which value} {
     upvar #0 $varname var
     global $varname
diff --git a/ds9/library/layout.tcl b/ds9/library/layout.tcl
index f026b52..99661c7 100644
--- a/ds9/library/layout.tcl
+++ b/ds9/library/layout.tcl
@@ -827,18 +827,10 @@ proc ProcessHeightCmd {varname iname} {
     # can't use ProcessRealize
     RealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	height::YY_FLUSH_BUFFER
-	height::yy_scan_string [lrange $var $i end]
-	height::yyparse
-	incr i [expr $height::yycnt-1]
-    } else {
-
-    global canvas
-    set canvas(height) [lindex $var $i]
-    UpdateView
-}
+    height::YY_FLUSH_BUFFER
+    height::yy_scan_string [lrange $var $i end]
+    height::yyparse
+    incr i [expr $height::yycnt-1]
 }
 
 proc ProcessSendHeightCmd {proc id param} {
@@ -854,18 +846,10 @@ proc ProcessWidthCmd {varname iname} {
     # can't use ProcessRealize
     RealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	width::YY_FLUSH_BUFFER
-	width::yy_scan_string [lrange $var $i end]
-	width::yyparse
-	incr i [expr $width::yycnt-1]
-    } else {
-
-    global canvas
-    set canvas(width) [lindex $var $i]
-    UpdateView
-}
+    width::YY_FLUSH_BUFFER
+    width::yy_scan_string [lrange $var $i end]
+    width::yyparse
+    incr i [expr $width::yycnt-1]
 }
 
 proc ProcessSendWidthCmd {proc id param} {
@@ -877,180 +861,10 @@ proc ProcessViewCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	view::YY_FLUSH_BUFFER
-	view::yy_scan_string [lrange $var $i end]
-	view::yyparse
-	incr i [expr $view::yycnt-1]
-    } else {
-	
-    global view
-    global rgb
-
-    set item [string tolower [lindex $var $i]]
-
-    switch  -- $item {
-	layout {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    switch  -- $item {
-		horz -
-		horizontal {
-		    set view(layout) horizontal
-		    ViewHorzCmd
-		}
-		vert -
-		vertical {
-		    set view(layout) verical
-		    ViewVertCmd
-		}
-	    }
-	}
-	keyvalue {
-	    incr i
-	    set view(info,keyvalue) [lindex $var $i]
-	}
-	horz -
-	horizontal {
-	    # backward compatibility
-	    set view(layout) horizontal
-	    ViewHorzCmd
-	}
-	vert -
-	vertical {
-	    # backward compatibility
-	    set view(layout) vertical
-	    ViewVertCmd
-	}
-
-	default {
-	    set yesno [lindex $var [expr $i+1]]
-	    switch -- $yesno {
-		1 -
-		0 -
-		yes -
-		no -
-		on -
-		off -
-		true -
-		false {incr i}
-		default {
-		    set yesno 1
-		}
-	    }
-
-	    switch -- $item {
-		info -
-		panner - 
-		magnifier - 
-		buttons -
-		colorbar {set view($item) [FromYesNo $yesno]}
-
-		colorbarnumerics {
-		    # backward compatibility
-		    set colorbar(numerics) [FromYesNo $yesno]
-		}
-		graph {
-		    incr i
-		    set item [string tolower [lindex $var $i]]
-		    switch -- $item {
-			horz -
-			horizontal {
-			    set yesno [lindex $var [expr $i+1]]
-			    switch -- $yesno {
-				1 -
-				0 -
-				yes -
-				no -
-				on -
-				off -
-				true -
-				false {incr i}
-				default {
-				    set yesno 1
-				}
-			    }
-			    set view(graph,horz) [FromYesNo $yesno]
-			}
-			vert -
-			vertical {
-			    set yesno [lindex $var [expr $i+1]]
-			    switch -- $yesno {
-				1 -
-				0 -
-				yes -
-				no -
-				on -
-				off -
-				true -
-				false {incr i}
-				default {
-				    set yesno 1
-				}
-			    }
-			    set view(graph,vert) [FromYesNo $yesno]
-			}
-		    }
-		}
-		horzgraph {
-		    # backward compatibility
-		    set view(graph,horz) [FromYesNo $yesno]
-		}
-		vertgraph {
-		    # backward compatibility
-		    set view(graph,vert) [FromYesNo $yesno]
-		}
-
-		filename -
-		object -
-		keyword -
-		minmax -
-		lowhigh -
-		units -
-
-		detector -
-		amplifier -
-		physical -
-		image -
-		wcs -
-		wcsa -
-		wcsb -
-		wcsc -
-		wcsd -
-		wcse -
-		wcsf -
-		wcsg -
-		wcsh -
-		wcsi -
-		wcsj -
-		wcsk -
-		wcsl -
-		wcsm -
-		wcsn -
-		wcso -
-		wcsp -
-		wcsq -
-		wcsr -
-		wcss -
-		wcst -
-		wcsu -
-		wcsv -
-		wcsw -
-		wcsx -
-		wcsy -
-		wcsz -
-
-		frame {set view(info,$item) [FromYesNo $yesno]}
-
-		red -
-		green -
-		blue {set rgb($item) [FromYesNo $yesno]; RGBView}
-	    }
-	    UpdateView
-	}
-    }
-}
+    view::YY_FLUSH_BUFFER
+    view::yy_scan_string [lrange $var $i end]
+    view::yyparse
+    incr i [expr $view::yycnt-1]
 }
 
 proc ViewCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/load.tcl b/ds9/library/load.tcl
index cc10f10..dd49c0f 100644
--- a/ds9/library/load.tcl
+++ b/ds9/library/load.tcl
@@ -414,33 +414,10 @@ proc ProcessPreserveCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	preserve::YY_FLUSH_BUFFER
-	preserve::yy_scan_string [lrange $var $i end]
-	preserve::yyparse
-	incr i [expr $preserve::yycnt-1]
-    } else {
-
-    global ds9
-    global scale
-    global panzoom
-    global marker
-
-    switch -- [string tolower [lindex $var $i]] {
-	pan {
-	    incr i
-	    set panzoom(preserve) [FromYesNo [lindex $var $i]]
-	    PreservePan
-	}
-	marker -
-	regions {
-	    incr i
-	    set marker(preserve) [FromYesNo [lindex $var $i]]
-	    MarkerPreserve
-	}
-    }
-}
+    preserve::YY_FLUSH_BUFFER
+    preserve::yy_scan_string [lrange $var $i end]
+    preserve::yyparse
+    incr i [expr $preserve::yycnt-1]
 }
 
 proc ProcessSendPreserveCmd {proc id param} {
@@ -464,60 +441,10 @@ proc ProcessUpdateCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	update::YY_FLUSH_BUFFER
-	update::yy_scan_string [lrange $var $i end]
-	update::yyparse
-	incr i [expr $update::yycnt-1]
-    } else {
-
-    global current
-    global ds9
-
-    if {$current(frame) == {}} {
-	return
-    }
-
-    if {[lindex $var $i] != {} && [string range [lindex $var $i] 0 0] != {-}} {
-	switch -- [string tolower [lindex $var $i]] {
-	    on -
-	    yes -
-	    no -
-	    off {
-		# backward compatibility
-	    }
-
-	    now {
-		if {[string is integer [lindex $var [expr $i+1]]]} {
-		    $current(frame) update now \
-			[lindex $var [expr $i+1]] \
-			[lindex $var [expr $i+2]] [lindex $var [expr $i+3]] \
-			[lindex $var [expr $i+4]] [lindex $var [expr $i+5]]
-		    
-		    incr i 5
-		} else {
-		    $current(frame) update now
-		}
-	    }
-	    {} {
-		$current(frame) update
-		incr i -1
-	    }
-
-	    default {
-		$current(frame) update \
-		    [lindex $var $i] \
-		    [lindex $var [expr $i+1]] [lindex $var [expr $i+2]] \
-		    [lindex $var [expr $i+3]] [lindex $var [expr $i+4]]
-		incr i 4
-	    }
-	}
-    } else {
-	$current(frame) update
-	incr i -1
-    }
-}
+    update::YY_FLUSH_BUFFER
+    update::yy_scan_string [lrange $var $i end]
+    update::yyparse
+    incr i [expr $update::yycnt-1]
 }
 
 proc UpdateCmd {{which {}} {x1 {}} {y1 {}} {x2 {}} {y2 {}}} {
diff --git a/ds9/library/magnifier.tcl b/ds9/library/magnifier.tcl
index 25fa9ed..80379d8 100644
--- a/ds9/library/magnifier.tcl
+++ b/ds9/library/magnifier.tcl
@@ -140,46 +140,10 @@ proc ProcessMagnifierCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	magnifier::YY_FLUSH_BUFFER
-	magnifier::yy_scan_string [lrange $var $i end]
-	magnifier::yyparse
-	incr i [expr $magnifier::yycnt-1]
-    } else {
-
-    global pmagnifier
-    global view
-
-    switch -- [string tolower [lindex $var $i]] {
-	color {
-	    incr i
-	    set pmagnifier(color) [lindex $var $i]
-	    MagnifierColor
-	}
-	zoom {
-	    incr i
-	    set pmagnifier(zoom) [lindex $var $i]
-	    MagnifierZoom
-	}
-	cursor {
-	    incr i
-	    set pmagnifier(cursor) [FromYesNo [lindex $var $i]]
-	    MagnifierCursor
-	}
-	region {
-	    incr i
-	    set pmagnifier(region) [FromYesNo [lindex $var $i]]
-	    MagnifierRegion
-	}
-	default {
-	    # backward compatibility
-	    set view(magnifier) 1
-	    UpdateView
-	    incr i -1
-	}
-    }
-}
+    magnifier::YY_FLUSH_BUFFER
+    magnifier::yy_scan_string [lrange $var $i end]
+    magnifier::yyparse
+    incr i [expr $magnifier::yycnt-1]
 }
 
 proc PmagnifierCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/marker.tcl b/ds9/library/marker.tcl
index 5ecd893..d63aca6 100644
--- a/ds9/library/marker.tcl
+++ b/ds9/library/marker.tcl
@@ -1396,571 +1396,19 @@ proc ProcessRegionsCmd {varname iname sock fn} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	set marker(load,format) $marker(format)
-	set marker(load,system) $marker(system)
-	set marker(load,sky) $marker(sky)
-	set marker(tag) {}
-	
-	region::YY_FLUSH_BUFFER
-	region::yy_scan_string [lrange $var $i end]
-	region::yyparse
-	incr i [expr $region::yycnt-1]
-    } else {
-
-    global ds9
-    global current
-    global pmarker
-
-    switch -- [string tolower [lindex $var $i]] {
-	epsilon {
-	    incr i
-	    set pmarker(epsilon) [lindex $var $i]
-	    MarkerEpsilon
-	}
-	show {
-	    incr i
-	    set marker(show) [FromYesNo [lindex $var $i]]
-	    MarkerShow
-	}
-	showtext {
-	    incr i
-	    set marker(show,text) [FromYesNo [lindex $var $i]]
-	    MarkerShowText
-	}
-	getinfo {MarkerInfo}
-	centroid {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		auto {
-		    incr i
-		    set marker(centroid,auto) [FromYesNo [lindex $var $i]]
-		    MarkerCentroidAuto
-		}
-		radius {
-		    incr i
-		    set marker(centroid,radius) [lindex $var $i]
-		    MarkerCentroidRadius
-		}
-		iteration {
-		    incr i
-		    set marker(centroid,iteration) [lindex $var $i]
-		    MarkerCentroidIteration
-		}
-		default {
-		    incr i -1
-		    MarkerCentroid
-		}
-	    }
-	}
-	autocentroid {
-	    # backward compatibilty
-	    incr i
-	    set marker(centroid,auto) [FromYesNo [lindex $var $i]]
-	    MarkerCentroidAuto
-	}
-	movefront {MarkerFront}
-	moveback {MarkerBack}
-	move {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		front {MarkerFront}
-		back {MarkerBack}
-	    }
-	}
-
-	selectall {MarkerSelectAll}
-	selectnone {MarkerUnselectAll}
-	select {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		group {
-		    # backward compatibility, use group <> select
-		    incr i
-		    if {$current(frame) != {}} {
-			if {[$current(frame) has fits]} {
-			    $current(frame) marker "\{[lindex $var $i]\}" select
-			}
-		    }
-		}
-		all {MarkerSelectAll}
-		none {MarkerUnselectAll}
-		invert {MarkerSelectInvert}
-	    }
-	}
-
-	deleteall {MarkerDeleteAll}
-	delete {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		select {MarkerDeleteSelect}
-		all {MarkerDeleteAll}
-	    }
-	}
-
-	format {
-	    incr i
-	    set marker(format) [string tolower [lindex $var $i]]
-	}
-	coord -
-	system {
-	    # for backward compatibility
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		fk4 -
-		b1950 -
-		fk5 -
-		j2000 -
-		icrs -
-		galactic -
-		ecliptic {
-		    incr i
-		    set marker(system) wcs
-		    set marker(sky) [string tolower [lindex $var $i]]
-		}
-		
-		default {set marker(system) [string tolower [lindex $var $i]]}
-	    }
-	}
-	sky {
-	    incr i
-	    set marker(sky) [string tolower [lindex $var $i]]
-	}
-	coordformat -
-	skyformat {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		deg -
-		degree -
-		degrees {set marker(skyformat) degrees}
-		default {
-		    set marker(skyformat) [string tolower [lindex $var $i]]
-		}
-	    }
-	}
-	strip {
-	    incr i
-	    set marker(strip) [FromYesNo [lindex $var $i]]
-	}
-	delim {
-	    incr i
-	    if {[lindex $var $i] != "nl"} {
-		set marker(strip) 1
-	    } else {
-		set marker(strip) 0
-	    }
-	}
-	shape {
-	    incr i
-	    set marker(shape) [string tolower [lindex $var $i]]
-	}
-	color {
-	    incr i
-	    set marker(color) [string tolower [lindex $var $i]]
-	    MarkerColor
-	}
-	width {
-	    incr i
-	    set marker(width) [lindex $var $i]
-	    MarkerWidth
-	}
-
-	fixed {
-	    incr i
-	    set marker(fixed) [FromYesNo [lindex $var $i]]
-	    MarkerProp fixed
-	}
-	edit {
-	    incr i
-	    set marker(edit) [FromYesNo [lindex $var $i]]
-	    MarkerProp edit
-	}
-	rotate {
-	    incr i
-	    set marker(rotate) [FromYesNo [lindex $var $i]]
-	    MarkerProp rotate
-	}
-	delete {
-	    incr i
-	    set marker(delete) [FromYesNo [lindex $var $i]]
-	    MarkerProp delete
-	}
-	include {
-	    set marker(include) 1
-	    MarkerProp include
-	}
-	exclude {
-	    set marker(include) 0
-	    MarkerProp include
-	}
-	source {
-	    set marker(source) 1
-	    MarkerProp source
-	}
-	background {
-	    set marker(source) 0
-	    MarkerProp source
-	}
-
-	tag -
-	tags -
-	group -
-	groups {
-	    incr i
-
-	    if {[string tolower [lindex $var $i]] == {new}} {
-		if {$current(frame) != {}} {
-		    if {[$current(frame) has fits]} {
-			set name [$current(frame) get marker tag default name]
-			$current(frame) marker tag "\{$name\}"
-			UpdateGroupDialog
-		    }
-		}
-	    } else {
-		set tag "\{[lindex $var $i]\}"
-		incr i
-		switch -- [string tolower [lindex $var $i]] {
-		    new {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker tag $tag
-				UpdateGroupDialog
-			    }
-			}
-		    }
-		    update {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker tag update $tag
-				UpdateGroupDialog
-			    }
-			}
-		    }
-		    delete {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag delete
-				UpdateGroupDialog
-			    }
-			}
-		    }
-		    select {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag select
-			    }
-			}
-		    }
-		    color {
-			incr i
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag color \
-				    [string tolower [lindex $var $i]]
-			    }
-			}
-		    }
-		    copy {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag copy
-			    }
-			}
-		    }
-		    cut {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag cut
-			    }
-			}
-		    }
-		    font {
-			incr i
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag font \
-				    "\{[lindex $var $i]\}"
-			    }
-			}
-		    }
-		    move {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag move \
-				    [lindex $var [expr $i+1]] \
-				    [lindex $var [expr $i+2]]
-			    }
-			}
-			incr i 2
-		    }
-		    movefront {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag move front
-			    }
-			}
-		    }
-		    moveback {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag move back
-			    }
-			}
-		    }
-		    property {
-			if {$current(frame) != {}} {
-			    if {[$current(frame) has fits]} {
-				$current(frame) marker $tag property \
-				    [lindex $var [expr $i+1]] \
-				    [lindex $var [expr $i+2]]
-			    }
-			}
-			incr i 2
-		    }
-		}
-	    }
-	}
-
-	copy {MarkerCopy}
-	cut {MarkerCut}
-	paste {
-	    set marker(paste,system) [string tolower [lindex $var [expr $i+1]]] 
-	    switch -- $marker(paste,system) {
-		image -
-		physical -
-		detector -
-		amplifier -
-		wcs -
-		wcsa -
-		wcsb -
-		wcsc -
-		wcsd -
-		wcse -
-		wcsf -
-		wcsg -
-		wcsh -
-		wcsi -
-		wcsj -
-		wcsk -
-		wcsl -
-		wcsm -
-		wcsn -
-		wcso -
-		wcsp -
-		wcsq -
-		wcsr -
-		wcss -
-		wcst -
-		wcsu -
-		wcsv -
-		wcsw -
-		wcsx -
-		wcsy -
-		wcsz {}
-		default {set marker(paste,system) wcs}
-	    }		
-
-#	    backward compatibility
-	    if {[string range [lindex $var [expr $i+2]] 0 0] == {-}} {
-		incr i 1
-	    } else {
-		incr i 2
-	    }
-
-	    MarkerPaste
-	}
-	undo {MarkerUndo}
-
-	composite {CompositeCreate}
-	desolve -
-	dissove {CompositeDelete}
-
-	template {
-	    incr i
-	    set ff [lindex $var $i]
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		at {
-		    incr i
-		    set ra [lindex $var $i]
-		    incr i
-		    set dec [lindex $var $i]
-		    incr i
-		    set sys [string tolower [lindex $var $i]]
-		    incr i
-		    set sky [string tolower [lindex $var $i]]
-		    switch -- $sys {
-			fk4 -
-			fk5 -
-			icrs -
-			galatic -
-			ecliptic {
-			    set sky $sys
-			    set sys wcs
-			    incr i -1
-			}
-		    }
-		    LoadTemplateMarkerAt $ff $ra $dec $sys $sky
-		    FileLast templatefbox $ff
-		}
-		default {
-		    LoadTemplateMarker $ff
-		    FileLast templatefbox $ff
-		    incr i -1
-		}
-	    }
-	}
-	savetemplate {
-	    incr i
-	    set ff [lindex $var $i]
-	    if {$ff != {}} {
-		if {$current(frame) != {}} {
-		    if {[$current(frame) has fits]} {
-			$current(frame) marker save template "\{$ff\}"
-		    }
-		}
-		FileLast templatefbox $ff
-	    }
-	}
-
-	command {
-	    incr i
-	    if {$current(frame) != {}} {
-		if {[$current(frame) has fits]} {
-		    $current(frame) marker command $marker(format) \
-			"\{[lindex $var $i]\}"
-		}
-	    }
-	    UpdateGroupDialog
-	}
-
-	list {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		close {SimpleTextDestroy markertxt}
-		default {
-		    if {$current(frame) != {}} {
-			if {[$current(frame) has fits]} {
-			    SimpleTextDialog markertxt [msgcat::mc {Region}] \
-				80 20 insert top \
-				[$current(frame) marker list $marker(format) \
-				     $marker(system) $marker(sky) \
-				     $marker(skyformat) $marker(strip)]
-			}
-		    }
-		    incr i -1
-		}
-	    }
-	}
-	save {
-	    incr i
-	    set ff [lindex $var $i]
-	    if {$ff == {}} {
-		return
-	    }
-	    if {$current(frame) != {}} {
-		if {[$current(frame) has fits]} {
-		    $current(frame) marker save "\{$ff\}" \
-			$marker(format) $marker(system) $marker(sky) \
-			$marker(skyformat) $marker(strip)
-		}
-	    }
-	    FileLast markerfbox $ff
-	}
-
-	file -
-	load {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		all {
-		    incr i
-		    set frames $ds9(frames)
-		}
-		default {
-		    set frames $current(frame)
-		}
-	    }
-	    MarkerLoadFrames [lindex $var $i] $frames \
-		$marker(format) $marker(system) $marker(sky)
-	}
-	default {
-	    set format $marker(format)
-	    set sys $marker(system)
-	    set sky $marker(sky)
-
-	    while {[string range [lindex $var $i] 0 0] == "-"} {
-		switch -- [string tolower [lindex $var $i]] {
-		    -format {
-			incr i
-			set format [lindex $var $i]
-		    }
-		    -sys -
-		    -coord -
-		    -system {
-			incr i
-			# for backward compatibility
-			switch -- [lindex $var $i] {
-			    fk4 -
-			    fk5 -
-			    icrs -
-			    galactic -
-			    ecliptic {
-				set sys wcs
-				set sky [lindex $var $i]
-			    }
-			    default {
-				set sys [lindex $var $i]
-			    }
-			}
-		    }
-		    -sky {
-			incr i
-			set sky [lindex $var $i]
-		    }
-		    default {
-			Error "Illegal option: [lindex $var $i]"
-			return
-		    }
-		}
-		incr i
-	    }
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-	    if {$sock != {}} {
-		# xpa path
-		if {[lindex $var $i] != {}} {
-		    MarkerLoadFrames [lindex $var $i] $current(frame) \
-			$format $sys $sky
-		} else {
-		    # fits regions files not supported  
-		    if {$current(frame) != {}} {
-			if {[$current(frame) has fits]} {
-			    $current(frame) marker load $format $sock $sys $sky
-			}
-		    }
-		    UpdateGroupDialog
-		}
-	    } elseif {$fn != {}} {
-		# samp path
-		if {[lindex $var $i] != {}} {
-		    MarkerLoadFrames [lindex $var $i] $current(frame) \
-			$format $sys $sky
-		} else {
-		    MarkerLoadFrames $fn $current(frame) \
-			$format $sys $sky
-		}
-	    } else {
-		# this will open a fits regions file
-		MarkerLoadFrames [lindex $var $i] $current(frame) \
-		    $format $sys $sky
-	    }
-	}
-    }
-}
+    set marker(load,format) $marker(format)
+    set marker(load,system) $marker(system)
+    set marker(load,sky) $marker(sky)
+    set marker(tag) {}
+    
+    region::YY_FLUSH_BUFFER
+    region::yy_scan_string [lrange $var $i end]
+    region::yyparse
+    incr i [expr $region::yycnt-1]
 }
 
 proc MarkerCmdSet {which value {cmd {}}} {
@@ -1998,7 +1446,7 @@ proc RegionCmdLoad {} {
 	UpdateGroupDialog
     } elseif {$parse(fn) != {}} {
 	# samp path
-	MarkerLoadFrames $fn $current(frame) \
+	MarkerLoadFrames $parse(fn) $current(frame) \
 	    $marker(load,format) $marker(load,system) $marker(load,sky)
     }
 }
diff --git a/ds9/library/mask.tcl b/ds9/library/mask.tcl
index a6ba7d9..d5128d9 100644
--- a/ds9/library/mask.tcl
+++ b/ds9/library/mask.tcl
@@ -261,59 +261,15 @@ proc ProcessMaskCmd {varname iname} {
     upvar $iname i
 
     global mask
+    global parse
+    set parse(result) {}
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(result) {}
-
-	mask::YY_FLUSH_BUFFER
-	mask::yy_scan_string [lrange $var $i end]
-	mask::yyparse
-	incr i [expr $mask::yycnt-1]
-
-	return $parse(result)
-    } else {
-
-    set rr {}
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	open {MaskDialog}
-	close {MaskDestroyDialog}
-	color {
-	    incr i
-	    set mask(color) [lindex $var $i]
-	    if {$current(frame) != {}} {
-		$current(frame) mask color $mask(color)
-	    }
-	}
-	mark {
-	    incr i
-	    set mask(mark) [lindex $var $i]
-	    if {$current(frame) != {}} {
-		$current(frame) mask mark $mask(mark)
-	    }
-	}
-	transparency {
-	    incr i
-	    set mask(transparency) [lindex $var $i]
-	    if {$current(frame) != {}} {
-		$current(frame) mask transparency $mask(transparency)
-	    }
-	    MaskTransparency
-	}
-	clear {
-	    MaskClear
-	}
+    mask::YY_FLUSH_BUFFER
+    mask::yy_scan_string [lrange $var $i end]
+    mask::yyparse
+    incr i [expr $mask::yycnt-1]
 
-	default {
-	    set rr mask
-	    incr i -1
-	}
-    }
-
-    return $rr
-}
+    return $parse(result)
 }
 
 proc MaskCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/mecube.tcl b/ds9/library/mecube.tcl
index 426ca81..a052ab9 100644
--- a/ds9/library/mecube.tcl
+++ b/ds9/library/mecube.tcl
@@ -81,50 +81,14 @@ proc ProcessMECubeCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mecube::YY_FLUSH_BUFFER
-	mecube::yy_scan_string [lrange $var $i end]
-	mecube::yyparse
-	incr i [expr $mecube::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMECubeSocket $sock $param]} {
-	    InitError xpa
-	    LoadMECubeFile $param
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMECubeAlloc $fn $param
-	} else {
-	    LoadMECubeFile $param
-	}
-    }
-    FinishLoad
-}
+    mecube::YY_FLUSH_BUFFER
+    mecube::yy_scan_string [lrange $var $i end]
+    mecube::yyparse
+    incr i [expr $mecube::yycnt-1]
 }
 
 proc MECubeCmdLoad {param} {
diff --git a/ds9/library/mosaicimageiraf.tcl b/ds9/library/mosaicimageiraf.tcl
index f12db74..c6deea7 100644
--- a/ds9/library/mosaicimageiraf.tcl
+++ b/ds9/library/mosaicimageiraf.tcl
@@ -47,51 +47,14 @@ proc ProcessMosaicImageIRAFCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mosaicimageiraf::YY_FLUSH_BUFFER
-	mosaicimageiraf::yy_scan_string [lrange $var $i end]
-	mosaicimageiraf::yyparse
-	incr i [expr $mosaicimageiraf::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMosaicImageIRAFSocket $sock $param $layer]} {
-	    InitError xpa
-	    LoadMosaicImageIRAFFile $param $layer
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMosaicImageIRAFAlloc $fn $param $layer
-	} else {
-	    LoadMosaicImageIRAFFile $param $layer
-	}
-    }
-    FinishLoad
-}
+    mosaicimageiraf::YY_FLUSH_BUFFER
+    mosaicimageiraf::yy_scan_string [lrange $var $i end]
+    mosaicimageiraf::yyparse
+    incr i [expr $mosaicimageiraf::yycnt-1]
 }
 
 proc MosaicImageIRAFCmdLoad {param layer} {
diff --git a/ds9/library/mosaicimagewcs.tcl b/ds9/library/mosaicimagewcs.tcl
index e6b4a19..a543fa8 100644
--- a/ds9/library/mosaicimagewcs.tcl
+++ b/ds9/library/mosaicimagewcs.tcl
@@ -75,58 +75,14 @@ proc ProcessMosaicImageWCSCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mosaicimagewcs::YY_FLUSH_BUFFER
-	mosaicimagewcs::yy_scan_string [lrange $var $i end]
-	mosaicimagewcs::yyparse
-	incr i [expr $mosaicimagewcs::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    if {[string range [lindex $var $i] 0 2] == {wcs}} {
-	set opt [lindex $var $i]
-	incr i
-    } else {
-	set opt wcs
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMosaicImageWCSSocket $sock $param $layer $opt]} {
-	    InitError xpa
-	    LoadMosaicImageWCSFile $param $layer $opt
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMosaicImageWCSAlloc $fn $param $layer $opt
-	} else {
-	    LoadMosaicImageWCSFile $param $layer $opt
-	}
-    }
-    FinishLoad
-}
+    mosaicimagewcs::YY_FLUSH_BUFFER
+    mosaicimagewcs::yy_scan_string [lrange $var $i end]
+    mosaicimagewcs::yyparse
+    incr i [expr $mosaicimagewcs::yycnt-1]
 }
 
 proc MosaicImageWCSCmdLoad {param layer sys} {
diff --git a/ds9/library/mosaicimagewfpc2.tcl b/ds9/library/mosaicimagewfpc2.tcl
index ac59f98..fcedc97 100644
--- a/ds9/library/mosaicimagewfpc2.tcl
+++ b/ds9/library/mosaicimagewfpc2.tcl
@@ -53,50 +53,14 @@ proc ProcessMosaicImageWFPC2Cmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mosaicimagewfpc2::YY_FLUSH_BUFFER
-	mosaicimagewfpc2::yy_scan_string [lrange $var $i end]
-	mosaicimagewfpc2::yyparse
-	incr i [expr $mosaicimagewfpc2::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMosaicImageWFPC2Socket $sock $param]} {
-	    InitError xpa
-	    LoadMosaicImageWFPC2File $param
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMosaicImageWFPC2Alloc $fn $param
-	} else {
-	    LoadMosaicImageWFPC2File $param
-	}
-    }
-    FinishLoad
-}
+    mosaicimagewfpc2::YY_FLUSH_BUFFER
+    mosaicimagewfpc2::yy_scan_string [lrange $var $i end]
+    mosaicimagewfpc2::yyparse
+    incr i [expr $mosaicimagewfpc2::yycnt-1]
 }
 
 proc MosaicImageWFPC2CmdLoad {param} {
diff --git a/ds9/library/mosaiciraf.tcl b/ds9/library/mosaiciraf.tcl
index c2a3656..d091fad 100644
--- a/ds9/library/mosaiciraf.tcl
+++ b/ds9/library/mosaiciraf.tcl
@@ -47,51 +47,14 @@ proc ProcessMosaicIRAFCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mosaiciraf::YY_FLUSH_BUFFER
-	mosaiciraf::yy_scan_string [lrange $var $i end]
-	mosaiciraf::yyparse
-	incr i [expr $mosaiciraf::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMosaicIRAFSocket $sock $param $layer]} {
-	    InitError xpa
-	    LoadMosaicIRAFFile $param $layer
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMosaicIRAFAlloc $fn $param $layer
-	} else {
-	    LoadMosaicIRAFFile $param $layer
-	}
-    }
-    FinishLoad
-}
+    mosaiciraf::YY_FLUSH_BUFFER
+    mosaiciraf::yy_scan_string [lrange $var $i end]
+    mosaiciraf::yyparse
+    incr i [expr $mosaiciraf::yycnt-1]
 }
 
 proc MosaicIRAFCmdLoad {param layer} {
diff --git a/ds9/library/mosaicwcs.tcl b/ds9/library/mosaicwcs.tcl
index 65e16b0..d46b6dc 100644
--- a/ds9/library/mosaicwcs.tcl
+++ b/ds9/library/mosaicwcs.tcl
@@ -83,58 +83,14 @@ proc ProcessMosaicWCSCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	mosaicwcs::YY_FLUSH_BUFFER
-	mosaicwcs::yy_scan_string [lrange $var $i end]
-	mosaicwcs::yyparse
-	incr i [expr $mosaicwcs::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    if {[string range [lindex $var $i] 0 2] == {wcs}} {
-	set opt [lindex $var $i]
-	incr i
-    } else {
-	set opt wcs
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadMosaicWCSSocket $sock $param $layer $opt]} {
-	    InitError xpa
-	    LoadMosaicWCSFile $param $layer $opt
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMosaicWCSAlloc $fn $param $layer $opt
-	} else {
-	    LoadMosaicWCSFile $param $layer $opt
-	}
-    }
-    FinishLoad
-}
+    mosaicwcs::YY_FLUSH_BUFFER
+    mosaicwcs::yy_scan_string [lrange $var $i end]
+    mosaicwcs::yyparse
+    incr i [expr $mosaicwcs::yycnt-1]
 }
 
 proc MosaicWCSCmdLoad {param layer sys} {
diff --git a/ds9/library/movie.tcl b/ds9/library/movie.tcl
index a6d33c0..55d55e7 100644
--- a/ds9/library/movie.tcl
+++ b/ds9/library/movie.tcl
@@ -460,83 +460,10 @@ proc ProcessMovieCmd {varname iname} {
     # already implemented
     # ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	movie::YY_FLUSH_BUFFER
-	movie::yy_scan_string [lrange $var $i end]
-	movie::yyparse
-	incr i [expr $movie::yycnt-1]
-    } else {
-
-    global movie
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	slice -
-	frame -
-	3d {
-	    set movie(action) $item
-	    incr i
-	}
-	default {
-	    # backward compatibility
-	    set movie(action) frame
-	}
-    }
-
-    set fn [lindex $var $i]
-
-    set go 1
-    while {$go} {
-	incr i
-	set item [string tolower [lindex $var $i]]
-	switch -- $item {
-	    number {
-		incr i
-		set movie(num) [lindex $var $i]
-	    }
-	    azfrom {
-		incr i
-		set movie(az,from) [lindex $var $i]
-	    }
-	    azto {
-		incr i
-		set movie(az,to) [lindex $var $i]
-	    }
-	    elfrom {
-		incr i
-		set movie(el,from) [lindex $var $i]
-	    }
-	    elto {
-		incr i
-		set movie(el,to) [lindex $var $i]
-	    }
-	    slfrom {
-		incr i
-		set movie(sl,from) [lindex $var $i]
-	    }
-	    slto {
-		incr i
-		set movie(sl,to) [lindex $var $i]
-	    }
-	    oscillate {
-		incr i
-		set movie(repeat) oscillate
-		set movie(repeat,num) [lindex $var $i]
-	    }
-	    repeat {
-		incr i
-		set movie(repeat) repeat
-		set movie(repeat,num) [lindex $var $i]
-	    }
-	    default {
-		incr i -1
-		set go 0
-	    }
-	}
-    }
-
-    Movie $fn
-}
+    movie::YY_FLUSH_BUFFER
+    movie::yy_scan_string [lrange $var $i end]
+    movie::yyparse
+    incr i [expr $movie::yycnt-1]
 }
 
 proc MovieCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/multiframe.tcl b/ds9/library/multiframe.tcl
index cc5a9bc..9f2318c 100644
--- a/ds9/library/multiframe.tcl
+++ b/ds9/library/multiframe.tcl
@@ -136,58 +136,14 @@ proc ProcessMultiFrameCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	multiframe::YY_FLUSH_BUFFER
-	multiframe::yy_scan_string [lrange $var $i end]
-	multiframe::yyparse
-	incr i [expr $multiframe::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    # not supported
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	global tcl_platform
-	switch $tcl_platform(os) {
-	    Linux -
-	    Darwin -
-	    SunOS {
-		if {![LoadMultiFrameSocket $sock $param]} {
-		    InitError xpa
-		    LoadMultiFrameFile $param
-		}
-	    }
-	    {Windows NT} {LoadMultiFrameFile $param}
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadMultiFrameAlloc $fn $param
-	} else {
-	    LoadMultiFrameFile $param
-	}
-    }
-    FinishLoad
-}
+    multiframe::YY_FLUSH_BUFFER
+    multiframe::yy_scan_string [lrange $var $i end]
+    multiframe::yyparse
+    incr i [expr $multiframe::yycnt-1]
 }
 
 proc MultiframeCmdLoad {param} {
diff --git a/ds9/library/nameres.tcl b/ds9/library/nameres.tcl
index 8af9383..8acb236 100644
--- a/ds9/library/nameres.tcl
+++ b/ds9/library/nameres.tcl
@@ -186,61 +186,13 @@ proc ProcessNRESCmd {varname iname} {
 
     NRESDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global cvarname
-	set cvarname dnres
-
-	nres::YY_FLUSH_BUFFER
-	nres::yy_scan_string [lrange $var $i end]
-	nres::yyparse
-	incr i [expr $nres::yycnt-1]
-    } else {
-
-    set vvarname dnres
-    upvar #0 $vvarname vvar
-    global $vvarname
-
-    global nres
-    global pnres
+    global cvarname
+    set cvarname dnres
 
-    switch -- [string tolower [lindex $var $i]] {
-	{} -
-	open {}
-	close {ARDestroy $vvarname}
-	server {
-	    incr i
-	    set pnres(server) [lindex $var $i]
-	}
-	pan {NRESPan $vvarname}
-	crosshair {NRESCrosshair $vvarname}
-	format -
-	skyformat {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		deg -
-		degree -
-		degrees {
-		    set vvar(skyformat) degrees
-		    set vvar(skyformat,msg) $vvar(skyformat)
-		}
-		default {
-		    set vvar(skyformat) [string tolower [lindex $var $i]]
-		    set vvar(skyformat,msg) $vvar(skyformat)
-		}
-	    }
-	}
-	name {
-	    incr i
-	    set vvar(name) [lindex $var $i]
-	    NRESApply $vvarname 1
-	}
-	default {
-	    set vvar(name) [lindex $var $i]
-	    NRESApply $vvarname 1
-	}
-    }
-}
+    nres::YY_FLUSH_BUFFER
+    nres::yy_scan_string [lrange $var $i end]
+    nres::yyparse
+    incr i [expr $nres::yycnt-1]
 }
 
 proc NRESCmdSet {which value} {
diff --git a/ds9/library/nrrd.tcl b/ds9/library/nrrd.tcl
index 1193eb1..8307b53 100644
--- a/ds9/library/nrrd.tcl
+++ b/ds9/library/nrrd.tcl
@@ -84,51 +84,14 @@ proc ProcessNRRDCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	nrrd::YY_FLUSH_BUFFER
-	nrrd::yy_scan_string [lrange $var $i end]
-	nrrd::yyparse
-	incr i [expr $nrrd::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![ImportNRRDSocket $sock $param $layer]} {
-	    InitError xpa
-	    ImportNRRDFile $param $layer
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    ImportNRRDAlloc $fn $param $layer
-	} else {
-	    ImportNRRDFile $param $layer
-	}
-    }
-    FinishLoad
-}
+    nrrd::YY_FLUSH_BUFFER
+    nrrd::yy_scan_string [lrange $var $i end]
+    nrrd::yyparse
+    incr i [expr $nrrd::yycnt-1]
 }
 
 proc NRRDCmdLoad {param layer} {
diff --git a/ds9/library/nvss.tcl b/ds9/library/nvss.tcl
index ba2c019..8496cad 100644
--- a/ds9/library/nvss.tcl
+++ b/ds9/library/nvss.tcl
@@ -154,15 +154,10 @@ proc ProcessNVSSCmd {varname iname} {
 
     NVSSDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	nvss::YY_FLUSH_BUFFER
-	nvss::yy_scan_string [lrange $var $i end]
-	nvss::yyparse
-	incr i [expr $nvss::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dnvss
-    }
+    nvss::YY_FLUSH_BUFFER
+    nvss::yy_scan_string [lrange $var $i end]
+    nvss::yyparse
+    incr i [expr $nvss::yycnt-1]
 }
 
 proc ProcessSendNVSSCmd {proc id param} {
diff --git a/ds9/library/pagesetup.tcl b/ds9/library/pagesetup.tcl
index e88982a..3c03050 100644
--- a/ds9/library/pagesetup.tcl
+++ b/ds9/library/pagesetup.tcl
@@ -181,25 +181,10 @@ proc ProcessPSPageSetupCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	pagesetup::YY_FLUSH_BUFFER
-	pagesetup::yy_scan_string [lrange $var $i end]
-	pagesetup::yyparse
-	incr i [expr $pagesetup::yycnt-1]
-    } else {
-
-    global ps
-
-    switch -- [string tolower [lindex $var $i]] {
-	orientation -
-	orient {incr i; set ps(orient) [string tolower [lindex $var $i]]}
-	pagescale -
-	scale {incr i; set ps(scale) [lindex $var $i]}
-	pagesize -
-	size {incr i; set ps(size) [string tolower [lindex $var $i]] }
-    }
-}
+    pagesetup::YY_FLUSH_BUFFER
+    pagesetup::yy_scan_string [lrange $var $i end]
+    pagesetup::yyparse
+    incr i [expr $pagesetup::yycnt-1]
 }
 
 proc ProcessSendPSPageSetupCmd {proc id param} {
diff --git a/ds9/library/panzoom.tcl b/ds9/library/panzoom.tcl
index ae3de93..0c0fd67 100644
--- a/ds9/library/panzoom.tcl
+++ b/ds9/library/panzoom.tcl
@@ -693,41 +693,10 @@ proc ProcessPanCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	pan::YY_FLUSH_BUFFER
-	pan::yy_scan_string [lrange $var $i end]
-	pan::yyparse
-	incr i [expr $pan::yycnt-1]
-    } else {
-	
-    switch -- [string tolower [lindex $var $i]] {
-	open {PanZoomDialog}
-	close {PanZoomDestroyDialog}
-	to {
-	    set x [lindex $var [expr $i+1]]
-	    set y [lindex $var [expr $i+2]]
-	    set sys [lindex $var [expr $i+3]]
-	    set sky [lindex $var [expr $i+4]]
-	    set format {}
-
-	    incr i 2
-	    incr i [FixSpec sys sky format physical fk5 degrees]
-	    PanTo $x $y $sys $sky
-	}
-	default {
-	    set x [lindex $var [expr $i+0]]
-	    set y [lindex $var [expr $i+1]]
-	    set sys [lindex $var [expr $i+2]]
-	    set sky [lindex $var [expr $i+3]]
-	    set format {}
-
-	    incr i 1
-	    incr i [FixSpec sys sky format physical fk5 degrees]
-	    Pan $x $y $sys $sky
-	}
-    }
-}
+    pan::YY_FLUSH_BUFFER
+    pan::yy_scan_string [lrange $var $i end]
+    pan::yyparse
+    incr i [expr $pan::yycnt-1]
 }
 
 proc ProcessSendPanCmd {proc id param} {
@@ -750,52 +719,10 @@ proc ProcessZoomCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	zoom::YY_FLUSH_BUFFER
-	zoom::yy_scan_string [lrange $var $i end]
-	zoom::yyparse
-	incr i [expr $zoom::yycnt-1]
-    } else {
-	
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	open {PanZoomDialog}
-	close {PanZoomDestroyDialog}
-	in {Zoom 2 2}
-	out {Zoom .5 .5}
-	to {
-	    switch -- [string tolower [lindex $var [expr $i+1]]] {
-		fit {
-		    ZoomToFit
-		    incr i
-		}
-		default {
-		    set z1 [lindex $var [expr $i+1]]
-		    set z2 [lindex $var [expr $i+2]]
-		    if {[string is double $z2] && $z2 != {}} {
-			set current(zoom) "$z1 $z2"
-			incr i 2
-		    } else {
-			set current(zoom) "$z1 $z1"
-			incr i
-		    }
-		    ChangeZoom
-		}
-	    }
-	}
-	default {
-	    set z1 [lindex $var $i]
-	    set z2 [lindex $var [expr $i+1]]
-	    if {[string is double $z2] && $z2 != {}} {
-		Zoom $z1 $z2
-		incr i
-	    } else {
-		Zoom $z1 $z1
-	    }
-	}
-    }
-}
+    zoom::YY_FLUSH_BUFFER
+    zoom::yy_scan_string [lrange $var $i end]
+    zoom::yyparse
+    incr i [expr $zoom::yycnt-1]
 }
 
 proc ProcessSendZoomCmd {proc id param} {
@@ -817,24 +744,10 @@ proc ProcessOrientCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	orient::YY_FLUSH_BUFFER
-	orient::yy_scan_string [lrange $var $i end]
-	orient::yyparse
-	incr i [expr $orient::yycnt-1]
-    } else {
-
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	open {PanZoomDialog}
-	close {PanZoomDestroyDialog}
-	default {
-	    set current(orient) [string tolower [lindex $var $i]]
-	    ChangeOrient
-	}
-    }
-}
+    orient::YY_FLUSH_BUFFER
+    orient::yy_scan_string [lrange $var $i end]
+    orient::yyparse
+    incr i [expr $orient::yycnt-1]
 }
 
 proc ProcessSendOrientCmd {proc id param} {
@@ -849,26 +762,10 @@ proc ProcessRotateCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	rotate::YY_FLUSH_BUFFER
-	rotate::yy_scan_string [lrange $var $i end]
-	rotate::yyparse
-	incr i [expr $rotate::yycnt-1]
-    } else {
-
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	open {PanZoomDialog}
-	close {PanZoomDestroyDialog}
-	to {
-	    set current(rotate) [lindex $var [expr $i+1]]
-	    ChangeRotate
-	    incr i
-	}
-	default {Rotate [lindex $var $i]}
-    }
-}
+    rotate::YY_FLUSH_BUFFER
+    rotate::yy_scan_string [lrange $var $i end]
+    rotate::yyparse
+    incr i [expr $rotate::yycnt-1]
 }
 
 proc ProcessSendRotateCmd {proc id param} {
diff --git a/ds9/library/photo.tcl b/ds9/library/photo.tcl
index 0bdaaaf..dad5534 100644
--- a/ds9/library/photo.tcl
+++ b/ds9/library/photo.tcl
@@ -203,59 +203,14 @@ proc ProcessPhotoCmd {varname iname ch fn} {
     upvar 2 $varname var
     upvar 2 $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(ch) $ch
-	set parse(fn) $fn
-
-	photo::YY_FLUSH_BUFFER
-	photo::yy_scan_string [lrange $var $i end]
-	photo::yyparse
-	incr i [expr $photo::yycnt-1]
-    } else {
-
-    set mode {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    set mode slice
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(ch) $ch
+    set parse(fn) $fn
 
-    if {$ch != {}} {
-	# xpa
-	global tcl_platform
-	switch $tcl_platform(os) {
-	    Linux -
-	    Darwin -
-	    SunOS {
-		if {![ImportPhotoSocket $ch $param $mode]} {
-		    InitError xpa
-		    ImportPhotoFile $param $mode
-		}
-	    }
-	    {Windows NT} {ImportPhotoFile $param $mode}
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    ImportPhotoAlloc $fn $param $mode
-	} else {
-	    ImportPhotoFile $param $mode
-	}
-    }
-    FinishLoad
-}
+    photo::YY_FLUSH_BUFFER
+    photo::yy_scan_string [lrange $var $i end]
+    photo::yyparse
+    incr i [expr $photo::yycnt-1]
 }
 
 proc PhotoCmdLoad {param mode} {
diff --git a/ds9/library/pixel.tcl b/ds9/library/pixel.tcl
index 5445841..475b846 100644
--- a/ds9/library/pixel.tcl
+++ b/ds9/library/pixel.tcl
@@ -266,33 +266,10 @@ proc ProcessPixelTableCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	pixeltable::YY_FLUSH_BUFFER
-	pixeltable::yy_scan_string [lrange $var $i end]
-	pixeltable::yyparse
-	incr i [expr $pixeltable::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	open -
-	yes -
-	true -
-	on -
-	1 {PixelTableDialog}
-
-	close -
-	no -
-	false -
-	off -
-	0 {PixelTableDestroyDialog}
-
-	default {
-	    PixelTableDialog
-	    incr i -1
-	}
-    }
-}
+    pixeltable::YY_FLUSH_BUFFER
+    pixeltable::yy_scan_string [lrange $var $i end]
+    pixeltable::yyparse
+    incr i [expr $pixeltable::yycnt-1]
 }
 
 proc PixelTableCmd {which} {
diff --git a/ds9/library/plotprocess.tcl b/ds9/library/plotprocess.tcl
index c62f767..42d9c4d 100644
--- a/ds9/library/plotprocess.tcl
+++ b/ds9/library/plotprocess.tcl
@@ -104,446 +104,18 @@ proc ProcessPlotCmd {xarname iname buf fn} {
     upvar $iname i
     global iap
 
-    global debug
-    if {$debug(tcl,parser)} {
-	set ref [lindex $iap(windows) end]
-	global cvarname
-	set cvarname $ref
-	global parse
-	set parse(buf) $buf
-	set parse(fn) $fn
-	set parse(tt) $iap(tt)
-
-	plot::YY_FLUSH_BUFFER
-	plot::yy_scan_string [lrange $xar $i end]
-	plot::yyparse
-	incr i [expr $plot::yycnt-1]
-    } else {
-
-    set varname $iap(tt)
-    set id 0
-
-    # check for next command line option
-    if {[string range [lindex $xar $i] 0 0] != {-}} {
-
-	# determine which plot
-	switch -- [string tolower [lindex $xar $i]] {
-	    {} -
-	    bar -
-	    scatter -
-	    new {}
-
-	    data -
-	    load -
-	    save -
-	    clear -
-	    dup -
-	    duplicate -
-	    stats -
-	    statistics -
-	    list -
-	    loadconfig -
-	    saveconfig -
-	    page -
-	    pagesetup -
-	    print -
-	    close -
-
-	    mode -
-	    axis -
-	    legend -
-	    font -
-	    title -
-	    show -
-	    color -
-	    fill -
-	    fillcolor -
-	    error -
-	    errorbar -
-	    barmode -
-	    name -
-	    shape -
-	    relief -
-	    smooth -
-	    width -
-	    dash -
-	    dataset -
-	    select -
-
-	    graph -
-	    line -
-	    view {
-		set varname [lindex $iap(windows) end]
-		set id [lsearch $iap(windows) $varname]
-	    }
-
-	    default {
-		set varname [lindex $xar $i]
-		set id [lsearch $iap(windows) $varname]
-		incr i
-	    }
-	}
-    }
-
-    # we better have a tt by now
-    if {$id == -1} {
-	Error "[msgcat::mc {Unable to find plot window}] $varname"
-	return
-    }
-
-    upvar #0 $varname var
-    global $varname
-
-    # check for next command line option
-    if {[string range [lindex $xar $i] 0 0] != {-}} {
-
-	# now, process plot command
-	switch -- [string tolower [lindex $xar $i]] {
-	    {} -
-	    bar -
-	    scatter {
-		if {$buf != {}} {
-		    ProcessPlotNew $varname $xarname $iname $buf
-		} elseif {$fn != {}} {
-		    if {[file exists $fn]} {
-			set ch [open $fn r]
-			set txt [read $ch]
-			close $ch
-			ProcessPlotNew $varname $xarname $iname $txt
-		    }
-		} else {
-		    ProcessPlotNew $varname $xarname $iname {}
-		}
-	    }
-	    new {
-		incr i
-		switch -- [lindex $xar $i] {
-		    name {
-			set varname [lindex $xar [expr $i+1]]
-			incr i 2
-		    }
-		}
-		if {$buf != {}} {
-		    ProcessPlotNew $varname $xarname $iname $buf
-		} elseif {$fn != {}} {
-		    if {[file exists $fn]} {
-			set ch [open $fn r]
-			set txt [read $ch]
-			close $ch
-			ProcessPlotNew $varname $xarname $iname $txt
-		    }
-		} else {
-		    ProcessPlotNew $varname $xarname $iname {}
-		}
-	    }
-	    data {
-		incr i
-		if {$buf != {}} {
-		    ProcessPlotData $varname $xarname $iname $buf
-		} elseif {$fn != {}} {
-		    if {[file exists $fn]} {
-			set ch [open $fn r]
-			set txt [read $ch]
-			close $ch
-			ProcessPlotData $varname $xarname $iname $txt
-		    }
-		}
-	    }
-
-	    load {
-		# File Menu
-		set ff [lindex $xar [expr $i+1]]
-		set dim [lindex $xar [expr $i+2]]
-		incr i 2
-		PlotLoadDataFile $varname $ff $dim
-		FileLast apdatafbox $ff
-	    }
-	    save {
-		# File Menu
-		incr i
-		set ff [lindex $xar $i]
-		PlotSaveDataFile $varname $ff
-		FileLast apdatafbox $ff
-	    }
-	    clear {
-		# File Menu
-		PlotClearData $varname
-	    }
-	    dup -
-	    duplicate {
-		# File Menu
-		incr i
-		set mm [lindex $xar $i]
-		if {$mm == {}} {
-		    set mm 1
-		} elseif {![string is integer $mm]} {
-		    set mm 1
-		    incr i -1
-		}
-		PlotDupData $varname $mm
-	    }
-	    stats -
-	    statistics {
-		# File Menu
-		set var(stats) 1
-		PlotStats $varname
-	    }
-	    list {
-		# File Menu
-		set var(list) 1
-		PlotList $varname
-	    }
-	    loadconfig {
-		# File Menu
-		incr i
-		set ff [lindex $xar $i]
-		PlotLoadConfigFile $varname $ff
-		FileLast apconfigfbox $ff
-	    }
-	    saveconfig {
-		# File Menu
-		incr i
-		set ff [lindex $xar $i]
-		PlotSaveConfigFile $varname $ff
-		FileLast apconfigfbox $ff
-	    }
-	    page -
-	    pagesetup {
-		# File Menu
-		incr i
-		ProcessPlotPageSetup $varname $xarname $iname
-	    }
-	    print {
-		# File Menu
-		incr i
-		ProcessPlotPrint $varname $xarname $iname
-	    }
-	    close {
-		# File Menu
-		PlotDestroy $varname
-	    }
-
-	    mode {
-		# Edit Menu
-		incr i
-		set var(mode) [lindex $xar $i]
-		PlotChangeMode $varname
-	    }
-
-	    axis {
-		# Graph Menu
-		incr i
-		ProcessPlotAxis $varname $xarname $iname
-	    }
-	    legend {
-		# Graph Menu
-		incr i
-		ProcessPlotLegend $varname $xarname $iname
-	    }
-	    font {
-		# Graph Menu
-		incr i
-		ProcessPlotFont $varname $xarname $iname
-	    }
-	    title {
-		# Graph Menu
-		incr i
-		ProcessPlotTitle $varname $xarname $iname
-	    }
-	    barmode {
-		incr i
-		set var(bar,mode) [lindex $xar $i]
-		$var(proc,updategraph) $varname
-	    }
-
-	    show {
-		# Dataset Menu
-		incr i
-		set var(show) [FromYesNo [lindex $xar $i]]
-		$var(proc,updateelement) $varname
-	    }
-	    color {
-		incr i
-		ProcessPlotColor $varname $xarname $iname
-	    }
-	    fill {
-		incr i
-		set var(fill) [FromYesNo [lindex $xar $i]]
-		$var(proc,updateelement) $varname
-	    }
-	    fillcolor {
-		incr i
-		set var(fill,color) [lindex $xar $i]
-		$var(proc,updateelement) $varname
-	    }
-	    error -
-	    errorbar {
-		# Dataset Menu
-		incr i
-		ProcessPlotErrorBar $varname $xarname $iname
-	    }
-	    name {
-		# Dataset Menu
-		incr i
-		set var(name) [lindex $xar $i]
-		$var(proc,updateelement) $varname
-	    }
-	    shape {
-		# Dataset Line Menu
-		incr i
-		ProcessPlotShape $varname $xarname $iname
-	    }
-	    relief {
-		# Dataset Bar Menu
-		incr i
-		set var(bar,relief) [lindex $xar $i]
-		$var(proc,updateelement) $varname
-	    }
-	    smooth {
-		# Dataset Line Menu
-		incr i
-		set var(smooth) [lindex $xar $i]
-		$var(proc,updateelement) $varname
-	    }
-	    width {
-		# Dataset Line Menu
-		incr i
-		set var(width) [lindex $xar $i]
-		$var(proc,updateelement) $varname
-	    }
-	    dash {
-		# Dataset Line Menu
-		incr i
-		set var(dash) [FromYesNo [lindex $xar $i]]
-		$var(proc,updateelement) $varname
-	    }
-
-	    dataset -
-	    select {
-		# Select Menu
-		incr i
-		set var(data,current) [lindex $xar $i]
-		PlotCurrentData $varname
-	    }
-
-	    graph {
-		# backward compatibility
-		incr i
-		ProcessPlotGraph $varname $xarname $iname
-	    }
-	    line {
-		# backward compatibility
-		incr i
-		ProcessPlotLine $varname $xarname $iname
-	    }
-	    view {
-		# backward compatibility
-		incr i
-		ProcessPlotView $varname $xarname $iname
-	    }
-	}
-    } else {
-	ProcessPlotNew $varname $xarname $iname {}
-    }
-
-    # force update
-    update idletasks
-}
-}
-
-proc ProcessPlotNew {varname xarname iname buf} {
-    upvar #0 $varname var
-    global $varname
-
-    upvar 2 $xarname xar
-    upvar 2 $iname i
-
-    # check for next command line option
-    if {[string range [lindex $xar $i] 0 0] != {-}} {
-	switch -- [string tolower [lindex $xar $i]] {
-	    line {incr i; ProcessPlotNewOne line $varname $xarname $iname $buf}
-	    bar {incr i;ProcessPlotNewOne bar $varname $xarname $iname $buf}
-	    scatter {
-		incr i
-		ProcessPlotNewOne scatter $varname $xarname $iname $buf
-	    }
-	    default {ProcessPlotNewOne line $varname $xarname $iname $buf}
-	}
-    } else {
-	PlotLine $varname {} {} {} {} xy $buf
-	incr i -1
-    }
-}
-
-proc ProcessPlotNewOne {which varname xarname iname buf} {
-    upvar #0 $varname var
-    global $varname
-
-    upvar 3 $xarname xar
-    upvar 3 $iname i
-
-    if {[string range [lindex $xar $i] 0 0] != {-}} {
-	switch -- [string tolower [lindex $xar $i]] {
-	    stdin {incr i; AnalysisPlotStdin $which $varname {} $buf}
-	    {} {
-		switch $which {
-		    line {PlotLine $varname {} {} {} {} xy $buf}
-		    bar {PlotBar $varname {} {} {} {} xy $buf}
-		    scatter {PlotScatter $varname {} {} {} {} xy $buf}
-		}
-	    }
-	    default {
-		switch $which {
-		    line {
-			PlotLine $varname {} \
-			    [lindex $xar $i] \
-			    [lindex $xar [expr $i+1]] \
-			    [lindex $xar [expr $i+2]] \
-			    [lindex $xar [expr $i+3]] \
-			    $buf
-		    }
-		    bar {
-			PlotBar $varname {} \
-			    [lindex $xar $i] \
-			    [lindex $xar [expr $i+1]] \
-			    [lindex $xar [expr $i+2]] \
-			    [lindex $xar [expr $i+3]] \
-			    $buf
-		    }
-		    scatter {
-			PlotScatter $varname {} \
-			    [lindex $xar $i] \
-			    [lindex $xar [expr $i+1]] \
-			    [lindex $xar [expr $i+2]] \
-			    [lindex $xar [expr $i+3]] \
-			    $buf
-		    }
-		}
-		incr i 3
-	    }
-	}
-    } else {
-	switch $which {
-	    line {PlotLine $varname {} {} {} {} xy $buf}
-	    bar {PlotBar $varname {} {} {} {} xy $buf}
-	    scatter {PlotScatter $varname {} {} {} {} xy $buf}
-	}
-	incr i -1
-    }
-}
-
-proc ProcessPlotData {varname xarname iname buf} {
-    global $varname
-    upvar #0 $varname var
-
-    upvar 2 $xarname xar
-    upvar 2 $iname i
-
-    PlotRaise $varname
-    PlotDataSet $varname [lindex $xar $i] $buf
-    $var(proc,updategraph) $varname
-    PlotStats $varname
-    PlotList $varname
+    set ref [lindex $iap(windows) end]
+    global cvarname
+    set cvarname $ref
+    global parse
+    set parse(buf) $buf
+    set parse(fn) $fn
+    set parse(tt) $iap(tt)
+
+    plot::YY_FLUSH_BUFFER
+    plot::yy_scan_string [lrange $xar $i end]
+    plot::yyparse
+    incr i [expr $plot::yycnt-1]
 }
 
 proc PlotCmdCheck {} {
@@ -552,14 +124,13 @@ proc PlotCmdCheck {} {
 
     if {![info exists cvar(top)]} {
 	Error "[msgcat::mc {Unable to find plot window}] $cvarname"
-	plot::YYABORT
-	return
+	return 0
     }
     if {![winfo exists $cvar(top)]} {
 	Error "[msgcat::mc {Unable to find plot window}] $cvarname"
-	plot::YYABORT
-	return
+	return 0
     }
+    return 1
 }
 
 proc PlotCmdRef {ref} {
@@ -569,11 +140,11 @@ proc PlotCmdRef {ref} {
     # look for reference in current list
     if {[lsearch $iap(windows) $ref] < 0} {
 	Error "[msgcat::mc {Unable to find plot window}] $ref"
-	plot::YYABORT
-	return
+	return 0
     }
+
     set cvarname $ref
-    PlotCmdCheck
+    return [PlotCmdCheck]
 }
 
 proc PlotCmdNew {name} {
@@ -631,8 +202,6 @@ proc PlotCmdData {dim} {
 	}
 	if {$parse(buf) == {}} {
 	    Error "[msgcat::mc {Unable to load plot data}] $fn"
-	    plot::YYABORT
-	    return
 	}
     }
     
diff --git a/ds9/library/print.tcl b/ds9/library/print.tcl
index 5496cee..933dbf8 100644
--- a/ds9/library/print.tcl
+++ b/ds9/library/print.tcl
@@ -580,30 +580,10 @@ proc ProcessPSPrintCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	ps::YY_FLUSH_BUFFER
-	ps::yy_scan_string [lrange $var $i end]
-	ps::yyparse
-	incr i [expr $ps::yycnt-1]
-    } else {
-
-    global ps
-
-    switch -- [string tolower [lindex $var $i]] {
-	destination {incr i; set ps(dest) [lindex $var $i]}
-	command {incr i; set ps(cmd) [lindex $var $i]}
-	filename {incr i; set ps(filename) [lindex $var $i]}
-	palette -
-	color {incr i; set ps(color) [lindex $var $i]}
-	level {incr i; set ps(level) [lindex $var $i]}
-	interpolate {incr i}
-	resolution {incr i; set ps(resolution) [lindex $var $i]}
-
-	{} {PostScript}
-	default {incr i -1; PostScript}
-    }
-}
+    ps::YY_FLUSH_BUFFER
+    ps::yy_scan_string [lrange $var $i end]
+    ps::yyparse
+    incr i [expr $ps::yycnt-1]
 }
 
 proc PSCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/rgb.tcl b/ds9/library/rgb.tcl
index bb4cb40..b028384 100644
--- a/ds9/library/rgb.tcl
+++ b/ds9/library/rgb.tcl
@@ -264,79 +264,10 @@ proc ProcessRGBCmd {varname iname} {
 
     RGBDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	rgb::YY_FLUSH_BUFFER
-	rgb::yy_scan_string [lrange $var $i end]
-	rgb::yyparse
-	incr i [expr $rgb::yycnt-1]
-    } else {
-
-    global current
-    global rgb
-
-    switch -- [string tolower [lindex $var $i]] {
-	open {}
-	close {RGBDestroyDialog}
-	red -
-	green -
-	blue {
-	    set current(rgb) [string tolower [lindex $var $i]]
-	    RGBChannel
-	}
-	channel {
-	    incr i
-	    set current(rgb) [string tolower [lindex $var $i]]
-	    RGBChannel
-	}
-	lock {
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set rr [FromYesNo [lindex $var $i]]
-	    } else {
-		set rr 1
-		incr i -1
-	    }
-	    switch -- $item {
-		wcs {set rgb(lock,wcs) $rr}
-		crop {set rgb(lock,crop) $rr}
-		slice {set rgb(lock,slice) $rr}
-		bin {set rgb(lock,bin) $rr}
-		axes -
-		order {set rgb(lock,axes) $rr}
-		scale {set rgb(lock,scale) $rr}
-		limits -
-		scalelimits {set rgb(lock,scalelimits) $rr}
-		color -
-		colormap -
-		colorbar {set rgb(lock,colorbar) $rr}
-		block {set rgb(lock,block) $rr}
-		smooth {set rgb(lock,smooth) $rr}
-	    }
-	}
-	system {
-	    incr i
-	    set rgb(system) [string tolower [lindex $var $i]]
-	    RGBSystem
-	}
-	view {
-	    set w [lindex $var [expr $i+1]]
-	    set yesno [lindex $var [expr $i+2]]
-	    switch -- [string tolower $w] {
-		red {set rgb(red) [FromYesNo $yesno]; RGBView}
-		green {set rgb(green) [FromYesNo $yesno]; RGBView}
-		blue {set rgb(blue) [FromYesNo $yesno]; RGBView}
-	    }
-	    incr i 2
-	}
-	default {
-	    CreateRGBFrame
-	    incr i -1
-	}
-    }
-}
+    rgb::YY_FLUSH_BUFFER
+    rgb::yy_scan_string [lrange $var $i end]
+    rgb::yyparse
+    incr i [expr $rgb::yycnt-1]
 }
 
 proc RGBCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/rgbarray.tcl b/ds9/library/rgbarray.tcl
index aff77a0..74239df 100644
--- a/ds9/library/rgbarray.tcl
+++ b/ds9/library/rgbarray.tcl
@@ -127,50 +127,14 @@ proc ProcessRGBArrayCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	rgbarray::YY_FLUSH_BUFFER
-	rgbarray::yy_scan_string [lrange $var $i end]
-	rgbarray::yyparse
-	incr i [expr $rgbarray::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateRGBFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![ImportRGBArraySocket $sock $param]} {
-	    InitError xpa
-	    ImportRGBArrayFile $param
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    ImportRGBArrayAlloc $fn $param
-	} else {
-	    ImportRGBArrayFile $param
-	}
-    }
-    FinishLoad
-}
+    rgbarray::YY_FLUSH_BUFFER
+    rgbarray::yy_scan_string [lrange $var $i end]
+    rgbarray::yyparse
+    incr i [expr $rgbarray::yycnt-1]
 }
 
 proc RGBArrayCmdLoad {param} {
diff --git a/ds9/library/rgbcube.tcl b/ds9/library/rgbcube.tcl
index 94252ca..6bd3789 100644
--- a/ds9/library/rgbcube.tcl
+++ b/ds9/library/rgbcube.tcl
@@ -111,50 +111,14 @@ proc ProcessRGBCubeCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	rgbcube::YY_FLUSH_BUFFER
-	rgbcube::yy_scan_string [lrange $var $i end]
-	rgbcube::yyparse
-	incr i [expr $rgbcube::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateRGBFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadRGBCubeSocket $sock $param]} {
-	    InitError xpa
-	    LoadRGBCubeFile $param
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadRGBCubeAlloc $fn $param
-	} else {
-	    LoadRGBCubeFile $param
-	}
-    }
-    FinishLoad
-}
+    rgbcube::YY_FLUSH_BUFFER
+    rgbcube::yy_scan_string [lrange $var $i end]
+    rgbcube::yyparse
+    incr i [expr $rgbcube::yycnt-1]
 }
 
 proc RGBCubeCmdLoad {param} {
diff --git a/ds9/library/rgbimage.tcl b/ds9/library/rgbimage.tcl
index 58b1144..460b556 100644
--- a/ds9/library/rgbimage.tcl
+++ b/ds9/library/rgbimage.tcl
@@ -129,50 +129,14 @@ proc ProcessRGBImageCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	rgbimage::YY_FLUSH_BUFFER
-	rgbimage::yy_scan_string [lrange $var $i end]
-	rgbimage::yyparse
-	incr i [expr $rgbimage::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateRGBFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-    set param [lindex $var $i]
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-    if {$sock != {}} {
-	# xpa
-	if {![LoadRGBImageSocket $sock $param]} {
-	    InitError xpa
-	    LoadRGBImageFile $param
-	}
-    } else {
-	# comm
-	if {$fn != {}} {
-	    LoadRGBImageAlloc $fn $param
-	} else {
-	    LoadRGBImageFile $param
-	}
-    }
-    FinishLoad
-}
+    rgbimage::YY_FLUSH_BUFFER
+    rgbimage::yy_scan_string [lrange $var $i end]
+    rgbimage::yyparse
+    incr i [expr $rgbimage::yycnt-1]
 }
 
 proc RGBImageCmdLoad {param} {
diff --git a/ds9/library/samp.tcl b/ds9/library/samp.tcl
index 9af0e1d..d126c02 100644
--- a/ds9/library/samp.tcl
+++ b/ds9/library/samp.tcl
@@ -1707,95 +1707,12 @@ proc ProcessSAMPCmd {varname iname} {
 
     # we need to be realized
     ProcessRealizeDS9
-
     SAMPUpdate
 
-    global debug
-    if {$debug(tcl,parser)} {
-	samp::YY_FLUSH_BUFFER
-	samp::yy_scan_string [lrange $var $i end]
-	samp::yyparse
-	incr i [expr $samp::yycnt-1]
-    } else {
-
-    global samp
-    global ds9
-    global env
-    switch -- [string tolower [lindex $var $i]] {
-	send {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		image {
-		    incr i
-		    set name [string tolower [lindex $var $i]]
-		    if {[info exists samp]} {
-			foreach arg $samp(apps,image) {
-			    foreach {key val} $arg {
-				if {[string tolower $val] == $name} {
-				    SAMPSendImageLoadFits $key
-				    break
-				}
-			    }
-			}
-		    } else {
-			Error "SAMP: [msgcat::mc {not connected}]"
-		    }
-		}
-		table {
-		    incr i
-		    set name [string tolower [lindex $var $i]]
-		    if {[info exists samp]} {
-			foreach arg $samp(apps,table) {
-			    foreach {key val} $arg {
-				if {[string tolower $val] == $name} {
-				    SAMPSendTableLoadFits $key
-				    break
-				}
-			    }
-			}
-		    } else {
-			Error "SAMP: [msgcat::mc {not connected}]"
-		    }
-		}
-		default {
-		    set name [string tolower [lindex $var $i]]
-		    if {[info exists samp]} {
-			foreach arg $samp(apps,image) {
-			    foreach {key val} $arg {
-				if {[string tolower $val] == $name} {
-				    SAMPSendImageLoadFits $key
-				    break
-				}
-			    }
-			}
-		    } else {
-			Error "SAMP: [msgcat::mc {not connected}]"
-		    }
-		}
-	    }
-	}
-	broadcast {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		image {SAMPSendImageLoadFits {}}
-		table {SAMPSendTableLoadFits {}}
-		default {
-		    incr i -1
-		    SAMPSendImageLoadFits {}
-		}
-	    }
-	}
-	connect {SAMPConnect}
-	disconnect {SAMPDisconnect}
-	default {
-	    if {[FromYesNo [lindex $var $i]]} {
-		SAMPConnect
-	    } else {
-		SAMPDisconnect
-	    }
-	}
-    }
-}
+    samp::YY_FLUSH_BUFFER
+    samp::yy_scan_string [lrange $var $i end]
+    samp::yyparse
+    incr i [expr $samp::yycnt-1]
 }
 
 proc SAMPCmdSendImage {name} {
diff --git a/ds9/library/sao.tcl b/ds9/library/sao.tcl
index ebb79fe..4889df2 100644
--- a/ds9/library/sao.tcl
+++ b/ds9/library/sao.tcl
@@ -149,15 +149,10 @@ proc ProcessSAOCmd {varname iname} {
 
     SAODialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	dsssao::YY_FLUSH_BUFFER
-	dsssao::yy_scan_string [lrange $var $i end]
-	dsssao::yyparse
-	incr i [expr $dsssao::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dsao
-    }
+    dsssao::YY_FLUSH_BUFFER
+    dsssao::yy_scan_string [lrange $var $i end]
+    dsssao::yyparse
+    incr i [expr $dsssao::yycnt-1]
 }
 
 proc ProcessSendSAOCmd {proc id param} {
diff --git a/ds9/library/save.tcl b/ds9/library/save.tcl
index a3fdad7..97af246 100644
--- a/ds9/library/save.tcl
+++ b/ds9/library/save.tcl
@@ -43,92 +43,10 @@ proc ProcessSaveCmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	save::YY_FLUSH_BUFFER
-	save::yy_scan_string [lrange $var $i end]
-	save::yyparse
-	incr i [expr $save::yycnt-1]
-    } else {
-
-    set format {}
-    set fn [lindex $var $i]
-    if {$fn == {}} {
-	return
-    }
-
-    switch -- $fn {
-	fits -
-	sfits -
-	rgbimage -
-	rgbcube -
-	srgbcube -
-	mecube -
-	multiframe -
-	mosaicimagewcs -
-	mosaicimageiraf -
-	mosaicimagewfpc -
-	mosaicwcs -
-	mosaiciraf -
-	smosaicwcs -
-	smosaiciraf {
-	    set format $fn
-	    set fn {}
-	    incr i
-	}
-	mosaicimage -
-	mosaic {
-	    set format $fn
-	    set fn {}
-	    incr i
-
-	    # eat any wcs
-	    if {[string range [lindex $var $i] 0 2] == {wcs}} {
-		incr i
-	    }
-	}
-    }
-
-    # one last time
-    if {$fn == {}} {
-	set fn [lindex $var $i]
-	if {$fn == {}} {
-	    return
-	}
-    }
-
-    if {$format == {}} {
-	set format [ExtToFormat $fn]
-    }
-
-    global savefits
-    set param [string tolower [lindex $var [expr $i+1]]]
-    switch $format {
-	fits {
-	    switch $param {
-		slice -
-		image -
-		table {
-		    set savefits(type) $param
-		    incr i
-		}
-		default {set savefits(type) image}
-	    }
-	}
-	mosaic -
-	mosaiciraf -
-	mosaicwcs {
-	    if {[string is integer -strict $param]} {
-		set savefits(mosaic) $param
-		incr i
-	    }
-	}
-    }
-
-    global savefitsfbox
-    FileLast savefitsfbox $fn
-    Save $format $fn
-}
+    save::YY_FLUSH_BUFFER
+    save::yy_scan_string [lrange $var $i end]
+    save::yyparse
+    incr i [expr $save::yycnt-1]
 }
 
 proc SaveCmdLoad {format fn} {
diff --git a/ds9/library/saveimage.tcl b/ds9/library/saveimage.tcl
index 45ac769..4729deb 100644
--- a/ds9/library/saveimage.tcl
+++ b/ds9/library/saveimage.tcl
@@ -154,123 +154,10 @@ proc ProcessSaveImageCmd {varname iname} {
     UpdateDS9
     RealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	saveimage::YY_FLUSH_BUFFER
-	saveimage::yy_scan_string [lrange $var $i end]
-	saveimage::yyparse
-	incr i [expr $saveimage::yycnt-1]
-    } else {
-
-    set format {}
-    set param {}
-    set fn [lindex $var $i]
-    if {$fn == {}} {
-	return
-    }
-
-    # backward compatibility
-    switch $fn {
-	fits -
-	eps -
-	gif -
-	tiff -
-	jpeg -
-	png {
-	    set format $fn
-	    set fn {}
-	    incr i
-	}
-	jpg {
-	    set format jpeg
-	    set fn {}
-	    incr i
-	}
-	tif {
-	    set format tiff
-	    set fn {}
-	    incr i
-	}
-	mpeg {
-	    # backward compatibility
-	    global movie
-	    incr i
-	    set fn [lindex $var $i]
-	    if {[string is integer -strict $fn]} {
-		incr i
-		set fn [lindex $var $i]
-	    }
-	    set movie(action) slice
-	    Movie $fn
-	}
-    }
-
-    # try again
-    if {$fn == {}} {
-	set fn [lindex $var $i]
-	if {$fn == {}} {
-	    return
-	}
-
-	if {[string is integer -strict $fn] || 
-	    $fn == {none} || $fn == {jpeg} || 
-	    $fn == {backbits} || $fn == {deflate}} {
-	    set param $fn
-	    set fn {}
-	    incr i
-	}
-    }
-
-    # one last time
-    if {$fn == {}} {
-	set fn [lindex $var $i]
-	if {$fn == {}} {
-	    return
-	}
-    }
-
-    global saveimage
-    if {$format == {}} {
-	set format [ExtToFormat $fn]
-    }
-
-    if {$param == {}} {
-	set param [string tolower [lindex $var [expr $i+1]]]
-	switch $format {
-	    fits -
-	    eps -
-	    gif -
-	    png {}
-	    jpeg {
-		if {[string is integer -strict $param]} {
-		    set saveimage(jpeg,quality) $param
-		    incr i
-		}
-	    }
-	    tiff {
-		switch $param {
-		    none -
-		    jpeg -
-		    packbits -
-		    deflate {
-			set saveimage(tiff,compress) $param
-			incr i
-		    }
-		}
-	    }
-	}
-    }
-
-    switch -- $format {
-	fits {FileLast fitsfbox $fn}
-	eps {FileLast epsfbox $fn}
-	gif {FileLast giffbox $fn}
-	jpeg {FileLast jpegfbox $fn}
-	tiff {FileLast tifffbox $fn}
-	png {FileLast pngfbox $fn}
-    }
-    SaveImage $fn $format
-}
+    saveimage::YY_FLUSH_BUFFER
+    saveimage::yy_scan_string [lrange $var $i end]
+    saveimage::yyparse
+    incr i [expr $saveimage::yycnt-1]
 }
 
 proc SaveimageCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/scale.tcl b/ds9/library/scale.tcl
index 8fd0575..3555d47 100644
--- a/ds9/library/scale.tcl
+++ b/ds9/library/scale.tcl
@@ -827,118 +827,10 @@ proc ProcessScaleCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	scale::YY_FLUSH_BUFFER
-	scale::yy_scan_string [lrange $var $i end]
-	scale::yyparse
-	incr i [expr $scale::yycnt-1]
-    } else {
-
-    global scale
-    switch -- [string tolower [lindex $var $i]] {
-	match {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		limits -
-		scalelimits {
-		    MatchScaleLimitsCurrent
-		}
-		default {
-		    incr i -1
-		    MatchScaleCurrent
-		}
-	    }
-	}
-	lock {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		limits -
-		scalelimits {
-		    incr i
-		    if {!([string range [lindex $var $i] 0 0] == "-")} {
-			set scale(lock,limits) [FromYesNo [lindex $var $i]]
-		    } else {
-			set scale(lock,limits) 1
-			incr i -1
-		    }
-		    LockScaleLimitsCurrent
-		}
-		default {
-		    if {!([string range [lindex $var $i] 0 0] == "-")} {
-			set scale(lock) [FromYesNo [lindex $var $i]]
-		    } else {
-			set scale(lock) 1
-			incr i -1
-		    }
-		    LockScaleCurrent
-		}
-	    }
-	}
-	open {ScaleDialog}
-	close {ScaleDestroyDialog}
-	linear -
-	pow -
-	sqrt -
-	squared -
-	asinh -
-	sinh -
-	histequ {
-	    set scale(type) [string tolower [lindex $var $i]]
-	    ChangeScale
-	}
-	log {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		exp {
-		    incr i
-		    set scale(log) [string tolower [lindex $var $i]]
-		    ChangeScale
-		}
-		default {
-		    incr i -1
-		    set scale(type) [string tolower [lindex $var $i]]
-		    ChangeScale
-		}
-	    }
-	}
-	datasec {
-	    incr i
-	    set scale(datasec) [FromYesNo [lindex $var $i]]
-	    ChangeDATASEC
-	}
-	limits -
-	scalelimits {
-	    incr i
-	    set scale(min) [lindex $var $i]
-	    incr i
-	    set scale(max) [lindex $var $i]
-	    ChangeScaleLimit
-	}
-	minmax -
-	zscale -
-	zmax -
-	user {
-	    set scale(mode) [string tolower [lindex $var $i]]
-	    ChangeScaleMode
-	}
-	mode {
-	    incr i
-	    set scale(mode) [string tolower [lindex $var $i]]
-	    ChangeScaleMode
-	}
-	local -
-	global {
-	    set scale(scope) [string tolower [lindex $var $i]]
-	    ChangeScaleScope
-	}
-	scope {
-	    incr i
-	    set scale(scope) [string tolower [lindex $var $i]]
-	    ChangeScaleScope
-	}
-    }
-}
+    scale::YY_FLUSH_BUFFER
+    scale::yy_scan_string [lrange $var $i end]
+    scale::yyparse
+    incr i [expr $scale::yycnt-1]
 }
 
 proc ScaleCmdSet {which value {cmd {}}} {
@@ -976,47 +868,10 @@ proc ProcessMinMaxCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	minmax::YY_FLUSH_BUFFER
-	minmax::yy_scan_string [lrange $var $i end]
-	minmax::yyparse
-	incr i [expr $minmax::yycnt-1]
-    } else {
-
-    global minmax
-    global scale
-    switch -- [string tolower [lindex $var $i]] {
-	auto {
-	    # backward compatibility
-	    set minmax(mode) scan
-	    ChangeMinMax
-	}
-	scan -
-	sample -
-	datamin -
-	irafmin {
-	    set minmax(mode) [string tolower [lindex $var $i]]
-	    ChangeMinMax
-	}
-	mode {
-	    incr i
-	    set minmax(mode) [string tolower [lindex $var $i]]
-	    ChangeMinMax
-	}
-	interval {
-	    incr i
-	    set minmax(sample) [lindex $var $i]
-	    ChangeMinMax
-	}
-	default {
-	    # for backward compatibility
-	    set scale(mode) minmax
-	    ChangeScaleMode
-	    incr i -1
-	}
-    }
-}
+    minmax::YY_FLUSH_BUFFER
+    minmax::yy_scan_string [lrange $var $i end]
+    minmax::yyparse
+    incr i [expr $minmax::yycnt-1]
 }
 
 proc MinmaxCmdSet {which value {cmd {}}} {
@@ -1045,41 +900,10 @@ proc ProcessZScaleCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	zscale::YY_FLUSH_BUFFER
-	zscale::yy_scan_string [lrange $var $i end]
-	zscale::yyparse
-	incr i [expr $zscale::yycnt-1]
-    } else {
-
-    global zscale
-    global scale
-
-    switch -- [string tolower [lindex $var $i]] {
-	contrast {
-	    incr i
-	    set zscale(contrast) [lindex $var $i]
-	    ChangeZScale
-	}
-	sample {
-	    incr i
-	    set zscale(sample) [lindex $var $i]
-	    ChangeZScale
-	}
-	line {
-	    incr i
-	    set zscale(line) [lindex $var $i]
-	    ChangeZScale
-	}
-	default {
-	    # for backward compatibility
-	    set scale(mode) zscale
-	    ChangeScaleMode
-	    incr i -1
-	}
-    }
-}
+    zscale::YY_FLUSH_BUFFER
+    zscale::yy_scan_string [lrange $var $i end]
+    zscale::yyparse
+    incr i [expr $zscale::yycnt-1]
 }
 
 proc ZscaleCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/sfits.tcl b/ds9/library/sfits.tcl
index d2cfdca..753706e 100644
--- a/ds9/library/sfits.tcl
+++ b/ds9/library/sfits.tcl
@@ -21,48 +21,8 @@ proc ProcessSFitsCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	sfits::YY_FLUSH_BUFFER
-	sfits::yy_scan_string [lrange $var $i end]
-	sfits::yyparse
-	incr i [expr $sfits::yycnt-1]
-    } else {
-
-    set layer {}
-    set mode {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    set mode slice
-	}
-    }
-
-    if {$sock != {}} {
-	# xpa
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSFitsFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer $mode
-	}
-    } else {
-	# comm
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSFitsFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer $mode
-	}
-    }
-    FinishLoad
-}
+    sfits::YY_FLUSH_BUFFER
+    sfits::yy_scan_string [lrange $var $i end]
+    sfits::yyparse
+    incr i [expr $sfits::yycnt-1]
 }
diff --git a/ds9/library/shm.tcl b/ds9/library/shm.tcl
index 7bf5249..d67002d 100644
--- a/ds9/library/shm.tcl
+++ b/ds9/library/shm.tcl
@@ -7,246 +7,14 @@ package provide DS9 1.0
 proc ProcessShmCmd {varname iname ml} {
     upvar $varname var
     upvar $iname i
-    global loadParam
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(ml) $ml
+    global parse
+    set parse(ml) $ml
 
-	shm::YY_FLUSH_BUFFER
-	shm::yy_scan_string [lrange $var $i end]
-	shm::yyparse
-	incr i [expr $shm::yycnt-1]
-    } else {
-
-    set done 0
-    while {!$done} {
-
-	# defaults
-	set loadParam(load,type) shared
-	set loadParam(file,type) fits
-	set loadParam(file,mode) {}
-
-	# mask not supported
-	set loadParam(load,layer) {}
-
-	set nn [lindex $var [expr $i+4]]
-	if {$nn == {} || [string range $nn 0 0] == "-"} {
-	    set def 1
-	} else {
-	    set def 0
-	}
-
-	switch -- [lindex $var $i] {
-	    key -
-	    shmid {
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(shared,idtype) [lindex $var $i]
-		set loadParam(shared,id) [lindex $var [expr $i+1]]
-		set loadParam(file,name) [lindex $var [expr $i+2]]
-		incr i 2
-	    }
-
-	    fits {
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    sfits {
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(load,type) sshared
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,hdr) [lindex $var [expr $i+2]]
-		set loadParam(shared,id) [lindex $var [expr $i+3]]
-		set loadParam(file,name) [lindex $var [expr $i+4]]
-		incr i 4
-	    }
-
-	    mosaicimage {
-		if {$ml} {
-		    MultiLoad
-		}
-		if {$def} {
-		    set loadParam(file,mode) {mosaic image iraf}
-		    set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		    set loadParam(shared,id) [lindex $var [expr $i+2]]
-		    set loadParam(file,name) [lindex $var [expr $i+3]]
-		    incr i 3
-		} else {
-		    set loadParam(file,mode) \
-			[list mosaic image [lindex $var [expr $i+1]]]
-		    set loadParam(shared,idtype) [lindex $var [expr $i+2]]
-		    set loadParam(shared,id) [lindex $var [expr $i+3]]
-		    set loadParam(file,name) [lindex $var [expr $i+4]]
-		    incr i 4
-		}
-	    }
-	    mosaic {
-		if {$def} {
-		    set loadParam(file,mode) {mosaic iraf}
-		    set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		    set loadParam(shared,id) [lindex $var [expr $i+2]]
-		    set loadParam(file,name) [lindex $var [expr $i+3]]
-		    incr i 3
-		} else {
-		    set loadParam(file,mode) \
-			[list mosaic [lindex $var [expr $i+1]]]
-		    set loadParam(shared,idtype) [lindex $var [expr $i+2]]
-		    set loadParam(shared,id) [lindex $var [expr $i+3]]
-		    set loadParam(file,name) [lindex $var [expr $i+4]]
-		    incr i 4
-		}
-	    }
-	    smosaic {
-		set loadParam(load,type) sshared
-		set loadParam(file,mode) \
-		    [list mosaic [lindex $var [expr $i+1]]]
-		set loadParam(shared,idtype) [lindex $var [expr $i+2]]
-		set loadParam(shared,hdr) [lindex $var [expr $i+3]]
-		set loadParam(shared,id) [lindex $var [expr $i+4]]
-		set loadParam(file,name) [lindex $var [expr $i+5]]
-		incr i 5
-	    }
-
-	    mosaicimageiraf {
-		# backward compatibility
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(file,mode) {mosaic image iraf}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    mosaiciraf {
-		# backward compatibility
-		set loadParam(file,mode) {mosaic iraf}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    mosaicimagewcs {
-		# backward compatibility
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(file,mode) {mosaic image wcs}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    mosaicwcs {
-		# backward compatibility
-		set loadParam(file,mode) {mosaic wcs}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    mosaicimagewfpc2 {
-		# backward compatibility
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(file,mode) {mosaic image wfpc2}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-
-	    rgbcube {
-		if {$ml} {
-		    MultiLoadRGB
-		}
-		set loadParam(file,mode) {rgb cube}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    srgbcube {
-		if {$ml} {
-		    MultiLoadRGB
-		}
-		set loadParam(load,type) sshared
-		set loadParam(file,mode) {rgb cube}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,hdr) [lindex $var [expr $i+2]]
-		set loadParam(shared,id) [lindex $var [expr $i+3]]
-		set loadParam(file,name) [lindex $var [expr $i+4]]
-		incr i 4
-	    }
-	    rgbimage {
-		if {$ml} {
-		    MultiLoadRGB
-		}
-		set loadParam(file,mode) {rgb image}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    rgbarray {
-		if {$ml} {
-		    MultiLoadRGB
-		}
-		set loadParam(file,type) array
-		set loadParam(file,mode) {rgb cube}
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-	    array {
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(file,type) array
-		set loadParam(shared,idtype) [lindex $var [expr $i+1]]
-		set loadParam(shared,id) [lindex $var [expr $i+2]]
-		set loadParam(file,name) [lindex $var [expr $i+3]]
-		incr i 3
-	    }
-
-	    default {
-		if {$ml} {
-		    MultiLoad
-		}
-		set loadParam(shared,idtype) key
-		set loadParam(shared,id) [lindex $var $i]
-		set loadParam(file,name) [lindex $var [expr $i+1]]
-		incr i 1
-	    }
-	}
-
-	ProcessLoad
-
-	# more to come?
-	incr i
-	if {([lindex $var $i] == "-shm") || 
-	    ([lindex $var $i] == "shm")} {
-	    set done 0
-	    incr i
-	} else {
-	    set done 1
-	    incr i -1
-	}
-    }
-    FinishLoad
-}
+    shm::YY_FLUSH_BUFFER
+    shm::yy_scan_string [lrange $var $i end]
+    shm::yyparse
+    incr i [expr $shm::yycnt-1]
 }
 
 proc ShmCmdSet {loadtype filetype filemode sharedidtype sharedid filename {sharedhdr {}}} {
diff --git a/ds9/library/sia.tcl b/ds9/library/sia.tcl
index 33f8570..5f0c8de 100644
--- a/ds9/library/sia.tcl
+++ b/ds9/library/sia.tcl
@@ -367,84 +367,14 @@ proc ProcessSIACmd {varname iname} {
     # we need to be realized
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	set ref [lindex $isia(sias) end]
-	global cvarname
-	set cvarname $ref
-
-	sia::YY_FLUSH_BUFFER
-	sia::yy_scan_string [lrange $var $i end]
-	sia::yyparse
-	incr i [expr $sia::yycnt-1]
-    } else {
-
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	cancel -
-	clear -
-	close -
-	coordinate -
-	crosshair -
-	export -
-	name -
-	print -
-	retreive -
-	retrieve -
-	save -
-	size -
-	sky -
-	skyformat -
-	system -
-	update {ProcessSIA $varname $iname [lindex $isia(sias) end]}
-
-	default {
-	    # existing sia or load new one?
-	    set ref $item
+    set ref [lindex $isia(sias) end]
+    global cvarname
+    set cvarname $ref
 
-	    incr i
-	    set item [string tolower [lindex $var $i]]
-	    switch -- $item {
-		cancel -
-		clear -
-		close -
-		coordinate -
-		crosshair -
-		export -
-		name -
-		print -
-		retreive -
-		retrieve -
-		save -
-		size -
-		sky -
-		skyformat -
-		system -
-		update {ProcessSIA $varname $iname sia${ref}}
-
-		default {
-		    # ok, new sia
-		    incr i -1
-		    set item [string tolower [lindex $var $i]]
-
-		    # see if its from our list of sias
-		    foreach mm $isia(def) {
-			set title [lindex $mm 0]
-			set vars [lindex $mm 1]
-			set url [lindex $mm 2]
-			set opts [lindex $mm 3]
-			set method [lindex $mm 4]
-
-			if {$title != {-} && "sia${item}" == $vars} {
-			    SIADialog $vars $title $url $opts $method sync
-			    return
-			}
-		    }
-		}
-	    }
-	}
-    }
-}
+    sia::YY_FLUSH_BUFFER
+    sia::yy_scan_string [lrange $var $i end]
+    sia::yyparse
+    incr i [expr $sia::yycnt-1]
 }
 
 proc ProcessSIA {varname iname cvarname} {
@@ -542,14 +472,13 @@ proc SIACmdCheck {} {
 
     if {![info exists cvar(top)]} {
 	Error "[msgcat::mc {Unable to find SIAP window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
     if {![winfo exists $cvar(top)]} {
 	Error "[msgcat:: mc {Unable to find SIAP window}] $cvarname"
-	cat::YYABORT
-	return
+	return 0
     }
+    return 1
 }
 
 proc SIACmdRef {ref} {
diff --git a/ds9/library/skyview.tcl b/ds9/library/skyview.tcl
index ecfe17c..81ac65f 100644
--- a/ds9/library/skyview.tcl
+++ b/ds9/library/skyview.tcl
@@ -610,15 +610,10 @@ proc ProcessSkyViewCmd {varname iname} {
 
     SkyViewDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	skyview::YY_FLUSH_BUFFER
-	skyview::yy_scan_string [lrange $var $i end]
-	skyview::yyparse
-	incr i [expr $skyview::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dskyview
-    }
+    skyview::YY_FLUSH_BUFFER
+    skyview::yy_scan_string [lrange $var $i end]
+    skyview::yyparse
+    incr i [expr $skyview::yycnt-1]
 }
 
 proc ProcessSendSkyViewCmd {proc id param} {
diff --git a/ds9/library/smooth.tcl b/ds9/library/smooth.tcl
index a5fd735..24e9ed9 100644
--- a/ds9/library/smooth.tcl
+++ b/ds9/library/smooth.tcl
@@ -345,79 +345,10 @@ proc ProcessSmoothCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	smooth::YY_FLUSH_BUFFER
-	smooth::yy_scan_string [lrange $var $i end]
-	smooth::yyparse
-	incr i [expr $smooth::yycnt-1]
-    } else {
-
-    global smooth
-
-    switch -- [string tolower [lindex $var $i]] {
-	open {SmoothDialog}
-	close {SmoothDestroyDialog}
-	match {MatchSmoothCurrent}
-	lock {
-	    incr i
-	    if {!([string range [lindex $var $i] 0 0] == "-")} {
-		set smooth(lock) [FromYesNo [lindex $var $i]]
-	    } else {
-		set smooth(lock) 1
-		incr i -1
-	    }
-	    LockSmoothCurrent
-	}
-	function {
-	    incr i
-	    set smooth(function) [lindex $var $i]
-	    SmoothUpdate
-	}
-	radius {
-	    incr i
-	    set smooth(radius) [lindex $var $i]
-	    SmoothUpdate
-	}
-	radiusminor {
-	    incr i
-	    set smooth(radius,minor) [lindex $var $i]
-	    SmoothUpdate
-	}
-	sigma {
-	    incr i
-	    set smooth(sigma) [lindex $var $i]
-	    SmoothUpdate
-	}
-	sigmaminor {
-	    incr i
-	    set smooth(sigma,minor) [lindex $var $i]
-	    SmoothUpdate
-	}
-	angle {
-	    incr i
-	    set smooth(angle) [lindex $var $i]
-	    SmoothUpdate
-	}
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    set smooth(view) [FromYesNo [lindex $var $i]]
-	    SmoothUpdate
-	}
-
-	default {
-	    set smooth(view) 1
-	    SmoothUpdate
-	    incr i -1
-	}
-    }
-}
+    smooth::YY_FLUSH_BUFFER
+    smooth::yy_scan_string [lrange $var $i end]
+    smooth::yyparse
+    incr i [expr $smooth::yycnt-1]
 }
 
 proc SmoothCmdSet {which value {cmd {}}} {
diff --git a/ds9/library/smosaiciraf.tcl b/ds9/library/smosaiciraf.tcl
index bf5cde2..8334e54 100644
--- a/ds9/library/smosaiciraf.tcl
+++ b/ds9/library/smosaiciraf.tcl
@@ -21,47 +21,8 @@ proc ProcessSMosaicIRAFCmd {varname iname sock fn layer} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	smosaiciraf::YY_FLUSH_BUFFER
-	smosaiciraf::yy_scan_string [lrange $var $i end]
-	smosaiciraf::yyparse
-	incr i [expr $smosaiciraf::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    if {$sock != {}} {
-	# xpa
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSMosaicIRAFFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer
-	}
-    } else {
-	# comm
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSMosaicIRAFFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer
-	}
-    }
-    FinishLoad
-}
+    smosaiciraf::YY_FLUSH_BUFFER
+    smosaiciraf::yy_scan_string [lrange $var $i end]
+    smosaiciraf::yyparse
+    incr i [expr $smosaiciraf::yycnt-1]
 }
diff --git a/ds9/library/smosaicwcs.tcl b/ds9/library/smosaicwcs.tcl
index 6e7a492..4d15461 100644
--- a/ds9/library/smosaicwcs.tcl
+++ b/ds9/library/smosaicwcs.tcl
@@ -21,54 +21,8 @@ proc ProcessSMosaicWCSCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	smosaicwcs::YY_FLUSH_BUFFER
-	smosaicwcs::yy_scan_string [lrange $var $i end]
-	smosaicwcs::yyparse
-	incr i [expr $smosaicwcs::yycnt-1]
-    } else {
-
-    set layer {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    set opt [lindex $var $i]
-    if {$opt != {}} {
-	incr i
-    } else {
-	set opt wcs
-    }
-
-    if {$sock != {}} {
-	# xpa
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSMosaicWCSFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer $opt
-	}
-    } else {
-	# comm
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSMosaicWCSFile [lindex $var $i] [lindex $var [expr $i+1]] \
-		$layer $opt
-	}
-    }
-    FinishLoad
-}
+    smosaicwcs::YY_FLUSH_BUFFER
+    smosaicwcs::yy_scan_string [lrange $var $i end]
+    smosaicwcs::yyparse
+    incr i [expr $smosaicwcs::yycnt-1]
 }
diff --git a/ds9/library/srgbcube.tcl b/ds9/library/srgbcube.tcl
index ac8f448..f4a36f6 100644
--- a/ds9/library/srgbcube.tcl
+++ b/ds9/library/srgbcube.tcl
@@ -33,44 +33,8 @@ proc ProcessSRGBCubeCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	srgbcube::YY_FLUSH_BUFFER
-	srgbcube::yy_scan_string [lrange $var $i end]
-	srgbcube::yyparse
-	incr i [expr $srgbcube::yycnt-1]
-    } else {
-
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateRGBFrame
-	}
-	mask {
-	    incr i
-	    # not supported
-	}
-	slice {
-	    incr i
-	    # not supported
-	}
-    }
-
-    if {$sock != {}} {
-	# xpa
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSRGBCubeFile [lindex $var $i] [lindex $var [expr $i+1]]
-	}
-    } else {
-	# comm
-	if {0} {
-	    # not supported
-	} else {
-	    LoadSRGBCubeFile [lindex $var $i] [lindex $var [expr $i+1]]
-	}
-    }
-    FinishLoad
-}
+    srgbcube::YY_FLUSH_BUFFER
+    srgbcube::yy_scan_string [lrange $var $i end]
+    srgbcube::yyparse
+    incr i [expr $srgbcube::yycnt-1]
 }
diff --git a/ds9/library/stsci.tcl b/ds9/library/stsci.tcl
index c42e362..8126689 100644
--- a/ds9/library/stsci.tcl
+++ b/ds9/library/stsci.tcl
@@ -174,15 +174,10 @@ proc ProcessSTSCICmd {varname iname} {
 
     STSCIDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	dssstsci::YY_FLUSH_BUFFER
-	dssstsci::yy_scan_string [lrange $var $i end]
-	dssstsci::yyparse
-	incr i [expr $dssstsci::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dstsci
-    }
+    dssstsci::YY_FLUSH_BUFFER
+    dssstsci::yy_scan_string [lrange $var $i end]
+    dssstsci::yyparse
+    incr i [expr $dssstsci::yycnt-1]
 }
 
 proc ProcessSendSTSCICmd {proc id param} {
diff --git a/ds9/library/url.tcl b/ds9/library/url.tcl
index 8a65ab7..3d30abc 100644
--- a/ds9/library/url.tcl
+++ b/ds9/library/url.tcl
@@ -313,32 +313,9 @@ proc ProcessURLFitsCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	urlfits::YY_FLUSH_BUFFER
-	urlfits::yy_scan_string [lrange $var $i end]
-	urlfits::yyparse
-	incr i [expr $urlfits::yycnt-1]
-    } else {
-
-    set layer {}
-    set mode {}
-    switch -- [string tolower [lindex $var $i]] {
-	new {
-	    incr i
-	    CreateFrame
-	}
-	mask {
-	    incr i
-	    set layer mask
-	}
-	slice {
-	    incr i
-	    set mode slice
-	}
-    }
-
-    LoadURLFits [lindex $var $i] $layer $mode
-}
+    urlfits::YY_FLUSH_BUFFER
+    urlfits::yy_scan_string [lrange $var $i end]
+    urlfits::yyparse
+    incr i [expr $urlfits::yycnt-1]
 }
 
diff --git a/ds9/library/util.tcl b/ds9/library/util.tcl
index fb24c38..b581c09 100644
--- a/ds9/library/util.tcl
+++ b/ds9/library/util.tcl
@@ -1197,59 +1197,10 @@ proc ProcessPrefsCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	prefs::YY_FLUSH_BUFFER
-	prefs::yy_scan_string [lrange $var $i end]
-	prefs::yyparse
-	incr i [expr $prefs::yycnt-1]
-    } else {
-
-    global pds9
-    global ds9
-
-    switch -- [string tolower [lindex $var $i]] {
-	clear {ClearPrefs}
-	precision {
-	    incr i
-	    set pds9(prec,linear) [lindex $var $i]
-	    incr i
-	    set pds9(prec,deg) [lindex $var $i]
-	    incr i
-	    set pds9(prec,hms) [lindex $var $i]
-	    incr i
-	    set pds9(prec,dms) [lindex $var $i]
-	    incr i
-	    set pds9(prec,arcmin) [lindex $var $i]
-	    incr i
-	    set pds9(prec,arcsec) [lindex $var $i]
-	    PrefsPrecision
-	}
-	bgcolor {
-	    # backward compatibility
-	    incr i
-	    set pds9(bg) [lindex $var $i]
-	    PrefsBgColor
-	}
-	nancolor {
-	    # backward compatibility
-	    incr i
-	    set pds9(nan) [lindex $var $i]
-	    PrefsNanColor
-	}
-	threads {
-	    # backward compatibility
-	    incr i
-	    set ds9(threads) [lindex $var $i]
-	    ChangeThreads
-	}
-	irafalign {
-	    incr i
-	    set pds9(iraf) [FromYesNo [lindex $var $i]]
-	    PrefsIRAFAlign
-	}
-    }
-}
+    prefs::YY_FLUSH_BUFFER
+    prefs::yy_scan_string [lrange $var $i end]
+    prefs::yyparse
+    incr i [expr $prefs::yycnt-1]
 }
 
 proc ProcessSendPrefsCmd {proc id param} {
@@ -1270,28 +1221,10 @@ proc ProcessPrecisionCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	precision::YY_FLUSH_BUFFER
-	precision::yy_scan_string [lrange $var $i end]
-	precision::yyparse
-	incr i [expr $precision::yycnt-1]
-    } else {
-
-    global pds9
-    set pds9(prec,linear) [lindex $var $i]
-    incr i
-    set pds9(prec,deg) [lindex $var $i]
-    incr i
-    set pds9(prec,hms) [lindex $var $i]
-    incr i
-    set pds9(prec,dms) [lindex $var $i]
-    incr i
-    set pds9(prec,arcmin) [lindex $var $i]
-    incr i
-    set pds9(prec,arcsec) [lindex $var $i]
-    PrefsPrecision
-}
+    precision::YY_FLUSH_BUFFER
+    precision::yy_scan_string [lrange $var $i end]
+    precision::yyparse
+    incr i [expr $precision::yycnt-1]
 }
 
 proc ProcessSendPrecisionCmd {proc id param} {
@@ -1304,18 +1237,10 @@ proc ProcessBgCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	bg::YY_FLUSH_BUFFER
-	bg::yy_scan_string [lrange $var $i end]
-	bg::yyparse
-	incr i [expr $bg::yycnt-1]
-    } else {
-
-    global pds9
-    set pds9(bg) [lindex $var $i]
-    PrefsBgColor
-}
+    bg::YY_FLUSH_BUFFER
+    bg::yy_scan_string [lrange $var $i end]
+    bg::yyparse
+    incr i [expr $bg::yycnt-1]
 }
 
 proc ProcessSendBgCmd {proc id param} {
@@ -1328,18 +1253,10 @@ proc ProcessNanCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	nan::YY_FLUSH_BUFFER
-	nan::yy_scan_string [lrange $var $i end]
-	nan::yyparse
-	incr i [expr $nan::yycnt-1]
-    } else {
-
-    global pds9
-    set pds9(nan) [lindex $var $i]
-    PrefsNanColor
-}
+    nan::YY_FLUSH_BUFFER
+    nan::yy_scan_string [lrange $var $i end]
+    nan::yyparse
+    incr i [expr $nan::yycnt-1]
 }
 
 proc ProcessSendNanCmd {proc id param} {
@@ -1352,18 +1269,10 @@ proc ProcessThreadsCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	threads::YY_FLUSH_BUFFER
-	threads::yy_scan_string [lrange $var $i end]
-	threads::yyparse
-	incr i [expr $threads::yycnt-1]
-    } else {
-
-    global ds9
-    set ds9(threads) [lindex $var $i]
-    ChangeThreads
-}
+    threads::YY_FLUSH_BUFFER
+    threads::yy_scan_string [lrange $var $i end]
+    threads::yyparse
+    incr i [expr $threads::yycnt-1]
 }
 
 proc ProcessSendThreadsCmd {proc id param} {
@@ -1404,38 +1313,10 @@ proc ProcessCursorCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	cursor::YY_FLUSH_BUFFER
-	cursor::yy_scan_string [lrange $var $i end]
-	cursor::yyparse
-	incr i [expr $cursor::yycnt-1]
-    } else {
-
-    global current
-
-    if {$current(frame) != {}} {
-	set x [lindex $var $i]
-	incr i
-	set y [lindex $var $i]
-
-	switch -- $current(mode) {
-	    none {$current(frame) warp $x $y}
-	    pointer -
-	    region {MarkerArrowKey $current(frame) $x $y}
-	    catalog {MarkerArrowKey $current(frame) $x $y}
-	    crosshair {CrosshairArrowKey $current(frame) $x $y}
-	    colorbar {}
-	    pan {PanCanvas $x $y}
-	    zoom -
-	    rotate -
-	    crop {}
-	    analysis {IMEArrowKey $current(frame) $x $y}
-	    examine -
-	    iexam {}
-	}
-    }
-}
+    cursor::YY_FLUSH_BUFFER
+    cursor::yy_scan_string [lrange $var $i end]
+    cursor::yyparse
+    incr i [expr $cursor::yycnt-1]
 }
 
 proc CursorCmd {x y} {
@@ -1523,32 +1404,10 @@ proc ProcessIconifyCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	iconify::YY_FLUSH_BUFFER
-	iconify::yy_scan_string [lrange $var $i end]
-	iconify::yyparse
-	incr i [expr $iconify::yycnt-1]
-    } else {
-
-    global ds9
-    switch -- [string tolower [lindex $var $i]] {
-	yes -
-	true -
-	on -
-	1 {wm iconify $ds9(top)}
-
-	no -
-	false -
-	off -
-	0 {wm deiconify $ds9(top)}
-
-	default {
-	    wm iconify $ds9(top)
-	    incr i -1
-	}
-    }
-}
+    iconify::YY_FLUSH_BUFFER
+    iconify::yy_scan_string [lrange $var $i end]
+    iconify::yyparse
+    incr i [expr $iconify::yycnt-1]
 }
 
 proc IconifyCmd {which} {
@@ -1582,22 +1441,10 @@ proc ProcessModeCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	mode::YY_FLUSH_BUFFER
-	mode::yy_scan_string [lrange $var $i end]
-	mode::yyparse
-	incr i [expr $mode::yycnt-1]
-    } else {
-
-    global current
-    set current(mode) [string tolower [lindex $var $i]]
-    # backward compatibility
-    switch $current(mode) {
-	pointer {set current(mode) region}
-    }
-    ChangeMode
-}
+    mode::YY_FLUSH_BUFFER
+    mode::yy_scan_string [lrange $var $i end]
+    mode::yyparse
+    incr i [expr $mode::yycnt-1]
 }
 
 proc ProcessQuitCmd {varname iname} {
@@ -1629,22 +1476,10 @@ proc ProcessSleepCmd {varname iname} {
     UpdateDS9
     RealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	sleep::YY_FLUSH_BUFFER
-	sleep::yy_scan_string [lrange $var $i end]
-	sleep::yyparse
-	incr i [expr $sleep::yycnt-1]
-    } else {
-
-    set sec 1
-    if {[lindex $var $i] != {} && [string range [lindex $var $i] 0 0] != {-}} {
-	set sec [lindex $var $i]
-    } else {
-	incr i -1
-    }
-    after [expr int($sec*1000)]
-}
+    sleep::YY_FLUSH_BUFFER
+    sleep::yy_scan_string [lrange $var $i end]
+    sleep::yyparse
+    incr i [expr $sleep::yycnt-1]
 }
 
 proc ProcessSourceCmd {varname iname} {
@@ -1655,16 +1490,10 @@ proc ProcessSourceCmd {varname iname} {
     # you never know what someone will try to do
     ProcessRealizeDS9
 
-    global debug
-    if {$debug(tcl,parser)} {
-	source::YY_FLUSH_BUFFER
-	source::yy_scan_string [lrange $var $i end]
-	source::yyparse
-	incr i [expr $source::yycnt-1]
-    } else {
-
-    uplevel #0 "source [lindex $var $i]"
-}
+    source::YY_FLUSH_BUFFER
+    source::yy_scan_string [lrange $var $i end]
+    source::yyparse
+    incr i [expr $source::yycnt-1]
 }
 
 proc SourceCmd {fn} {
diff --git a/ds9/library/vla.tcl b/ds9/library/vla.tcl
index d568a20..129a03e 100644
--- a/ds9/library/vla.tcl
+++ b/ds9/library/vla.tcl
@@ -165,15 +165,10 @@ proc ProcessVLACmd {varname iname} {
 
     VLADialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	vla::YY_FLUSH_BUFFER
-	vla::yy_scan_string [lrange $var $i end]
-	vla::yyparse
-	incr i [expr $vla::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dvla
-    }
+    vla::YY_FLUSH_BUFFER
+    vla::yy_scan_string [lrange $var $i end]
+    vla::yyparse
+    incr i [expr $vla::yycnt-1]
 }
 
 proc ProcessSendVLACmd {proc id param} {
diff --git a/ds9/library/vlss.tcl b/ds9/library/vlss.tcl
index e0e45d6..1d85c3e 100644
--- a/ds9/library/vlss.tcl
+++ b/ds9/library/vlss.tcl
@@ -124,15 +124,10 @@ proc ProcessVLSSCmd {varname iname} {
 
     VLSSDialog
 
-    global debug
-    if {$debug(tcl,parser)} {
-	vlss::YY_FLUSH_BUFFER
-	vlss::yy_scan_string [lrange $var $i end]
-	vlss::yyparse
-	incr i [expr $vlss::yycnt-1]
-    } else {
-	IMGSVRProcessCmd $varname $iname dvlss
-    }
+    vlss::YY_FLUSH_BUFFER
+    vlss::yy_scan_string [lrange $var $i end]
+    vlss::yyparse
+    incr i [expr $vlss::yycnt-1]
 }
 
 proc ProcessSendVLSSCmd {proc id param} {
diff --git a/ds9/library/vo.tcl b/ds9/library/vo.tcl
index c96c597..10ff0fb 100644
--- a/ds9/library/vo.tcl
+++ b/ds9/library/vo.tcl
@@ -466,76 +466,10 @@ proc ProcessVOCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	vo::YY_FLUSH_BUFFER
-	vo::yy_scan_string [lrange $var $i end]
-	vo::yyparse
-	incr i [expr $vo::yycnt-1]
-    } else {
-
-    set vvarname voi
-    upvar #0 $vvarname vvar
-    global $vvarname
-
-    global ivo
-    global pvo
-
-    switch -- [string tolower [lindex $var $i]] {
-	open {VODialog}
-	close {VODestroy $vvarname}
-	method {
-	    incr i
-	    set pvo(method) [lindex $var $i]
-	}
-	server {
-	    incr i
-	    set pvo(server) [lindex $var $i]
-	}
-	internal {
-	    incr i
-	    set pvo(hv) [FromYesNo [lindex $var $i]]
-	}
-	delay {
-	    incr i
-	    set pvo(delay) [lindex $var $i]
-	}
-	connect {
-	    incr i
-
-	    VODialog
-
-	    # find best match
-	    set ii [lsearch $ivo(server,url) "*[lindex $var $i]*"]
-	    if {$ii>=0} {
-		set ivo(b$ii) 1
-		VOCheck $vvarname $ii
-	    }
-	}
-	disconnect {
-	    incr i
-
-	    VODialog
-
-	    # find best match
-	    set ii [lsearch $ivo(server,url) "*[lindex $var $i]*"]
-	    if {$ii>=0} {
-		set ivo(b$ii) 0
-		VOCheck $vvarname $ii
-	    }
-	}
-	default {
-	    VODialog
-
-	    # find best match
-	    set ii [lsearch $ivo(server,url) "*[lindex $var $i]*"]
-	    if {$ii>=0} {
-		set ivo(b$ii) 1
-		VOCheck $vvarname $ii
-	    }
-	}
-    }
-}
+    vo::YY_FLUSH_BUFFER
+    vo::yy_scan_string [lrange $var $i end]
+    vo::yyparse
+    incr i [expr $vo::yycnt-1]
 }
 
 proc VOCmdSet {which value} {
diff --git a/ds9/library/wcs.tcl b/ds9/library/wcs.tcl
index bc4c4cb..53f1171 100644
--- a/ds9/library/wcs.tcl
+++ b/ds9/library/wcs.tcl
@@ -1134,139 +1134,14 @@ proc ProcessWCSCmd {varname iname sock fn} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	global parse
-	set parse(sock) $sock
-	set parse(fn) $fn
-
-	wcs::YY_FLUSH_BUFFER
-	wcs::yy_scan_string [lrange $var $i end]
-	wcs::yyparse
-	incr i [expr $wcs::yycnt-1]
-    } else {
-
-    global wcs
-    global current
-    global rgb
-
-    set item [string tolower [lindex $var $i]]
-    switch -- $item {
-	open {WCSDialog}
-	close {WCSDestroyDialog}
-	system {
-	    incr i
-	    set wcs(system) [string tolower [lindex $var $i]]
-	    UpdateWCS
-	}
-	sky {
-	    incr i
-	    set wcs(sky) [string tolower [lindex $var $i]]
-	    UpdateWCS
-	}
-	format -
-	skyformat {
-	    incr i
-	    switch -- [string tolower [lindex $var $i]] {
-		deg -
-		degree -
-		degrees {set wcs(skyformat) degrees}
-		default {set wcs(skyformat) [string tolower [lindex $var $i]]}
-	    }
-	    UpdateWCS
-	}
-	align {
-	    incr i
-	    set current(align) [FromYesNo [lindex $var $i]]
-	    AlignWCSFrame
-	}
-	reset {
-	    set ext 1
-	    set nn [lindex $var [expr $i+1]]
-	    if {[string is integer -strict $nn]} {
-		incr i
-		set ext $nn
-	    }
-
-	    RGBEvalLock rgb(lock,wcs) $current(frame) [list $current(frame) wcs reset $ext]
-	    UpdateWCS
-	}
-	replace -
-	append {
-	    set ext 1
-	    set nn [lindex $var [expr $i+1]]
-	    if {[string is integer -strict $nn]} {
-		incr i
-		set ext $nn
-	    }
+    global parse
+    set parse(sock) $sock
+    set parse(fn) $fn
 
-	    if {$sock != {}} {
-		incr i
-		if {[lindex $var $i] == {}} {
-		    RGBEvalLock rgb(lock,wcs) $current(frame) [list $current(frame) wcs $item $ext $sock]
-		    incr i -1
-		} else {
-		    RGBEvalLock rgb(lock,wcs) $current(frame) "$current(frame) wcs $item $ext \{\{[lindex $var $i]\}\}"
-		}
-	    } elseif {$fn != {}} {
-		RGBEvalLock rgb(lock,wcs) $current(frame) "$current(frame) wcs $item $ext \{\{$fn\}\}"
-	    } else {
-		incr i
-		if {[lindex $var $i] == "file"} {
-		    incr i
-		}
-		RGBEvalLock rgb(lock,wcs) $current(frame) "$current(frame) wcs $item $ext \{\{[lindex $var $i]\}\}"
-	    }
-	    UpdateWCS
-	}
-
-	fk4 -
-	fk5 -
-	icrs -
-	galactic -
-	ecliptic {
-	    set wcs(sky) $item
-	    UpdateWCS
-	}
-
-	degrees -
-	sexagesimal {
-	    set wcs(skyformat) $item
-	    UpdateWCS
-	}
-
-	wcs -
-	wcsa -
-	wcsb -
-	wcsc -
-	wcsd -
-	wcse -
-	wcsf -
-	wcsg -
-	wcsh -
-	wcsi -
-	wcsj -
-	wcsk -
-	wcsl -
-	wcsm -
-	wcsn -
-	wcso -
-	wcsp -
-	wcsq -
-	wcsr -
-	wcss -
-	wcst -
-	wcsu -
-	wcsv -
-	wcsw -
-	wcsx -
-	wcsy -
-	wcsz {
-	    set wcs(system) $item
-	    UpdateWCS
-	}
-    }
-}
+    wcs::YY_FLUSH_BUFFER
+    wcs::yy_scan_string [lrange $var $i end]
+    wcs::yyparse
+    incr i [expr $wcs::yycnt-1]
 }
 
 proc WCSCmdSet {which value {cmd {}}} {
@@ -1339,34 +1214,10 @@ proc ProcessAlignCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	align::YY_FLUSH_BUFFER
-	align::yy_scan_string [lrange $var $i end]
-	align::yyparse
-	incr i [expr $align::yycnt-1]
-    } else {
-
-    global current
-    switch -- [string tolower [lindex $var $i]] {
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {
-	    set current(align) [FromYesNo [lindex $var $i]]
-	    AlignWCSFrame
-	}
-	default {
-	    set current(align) 1
-	    AlignWCSFrame
-	    incr i -1
-	}
-    }
-}
+    align::YY_FLUSH_BUFFER
+    align::yy_scan_string [lrange $var $i end]
+    align::yyparse
+    incr i [expr $align::yycnt-1]
 }
 
 proc ProcessSendAlignCmd {proc id param} {
diff --git a/ds9/library/xpa.tcl b/ds9/library/xpa.tcl
index dc34a39..e4f6d70 100644
--- a/ds9/library/xpa.tcl
+++ b/ds9/library/xpa.tcl
@@ -2205,63 +2205,20 @@ proc ProcessXPAFirstCmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	xpafirst::YY_FLUSH_BUFFER
-	xpafirst::yy_scan_string [lrange $var $i end]
-	xpafirst::yyparse
-	incr i [expr $xpafirst::yycnt-1]
-    } else {
-
-    global ds9
-    global pds9
-    global env
-
-    switch -- [string tolower [lindex $var $i]] {
-	unix -
-	inet -
-	local -
-	localhost {set env(XPA_METHOD) [lindex $var $i]}
-	noxpans {set env(XPA_NSREGISTER) false}
-
-	yes -
-	true -
-	on -
-	1 -
-	no -
-	false -
-	off -
-	0 {set pds9(xpa) [FromYesNo [lindex $var $i]]}
-    }
-}
+    xpafirst::YY_FLUSH_BUFFER
+    xpafirst::yy_scan_string [lrange $var $i end]
+    xpafirst::yyparse
+    incr i [expr $xpafirst::yycnt-1]
 }
 
 proc ProcessXPACmd {varname iname} {
     upvar $varname var
     upvar $iname i
 
-    global debug
-    if {$debug(tcl,parser)} {
-	xpa::YY_FLUSH_BUFFER
-	xpa::yy_scan_string [lrange $var $i end]
-	xpa::yyparse
-	incr i [expr $xpa::yycnt-1]
-    } else {
-
-    global ds9
-    global pds9
-
-    switch -- [string tolower [lindex $var $i]] {
-	tcl {
-	    # backward compatibility
-	    incr i
-	}
-
-	connect {XPAConnect}
-	disconnect {XPADisconnect}
-	info {XPAInfo}
-    }
-}
+    xpa::YY_FLUSH_BUFFER
+    xpa::yy_scan_string [lrange $var $i end]
+    xpa::yyparse
+    incr i [expr $xpa::yycnt-1]
 }
 
 proc XPACmdSet {varname which value} {
diff --git a/ds9/make.include b/ds9/make.include
index 0d0e028..37a7189 100644
--- a/ds9/make.include
+++ b/ds9/make.include
@@ -7,13 +7,13 @@ vpath %.fcl $(prefix)/ds9/parsers
 # -w generate warnings
 # -d generate lexer table
 $(prefix)/ds9/parsers/%parser.tcl : %parser.tac
-	tclsh $(prefix)/taccle/taccle.tcl -p $* -d $<
-#	tclsh $(prefix)/taccle/taccle.tcl -p $* -d -w -v $<
+#	tclsh $(prefix)/taccle/taccle.tcl -p $* -d $<
+	tclsh $(prefix)/taccle/taccle.tcl -p $* -d -w -v $<
 
 # -d debug
 $(prefix)/ds9/parsers/%lex.tcl : %lex.fcl
-	tclsh $(prefix)/fickle/fickle.tcl -P $* $<
-#	tclsh $(prefix)/fickle/fickle.tcl -P $* -d $<
+#	tclsh $(prefix)/fickle/fickle.tcl -P $* $<
+	tclsh $(prefix)/fickle/fickle.tcl -P $* -d $<
 
 #--------------------------library
 
diff --git a/ds9/parsers/analysislex.fcl b/ds9/parsers/analysislex.fcl
index 07327c5..0ba847d 100644
--- a/ds9/parsers/analysislex.fcl
+++ b/ds9/parsers/analysislex.fcl
@@ -8,7 +8,6 @@
 %%
 
 clear	    {return $CLEAR_}
-entry	    {return $ENTRY_}
 load	    {return $LOAD_}
 message	    {return $MESSAGE_}
 plot	    {return $PLOT_}
diff --git a/ds9/parsers/analysisparser.tac b/ds9/parsers/analysisparser.tac
index 15535e3..4b42b99 100644
--- a/ds9/parsers/analysisparser.tac
+++ b/ds9/parsers/analysisparser.tac
@@ -7,7 +7,6 @@
 %start command
 
 %token CLEAR_
-%token ENTRY_
 %token LOAD_
 %token MESSAGE_
 %token PLOT_
@@ -53,7 +52,11 @@ task : INT_ {AnalysisTask $1 menu}
  ;
 
 clear : {ClearAnalysis}
- | LOAD_ STRING_ {ClearAnalysis; ProcessAnalysisFile $2}
+ | LOAD_ clearLoad
+ ;
+ 
+clearLoad : {ClearAnalysis; AnalysisCmdLoad}
+ | STRING_ {ClearAnalysis; ProcessAnalysisFile $1}
  ;
 
 message : {set _ ok}
@@ -76,6 +79,7 @@ dim : XY_ {set _ xy}
  | XYEX_ {set _ xyex}
  | XYEY_ {set _ xyey}
  | XYEXEY_ {set _ xyexey}
+ | INT_ {set _ $1}
  ;
 
 %%
diff --git a/ds9/parsers/catparser.tac b/ds9/parsers/catparser.tac
index 13a618e..f3328c4 100644
--- a/ds9/parsers/catparser.tac
+++ b/ds9/parsers/catparser.tac
@@ -115,7 +115,7 @@ catalog : NEW_ {CATTool}
  | LOAD_ STRING_ {CatalogCmdLoad $2 VOTRead}
  | IMPORT_ reader STRING_ {CatalogCmdLoad $3 $2}
 
- | {CatalogCmdCheck} catCmd
+ | {if {![CatalogCmdCheck]} {cat::YYABORT}} catCmd
  | STRING_ {CatalogCmdRef $1}
  | STRING_ {CatalogCmdRef $1} catCmd
 # backward compatibility
diff --git a/ds9/parsers/matchlock.trl b/ds9/parsers/matchlock.trl
index 4fe6ad1..9a2affc 100644
--- a/ds9/parsers/matchlock.trl
+++ b/ds9/parsers/matchlock.trl
@@ -3,7 +3,8 @@ lock : coordsys {set _ $1}
  | NONE_  {set _ none}
  ;
 
-lockslice : IMAGE_ {set _ image}
+lockslice : {set _ image}
+ | IMAGE_ {set _ image}
  | wcssys {set _ $1}
  | NONE_ {set _ none}
  ;
diff --git a/ds9/parsers/plotparser.tac b/ds9/parsers/plotparser.tac
index d48497b..d601f72 100644
--- a/ds9/parsers/plotparser.tac
+++ b/ds9/parsers/plotparser.tac
@@ -154,8 +154,8 @@ command : plot
  | NEW_ {PlotCmdNew {}} new
  | NEW_ NAME_ STRING_ {PlotCmdNew $3} new
 
- | {PlotCmdCheck} plotCmd
- | STRING_ {PlotCmdRef $1} plotCmd
+ | {if {![PlotCmdCheck]} {plot::YYABORT}} plotCmd
+ | STRING_ {if {![PlotCmdRef $1]} {plot::YYABORT}} plotCmd
  ;
 
 line : {PlotCmdNew {}; PlotCmdLine {} {} {} xy}
diff --git a/ds9/parsers/siaparser.tac b/ds9/parsers/siaparser.tac
index 5bdb989..4f117a4 100644
--- a/ds9/parsers/siaparser.tac
+++ b/ds9/parsers/siaparser.tac
@@ -49,7 +49,7 @@ command : sia
  | sia {yyclearin; YYACCEPT} STRING_
  ;
 
-sia : {SIACmdCheck} siaCmd
+sia : {if {![SIACmdCheck]} {sia::YYABORT}} siaCmd
  | site {SIACmdRef $1}
  | site {SIACmdRef $1} siaCmd
  ;
diff --git a/ds9/parsers/webparser.tac b/ds9/parsers/webparser.tac
index 2be631f..8939480 100644
--- a/ds9/parsers/webparser.tac
+++ b/ds9/parsers/webparser.tac
@@ -27,8 +27,8 @@ web : {WebCmdNew {}}
  | STRING_ {WebCmdNew $1}
  | NEW_ STRING_ STRING_ {WebCmdNew $3 $2}
 
- | {WebCmdCheck} webCmd
- | STRING_ {WebCmdRef $1} webCmd
+ | {if {![WebCmdCheck]} {web::YYABORT}} webCmd
+ | STRING_ {if {![WebCmdRef $1]} {web::YYABORT}} webCmd
  ;
 
 webCmd : CLICK_ click