doc.tcl

Go to the documentation of this file.

/*  -*- tcl -*-*/
/*  sak::doc - Documentation facilities*/

package require sak::util

namespace ::sak::doc {}

/*  ###*/
/*  API commands*/

ret  ::sak::doc::validate (type modules) {Gen null  null $modules}
ret  ::sak::doc::html     (type modules) {Gen html  html $modules}
ret  ::sak::doc::nroff    (type modules) {Gen nroff n    $modules}
ret  ::sak::doc::tmml     (type modules) {Gen tmml  tmml $modules}
ret  ::sak::doc::text     (type modules) {Gen text  txt  $modules}
ret  ::sak::doc::wiki     (type modules) {Gen wiki  wiki $modules}
ret  ::sak::doc::latex    (type modules) {Gen latex tex  $modules}

ret  ::sak::doc::dvi (type modules) {
    latex $modules
    file mkdir [file join doc dvi]
    cd         [file join doc dvi]

    foreach f [lsort -dict [glob -nocomplain ../latex/*.tex]] {

    set target [file rootname [file tail $f]].dvi
    if {[file exists $target] 
        && [file mtime $target] > [file mtime $f]} {
        continue
    }

    puts "Gen (dvi): $f"
    exec latex $f 1>@ stdout 2>@ stderr
    }
    cd ../..
    return
}

ret  ::sak::doc::ps (type modules) {
    dvi $modules
    file mkdir [file join doc ps]
    cd         [file join doc ps]
    foreach f [lsort -dict [glob -nocomplain ../dvi/*.dvi]] {

    set target [file rootname [file tail $f]].ps
    if {[file exists $target] 
        && [file mtime $target] > [file mtime $f]} {
        continue
    }

    puts "Gen (ps): $f"
    exec dvips -o $target $f >@ stdout 2>@ stderr
    }
    cd ../..
    return
}

ret  ::sak::doc::pdf (type modules) {
    dvi $modules
    file mkdir [file join doc pdf]
    cd         [file join doc pdf]
    foreach f [lsort -dict [glob -nocomplain ../ps/*.ps]] {

    set target [file rootname [file tail $f]].pdf
    if {[file exists $target] 
        && [file mtime $target] > [file mtime $f]} {
        continue
    }

    puts "Gen (pdf): $f"
    exec ps2pdf $f $target >@ stdout 2>@ stderr
    }
    cd ../..
    return
}

ret  ::sak::doc::list (type modules) {
    Gen list l $modules
    
    set FILES [glob -nocomplain doc/list/*.l]
    set LIST  [open [file join doc list manpages.tcl] w]

    foreach file $FILES {
        set f [open $file r]
        puts $LIST [read $f]
        close $f
    }
    close $LIST

    eval file delete -force $FILES
    return
}

/*  ### ### ### ######### ######### #########*/
/*  Implementation*/

ret  ::sak::doc::Gen (type fmt , type ext , type modules) {
    global distribution
    global tcl_platform

    getpackage doctools doctools/doctools.tcl

    set null   0 ; if {![string compare $fmt null]} {set null   1}
    set hidden 0 ; if {![string compare $fmt desc]} {set hidden 1}

    if {!$null} {
    file mkdir [file join doc $fmt]
    set prefix "Gen ($fmt)"
    } else {
    set prefix "Validate  "
    }

    foreach m $modules {
    set mpath [sak::util::module2path $m]

    ::doctools::new dt \
        -format $fmt \
        -module $m

    set fl [glob -nocomplain [file join $mpath *.man]]

    if {[llength $fl] == 0} {
        dt destroy
        continue
    }

    foreach f $fl {
        if {!$null} {
                set target [file join doc $fmt \
                                [file rootname [file tail $f]].$ext]
                if {[file exists $target] 
                    && [file mtime $target] > [file mtime $f]} {
                    continue
                }
        }
        if {!$hidden} {puts "$prefix: $f"}

        dt configure -file $f
        if {$null} {
        dt configure -deprecated 1
        }

        set fail [catch {
        set data [dt format [get_input $f]]
        } msg]

        set warnings [dt warnings]
        if {[llength $warnings] > 0} {
        puts stderr [join $warnings \n]
        }

        if {$fail} {
        puts stderr $msg
        continue
        }

        if {!$null} {
        write_out $target $data
        }
    }
    dt destroy
    }
}

/*  ### ### ### ######### ######### #########*/

package provide sak::doc 1.0

/** 
 * ###