Eskil

2017-12-04
 Support multiple plugins from command line.

2017-12-02
 Support multiple plugins.
 Changed default pivot to 10. Include GUI choice for 1.

2017-12-01
 Added GUI for multiple plugins. No function yet.

Eskil provides a plugin system where plugins can preprocess data
before being compared and displayed.

The command line options for plugins are:
  -plugin plugin     : Use plugin
  -plugininfo info   : Pass info to plugin (plugin specific)
  -pluginallow       : Allow full access privilege for a plugin.
Command line options for info:
  -plugindump plugin : Dump plugin source to stdout
  -pluginlist        : List known plugins

A plugin may further define command line options that it accepts.

Multiple -plugin may be given and they will be applied in the given
order. Any -plugininfo and -pluginallow belongs to the last -plugin
before them.

A plugin is a Tcl script that must follow a specific format.
Dump one of the included plugins to see what it looks like.
The plugin is executed in a safe interpreter and thus cannot do any
damage. You can turn this safety off with -pluginallow.

A plugin is set up with these global variables filled in:

    set arg $::eskil($top,edit,pluginname,$n)
    set pOpts {}
    if {$arg ne ""} {
        set res [LocatePlugin $arg]
        set pOpts [dict get $res opts]
    }
    # Look for defaults on the command line
    set pArgv $::eskil(argv)
    if {[info exists ::eskil($top,pluginargv,$n)]} {
        lappend pArgv {*}$::eskil($top,pluginargv,$n)
    }
    # Look for declarations of command line options
    set t 0
    set ::eskil($top,edit,opts,$n) $pOpts
    foreach {name flag doc} $pOpts {
        ttk::label $w.l$t -text $name
        addBalloon $w.l$t $doc
        grid $w.l$t -sticky "w" -padx 3 -pady 3
        if {$flag} {
            # Initialise if given.
            if {[lsearch -exact $pArgv $name] >= 0} {
                set ::eskil($top,edit,$name,$n) 1
                # Move responsibility from global argv
                set ix [lsearch -exact $::eskil(argv) $name]
                if {$ix >= 0} {
                    set ::eskil(argv) [lreplace $::eskil(argv) $ix $ix]
                    lappend ::eskil($top,pluginargv,$n) $name
                }
            }
            ttk::checkbutton $w.s$t -text "On" \
                    -variable ::eskil($top,edit,$name,$n)
            grid $w.s$t -row $t -column 1 -sticky "w" -padx 3 -pady 3
        } else {
            # Initialise if given.
            set ix [lsearch -exact $pArgv $name]
            if {$ix >= 0} {
                set ::eskil($top,edit,$name,$n) [lindex $pArgv $ix+1]
                # Move responsibility from global argv
                set ix [lsearch -exact $::eskil(argv) $name]
                if {$ix >= 0} {
                    lappend ::eskil($top,pluginargv,$n) $name \
                            [lindex $::eskil(argv) $ix+1]
                    set ::eskil(argv) [lreplace $::eskil(argv) $ix $ix+1]
                }
            }
            ttk::entry $w.s$t \
                    -textvariable ::eskil($top,edit,$name,$n)
            grid $w.s$t -row $t -column 1 -sticky we -padx 3 -pady 3
        }
        incr t
    }
    grid columnconfigure $w 1 -weight 1

                set chunk [string range $d 0 $ci-1]
                set d [string trim [string range $d $ci end]]
            }
            puts "$outName$chunk"
            set outName [format %*s $indent ""]
        }
    }
    # Dump any plugin that has options defined
    foreach {plugin _} $::eskil(opts,src) {
        puts ""
        printPlugin $plugin 1
    }
}

#####################################
# Option/flag handling helpers
#####################################
# Validators

            addFlags $name
        } else {
            addOpt $name
        }
        docFlag $name "Plugin $arg : $doc"
        addSource $name $arg
    }
    # Special:
    # If a -plugin is given and plugininfo and pluginallow is not
    # balanced, extend them.
    set n [llength [dict get $::eskil(opts) -plugin]]
    # Validator is called after this -plugin was added.
    incr n -1
    while {[llength [dict get $::eskil(opts) -plugininfo]] < $n} {
        dict lappend ::eskil(opts) -plugininfo ""
    }
    while {[llength [dict get $::eskil(opts) -pluginallow]] < $n} {
        dict lappend ::eskil(opts) -pluginallow 0
    }
}

# Option database setup
proc initOpts {} {
    set ::eskil(opts) {}
    set ::eskil(opts,info) {}
    set ::eskil(opts,src) {}
    set ::eskil(defoptinfo) {
        flag 0
        given 0
        multi 0
        type ""
        validator ""
        filter ""
        sideeffect ""
        shortdescr ""
        longdescr ""
        source ""
    } 
}
# Add a command line flag that do not take a value
proc addFlags {args} {
    foreach name $args {
        dict set ::eskil(opts) $name 0
        dict set ::eskil(opts,info) $name $::eskil(defoptinfo)
        dict set ::eskil(opts,info) $name flag  1
    }
}
# Add a command line flag that do not take a value, but can be given multiple
proc addMultFlags {args} {
    foreach name $args {
        dict set ::eskil(opts) $name {}
        dict set ::eskil(opts,info) $name $::eskil(defoptinfo)
        dict set ::eskil(opts,info) $name flag  1
        dict set ::eskil(opts,info) $name multi 1
    }
}
# Document a flag or option
proc docFlag {name short {long {}}} {
    dict set ::eskil(opts,info) $name shortdescr $short
    dict set ::eskil(opts,info) $name longdescr $long
}

}
# Add a filter command prefix to an Opt
proc addFilter {name cmd} {
    dict set ::eskil(opts,info) $name filter $cmd
}
# Add a source reference to an Opt
proc addSource {name src} {
    # Remember them if needed for -help
    dict set ::eskil(opts,src) $src 1
    # This points to the plugin the Opt belongs to.
    dict set ::eskil(opts,info) $name source $src
}
# Add a sideeffect to an Opt
##nagelfar syntax addSideEffect x c
proc addSideEffect {name script} {
    dict set ::eskil(opts,info) $name sideeffect $script
}

    addFlags -foreach -close
    docFlag -foreach "Open one diff window per file listed"
    docFlag -close   "Close windows with no changes"
    addFlags -nonewline -nonewline+ -nocdiff
    docFlag -nonewline  "Try to ignore newline changes"
    docFlag -nonewline+ "Try to ignore newline changes, and don't display"
    docFlag -nocdiff    "Disable C version of DiffUtil. For debug"
    addFlags -pluginlist
    addMultFlags -pluginallow
    docFlag -pluginlist  "List known plugins"
    docFlag -pluginallow "Allow full access privilege for plugin"
    # Options that take values
    addMultOpt -plugin
    docFlag  -plugin "Preprocess files using plugin"
    addValidator -plugin optValidatePlugin
    addMultOpt -plugininfo
    docFlag  -plugininfo "Pass info to plugin (plugin specific)"
    addOpt   -plugindump
    docFlag  -plugindump "Dump plugin source to stdout"
    # These options affect Pref
    addPrefOpt -pivot             pivot             optValidatePositive
    docFlag    -pivot "Pivot setting for diff algorithm (10)"
    addPrefOpt -context           context           optValidateNatural

        printUsage
        exit
    }

    # All options have been parsed, extract them to where they need to go

    # Straight to locals
    set pluginL     [optGet -plugin]
    set plugininfoL [optGet -plugininfo]
    set plugindump  [optGet -plugindump]
    set pluginlist  [optGet -pluginlist]
    set pluginallowL [optGet -pluginallow]
    set noautodiff  [optGet -nodiff]
    set nocdiff     [optGet -nocdiff]
    set dodir       [optGet -dir]
    set doclip      [optGet -clip]
    set dopatch     [optGet -patch]
    set doreview    [optGet -review]
    set autobrowse  [optGet -browse]

        printPlugins
        exit
    }
    if {$plugindump ne ""} {
        printPlugin $plugindump
        exit
    }
    set t 0
    foreach plugin $pluginL {
        set plugininfo [lindex $plugininfoL $t]
        set pluginallow [lindex $pluginallowL $t]
        # If pluginallow list is too short
        if {$pluginallow eq ""} { set pluginallow 0 }
        incr t
        set pinterp [createPluginInterp $plugin $plugininfo $pluginallow pinfo]
        if {$pinterp eq ""} {
            # This should not happen since the validator should handle it
            puts "Bad plugin: $plugin"
            printPlugins
            exit
        }

        set opts(plugin,$t) $pinterp
        set opts(pluginname,$t) $plugin
        set opts(pluginallow,$t) $pluginallow
        set opts(plugininfo,$t) $plugininfo
        set opts(pluginpinfo,$t) $pinfo
    }

    # Store the command line given opts
    set ::eskil(defaultopts) [array get opts]

    # Do we start in clip diff mode?
    if {$doclip} {