#!/usr/bin/env texlua  

 

VERSION = "0.23a"

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

local orig_print = print

 

function usage()

  orig_print

Usage:  [texlua] musixtex.lua { option | basename[ .xml | .mtx | .pmx | .aspc | .tex | .ltx] } ...

        When no extension is given, extensions are tried in the above order

        until a source file is found. Preprocessing goes xml-pmx-tex or mtx-pmx-tex or

        aspc-tex, with the entry point determined by the extension.

        The normal route after preprocessing goes tex-dvi-ps-pdf, but shorter

        routes are also available, see the options. The default 3-pass processing route

        for .tex files is etex-musixflx-etex.

Options: -v, --version  version

         -h, --help   help

         -l  latex source

         -p  direct tex-pdf (pdftex etc)

         -F fmt  use fmt as the TeX processor

         -d  tex-dvi-pdf (using dvipdfm if -D not used)

         -D dvixx  use dvixx as the dvi processor

         -P ps2pdfxx  use ps2pdfxx as the Postscript processor

         -c  preprocess pmx file using pmxchords

         -m  stop at pmx

         -M prepmxx  use prepmxx as the mtx preprocessor

         -A autospx  use autospx as the aspc preprocessor

         -X pmxabx  use pmxabx as the pmx preprocessor

         -L xmlx use xmlx as the xml preprocessor

         -t  stop at tex/mid

         -s  stop at dvi

         -g  stop at ps

         -i  retain intermediate and log files

         -q  quiet mode (redirect screen logs, write summary on musixtex.log)

         -1  one-pass [pdf][la]tex processing

         -x  run makeindex

         -f  restore default processing

Four TeX engines are available via the -l and -p options.

    etex      default

    latex     -l

    pdfetex   -p

    pdflatex  -l -p

If the -F option is used, options -l and -p need to be set if the engine

name does not contain "latex" and "pdf" respectively. For example, the

above four engines can be replaced by:

  -F "luatex --output-format=dvi"

  -F "lualatex --output-format=dvi"

  -F "luatex" -p

  -F "lualatex" -p

 

function whoami ()

  print("This is musixtex.lua version ".. VERSION .. ".")

 

function exists (filename, nolog)

  local f = io.open(filename, "r")

  if f then

    f:close()

    if not nolog then musixlog:write("Processing " .. filename,'\n' ) end

    return true

  else

    return false

  end

 

local dvips = "dvips -e0"

function defaults()

  xml2pmx = "xml2pmx"

  prepmx = "prepmx"

  pmx = "pmxab"

  autosp = "autosp"

  tex = "etex"

  musixflx = "musixflx"

  dvi = dvips

  ps2pdf = "ps2pdf"

  cleanup = true  -- clean up intermediate and log files

  index = false

  latex = false

  force_engine = false -- indicates whether -F is specified

  override = ""  

  passes = 2

  quiet = ""     -- set by "-q"

end  

 

 

if #arg == 0 then

  whoami()

  usage()

  os.exit(0)

 

 

musixlog = io.open("musixtex.log","w")

if not musixlog then

   print"!! Can't open files for writing in current directory, aborting"

   os.exit(1)

 

 

print = function(...)

   orig_print(...)

   musixlog:write(...,"\n") -- only the first argument gets written!

 

local orig_remove = os.remove

remove = function(filename)  

  if exists(filename,"nolog") then

    musixlog:write("  removing ",filename,"\n")

    return orig_remove(filename)

  end

 

local orig_execute = os.execute

execute = function(command)

  musixlog:write("  ",command,"\n")

  return orig_execute(command .. quiet)

 

function report_warnings(filename,pattern)

  local log = io.open(filename)

  if not log then

    print("! No file "..filename)

    return

  end

  for line in log:lines() do

    if line:match(pattern) then

      musixlog:write("!  "..line,"\n")

    end

  end

end

 

function report_error(filename)

  local log = io.open(filename)

  if not log then

    print("! No file "..filename)

    return

  end

  local trigger = false

  for line in log:lines() do

    if trigger and line:match"^!" then

      -- report just the first error  

      break

    end

    trigger = trigger or line:match"^!"

    if trigger then

      io.stderr:write("!  "..line,"\n")

    end

  end

end

 

function process_option(this_arg)

  if this_arg == "-v" or this_arg == "-version" or this_arg == "--version" then

    os.exit(0)

  elseif this_arg == "-h" or this_arg == "-help" or this_arg == "--help" then

    usage()

    os.exit(0)

  elseif this_arg == "-l" then

    latex = true

    override = override .. 'l'

  elseif this_arg == "-p" then

    dvi = nil

    override = override .. 'p'

  elseif this_arg == "-d" then

    dvi = "dvipdfm"; ps2pdf = nil

  elseif this_arg == "-D" then

    narg = narg+1

    dvi = arg[narg]

  elseif this_arg == "-c" then

    pmx = "pmxchords"

  elseif this_arg == "-F" then

    narg = narg+1

    tex = arg[narg]

    force_engine = true

  elseif this_arg == "-s" then

    dvi = false; ps2pdf = nil; protect.dvi = true

  elseif this_arg == "-g" then

    dvi = dvips; ps2pdf = nil; protect.ps = true

  elseif this_arg == "-i" then

    cleanup = false

  elseif this_arg == "-x" then

    index = true

  elseif this_arg == "-1" then

    passes = 1

  elseif this_arg == "-f" then

    defaults()

  elseif this_arg == "-t" then

    tex, dvi, ps2pdf = nil,nil,nil

    protect.tex = true

  elseif this_arg == "-m" then

    pmx, tex, dvi, ps2pdf = nil,nil,nil,nil

    protect.pmx = true

  elseif this_arg == "-M" then

    narg = narg+1

    prepmx = arg[narg]

  elseif this_arg == "-A" then

    narg = narg+1

    autosp = arg[narg]

  elseif this_arg == "-L" then

    narg = narg+1

    xml2pmx = arg[narg]

  elseif this_arg == "-q" then

    if not tempname then

      tempname = tempname or os.tmpname()

      print("Redirecting screen output to "..tempname)

    end

    if dvi == dvips then dvi = dvi .. " -q" end

    quiet = " >> " .. tempname

  elseif this_arg == "-P" then

    narg = narg+1

    ps2pdf = arg[narg]

  elseif this_arg == "-X" then

    narg = narg+1

    pmx = arg[narg]

  else

    print("! Unknown option "..this_arg.." ignored")

  end

 

function find_file(this_arg)

  basename, extension = this_arg:match"(.*)%.(.*)"  

  extensions = {["xml"] = true, ["mtx"] = true, ["pmx"] = true, ["aspc"] = true, ["tex"] = true, ["ltx"] = true}

  if extensions[extension] then

    return basename, extension

  end

  basename, extension  = this_arg, null

  for ext in ("xml,mtx,pmx,aspc,tex,ltx"):gmatch"[^,]+" do

    if exists (basename .. "." .. ext) then

      extension = ext

      break

    end

  end

  if extension == null then

    print("!! No file " .. basename .. ".[xml|mtx|pmx|aspc|tex|ltx]")

    exit_code = exit_code+1

    return

  end

  return basename, extension

 

function preprocess(basename,extension)

  if not (basename and extension) then return end

  if extension == "xml" then

    if execute(xml2pmx .. " " .. basename .. ".xml" .. " " .. basename .. ".pmx" ) == 0 then

      extension = "pmx"

    else

      print ("!! xml2pmx preprocessing of " .. basename .. ".xml fails.")

      return

    end

  elseif extension == "mtx" then

    if execute(prepmx .. " " .. basename ) == 0 then

      extension = "pmx"

    else

      print ("!! prepmx preprocessing of " .. basename .. ".mtx fails.")

      return

    end

  end

  if extension == "pmx" then

    local OK = true

    if pmx then

      local code = execute(pmx .. " " .. basename)

      local pmxaerr = io.open("pmxaerr.dat", "r")

      if (not pmxaerr) then

        OK = false

        print("!! No pmx log file.")

      else

        extension = "tex"

        local linebuf = pmxaerr:read()

        local err = tonumber(linebuf)

        if (code == 0) then

          if err ~=0 then

            print ("!  pmx produced a warning on line "..err..

                " of "..basename..".pmx")

          end

        else

          OK = false

          print ("!! pmx processing of " .. basename .. ".pmx fails.")

        end

        pmxaerr:close()

      end

    end

    if not OK then

      exit_code = exit_code+1

      return

    end

  end

  if extension == "aspc" then

    if execute (autosp .. " " .. basename .. ".aspc" ) == 0 then

      if exists ( basename .. ".ltx")

        then extension = "ltx"

        else extension = "tex"

      end

    else

      print ("!! autosp preprocessing of " .. basename .. ".aspc fails.")

      exit_code = exit_code+1

      return

    end      

  end

  return extension

 

function tex_process(tex,basename,extension)

  if not (extension == "tex" or extension == "ltx") or not tex then return end

  remove(basename .. ".mx1")

  remove(basename .. ".mx2")

  local filename = basename .. "." ..extension

  local latex = latex

  if extension == "ltx" then

    if not force_engine and not latex then

      if dvi then tex = "latex" else tex = "pdflatex" end

    end

    latex = true

  end

  if quiet ~= "" then

    tex = tex .. " -interaction batchmode"

  end

  local OK = (execute(tex .. " " .. filename) == 0)

  if passes ~= 1 then

    OK = OK and (execute(musixflx .. " " .. basename) == 0)

      and (execute(tex .. " " .. filename) == 0)

    if latex and index then

      OK = OK and (execute("makeindex -q " .. basename) == 0)

              and (execute(tex .. " " .. filename) == 0)

      if exists (basename .. ".toc","nolog") then

        -- an extra line for the index will have been added

        OK = OK and (execute(tex .. " " .. filename) == 0)

        -- there is a tiny possibility that the extra line for the index

        -- has changed the pagination. If you feel this should not be

        -- ignored, here are the possibilities:

        --   a. Do an extra TeX pass regardless.

        --   b. Provide a user option -4 to force the extra pass.

        --   c. Compare aux files to find out.

      end

    end

  end

  if (quiet ~= "") and not OK then

    report_error(basename..".log")

  end

  if OK and latex then

    report_warnings(basename..".log","LaTeX.*Warning")

  end

  if dvi then OK = OK and (execute(dvi .. " " .. basename) == 0) end

  if dvi and ps2pdf then

    OK = OK and (execute(ps2pdf .. " " .. basename .. ".ps") == 0)

    if OK then

      print(basename .. ".pdf generated by " .. ps2pdf .. ".")

    end

  end

  if not OK then

    print("!! Processing of " .. filename .. " fails.\n")

    exit_code = exit_code+1

  end

 

 

logtargets =  {

mtxtex = {"mtx%.tex","mtxTeX"},

mtxlatex = {"mtxlatex%.sty","mtxLaTeX"},

pmxtex = {"pmx%.tex","PMX"},

musixtex = {"musixtex%.tex","MusiXTeX"},

musixltx = {"musixltx%.tex","MusiXLaTeX"},

musixlyr = {"musixlyr%.tex","MusiXLYR"}

 

capturetargets = {

MTx = "This is (M%-Tx.->)",

PMX = "This is (PMX[^\n]+)",

pdftex = "This is (pdfTeX[^\n]+)",

musixflx = "Musixflx%S+",

autosp = "This is autosp.*$",

index = "autosp,MTx,PMX,musixflx,pdftex"

 

function report_texfiles(logname)

  local log = logname and io.open(logname)

  if not log then return end

  local lines =

    {"---   TeX files actually included according to "..logname.."   ---"}

  log = log:read"*a"

  for pos,filename in log:gmatch"%(()(%.?[/]%a[%-/%.%w\n]+)" do

    local hit

    repeat  

      local oldfilename = filename

      filename = oldfilename:match"[^\n]+"   -- up to next line break

      hit = io.open(filename)                -- success if the file exists

      if hit then break end

      filename = oldfilename:gsub("\n","",1) -- remove line break

    until filename==oldfilename

    if hit then

      for target,sig in pairs(logtargets) do

        if filename:match(sig[1]) then

          local i,j = log:find(sig[2].."[^\n]+",pos)          

          if j then lines[#lines+1] = filename.."\n  "..log:sub(i,j) end

        end

      end

    end

  end

  return table.concat(lines,'\n').."\n"

end  

 

function report_versions(tempname)

  if not tempname then return end  -- only available with -q

  local logs = io.open(tempname)

  if not logs then

     musixlog:write ("No version information: could not open "..tempname)

     return

  end

  local versions = {}

  musixlog:write("---   Programs actually executed according to "..tempname.."   ---\n")

  for line in logs:lines() do

    for target in capturetargets.index:gmatch"[^,]+" do

      if not versions[target] then

        local found = line:match(capturetargets[target])

        if found then

          versions[target] = found

          musixlog:write(found,"\n")

        end

      end

    end

  end

  logs:close()

  return

 

 

whoami()

 

defaults()

 

exit_code = 0

narg = 1

protect = {}  -- extensions not to be deleted, even if cleanup requested

 

  this_arg = arg[narg]

  if this_arg:match"^%-" then process_option(this_arg)

  else

    basename, extension = find_file(this_arg)  -- nil,nil if not found

    if tex then -- tex output enabled, now select engine

      if tex:match"pdf" then dvi = nil end

      if not dvi then ps2pdf = nil end

      -- .ltx extension will be taken into account later, in `process`

      -- deduce tex/latex from current engine name if -l is not specified

      if not override:match"l" then latex = tex:match"latex" end

      if not force_engine then -- select appropriate default engine

        if latex then

          if dvi==nil then tex = "pdflatex" else tex = "latex" end

        else

          if dvi==nil then tex = "pdfetex" else tex = "etex" end

        end  

      end

    end

    extension = preprocess(basename, extension)

    tex_process(tex,basename,extension)

    if basename and io.open(basename..".log") then -- to be printed later

      versions = report_texfiles(basename..".log")

    end

    if basename and cleanup then

      remove("pmxaerr.dat")

      for ext in ("mx1,mx2,dvi,ps,idx,log,ilg,pml"):gmatch"[^,]+" do

        if not protect[ext] then remove(basename.."."..ext)

        end

      end

    end

    protect = {}

  end

  narg = narg+1

until narg > #arg

 

if versions then musixlog:write(versions) end

report_versions(tempname)

musixlog:close()

os.exit( exit_code )