-@ ARGFILE

Read command-line arguments from the specified file. The file contains one argument per line (NOT one option per line -- some options require additional arguments, and all arguments must be placed on separate lines). Blank lines and lines beginning with # and are ignored. Normal shell processing of arguments is not performed, which among other things means that arguments should not be quoted and spaces are treated as any other character. ARGFILE may exist relative to either the current directory or the exiftool directory unless an absolute pathname is given.

#!/usr/bin/tclsh

#---------------------------------------------------------------------------
# start of "package"
#
namespace eval ::run_exiftool {
    variable et_vars

    set et_vars [dict create]
    # the caller can use this dict, we only care about the keys "chan" and
    # "func"
}

# called by the user to start using ExifTool
proc ::run_exiftool::start { func } {
    variable et_vars

    # remember the user-supplied function
    dict set et_vars func $func

    # start ExifTool in the right way and remember the channel for the pipe
    set et [open "|exiftool -stay_open true -@ -" r+]
    fconfigure $et -blocking false
    fileevent $et readable [list [namespace current]::isReadable]
    dict set et_vars chan $et

    # call the user-supplied function with the NAME of the dictionary and the
    # special string "INIT"
    $func [namespace current]::et_vars INIT
    # presumably the user-supplied code will feed arguments to ExifTool,
    # deal with its output and, eventually, stop it properly.

    vwait ::DONE

    close [dict get $et_vars chan]
}

# this is how to stop ExifTool properly
proc ::run_exiftool::stop {} {
    variable et_vars
    set et [dict get $et_vars chan]
    puts $et "-stay_open"
    puts $et "false"
    flush $et
}

# pretty much a standard fileevent handler
proc ::run_exiftool::isReadable {} {
    variable et_vars

    set et [dict get $et_vars chan]

    # The channel is readable; try to read it.
    set status [catch { gets $et line } result]
    if { $status != 0 } {
        # Error on the channel
        puts "error reading $et: $result"
        set ::DONE 2
    } elseif { $result >= 0 } {
        # Successfully read the channel, so tell the user (dict passed
        # by NAME)
        set usr_status [catch { [dict get $et_vars func] [namespace current]::et_vars $line } usr_result]
        if { $usr_status != 0 } {
            puts "error in user function: $usr_result"
            close $et
            set ::DONE 99
        }
    } elseif { [eof $et] } {
       # End of file on the channel
       set ::DONE 1
    } elseif { [fblocked $et] } {
       # Read blocked.  Just return
    } else {
       # Something else
       puts "can't happen"
       set ::DONE 3
    }
}

# end of "package"
#---------------------------------------------------------------------------

# ::run_exiftool::start do_one_line

proc do_one_line { et_dict line } {
    # the dict is available for user data needed across calls, which is why
    # we get it by name, and pass it on by name as well
    upvar 1 $et_dict et_vars
    # the channel to ExifTool is the most important thing we get
    set et [dict get $et_vars chan]
    # process a line of ExifTool's output
    switch -regexp -- $line {
        {^INIT$} {
            # This is the special case to allow us to initialize - 
            # in this case we are driven by a file, so open it, save the
            # channel, and call our function to read from it and send something
            # to ExifTool
            dict set et_vars fp [open captionlist]
            dict set et_vars dates -
            sendnext et_vars
        }
        {^date} {
            # this output will result from what we sent first, so remember it
            dict set et_vars dates [lindex [split $line] 1]
        }
        {^{ready1}$} {
            # this is from -execute1, now we can use what we remembered to
            # build some updates
            updnext et_vars
        }
        {^{ready2}$} {
            # this is from -execute2, our updates are done, so go get the data
            # for the next and send it
            sendnext et_vars
        }
        default {
            # not from anything we did or from -execute, so just show it
            # to the user
            puts $line
        }
    }
}

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References