lib/configure.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #
   4 # file configure.py
   5 # This file is part of LyX, the document processor.
   6 # Licence details can be found in the file COPYING.
   7
   8 # \author Bo Peng
   9 # Full author contact details are available in file CREDITS.
  10
  11 from __future__ import print_function
  12 import glob, logging, os, errno, re, shutil, subprocess, sys, stat
  13
  14 # set up logging
  15 logging.basicConfig(level = logging.DEBUG,
  16     format = '%(levelname)s: %(message)s', # ignore application name
  17     filename = 'configure.log',
  18     filemode = 'w')
  19 #
  20 # Add a handler to log to console
  21 console = logging.StreamHandler()
  22 console.setLevel(logging.INFO) # the console only print out general information
  23 formatter = logging.Formatter('%(message)s') # only print out the message itself
  24 console.setFormatter(formatter)
  25 logger = logging.getLogger('LyX')
  26 logger.addHandler(console)
  27
  28 def writeToFile(filename, lines, append = False):
  29     " utility function: write or append lines to filename "
  30     if append:
  31         file = open(filename, 'a')
  32     else:
  33         file = open(filename, 'w')
  34     file.write(lines)
  35     file.close()
  36
  37
  38 def addToRC(lines):
  39     ''' utility function: shortcut for appending lines to outfile
  40         add newline at the end of lines.
  41     '''
  42     if lines.strip() != '':
  43         writeToFile(outfile, lines + '\n', append = True)
  44         logger.debug('Add to RC:\n' + lines + '\n\n')
  45
  46
  47 def removeFiles(filenames):
  48     '''utility function: 'rm -f'
  49         ignore errors when file does not exist, or is a directory.
  50     '''
  51     for file in filenames:
  52         try:
  53             os.remove(file)
  54             logger.debug('Removing file %s' % file)
  55         except OSError as e:
  56             if e.errno == errno.ENOENT: # no such file or directory
  57                 logger.debug('No need to remove file %s (it does not exists)' % file)
  58             elif e.errno == errno.EISDIR: # is a directory
  59                 logger.debug('Failed to remove file %s (it is a directory)' % file)
  60             else:
  61                 logger.debug('Failed to remove file %s' % file)
  62             pass
  63
  64
  65 def cmdOutput(cmd, async = False):
  66     '''utility function: run a command and get its output as a string
  67         cmd: command to run
  68         async: if False, return whole output as a string, otherwise
  69                return the stdout handle from which the output can be
  70                read (the caller is then responsible for closing it)
  71     '''
  72     if os.name == 'nt':
  73         b = False
  74         if sys.version_info[0] < 3:
  75             cmd = 'cmd /d /c pushd ' + shortPath(os.getcwdu()) + '&' + cmd
  76         else:
  77             cmd = 'cmd /d /c pushd ' + shortPath(os.getcwd()) + '&' + cmd
  78     else:
  79         b = True
  80     pipe = subprocess.Popen(cmd, shell=b, close_fds=b, stdin=subprocess.PIPE,
  81                             stdout=subprocess.PIPE, universal_newlines=True)
  82     pipe.stdin.close()
  83     if async:
  84         return pipe.stdout
  85     output = pipe.stdout.read()
  86     pipe.stdout.close()
  87     return output.strip()
  88
  89
  90 def shortPath(path):
  91     ''' On Windows, return the short version of "path" if possible '''
  92     if os.name == 'nt':
  93         from ctypes import windll, create_unicode_buffer
  94         GetShortPathName = windll.kernel32.GetShortPathNameW
  95         shortlen = GetShortPathName(path, 0, 0)
  96         shortpath = create_unicode_buffer(shortlen)
  97         if GetShortPathName(path, shortpath, shortlen):
  98             return shortpath.value
  99     return path
 100
 101
 102 def setEnviron():
 103     ''' I do not really know why this is useful, but we might as well keep it.
 104         NLS nuisances.
 105         Only set these to C if already set.  These must not be set unconditionally
 106         because not all systems understand e.g. LANG=C (notably SCO).
 107         Fixing LC_MESSAGES prevents Solaris sh from translating var values in set!
 108         Non-C LC_CTYPE values break the ctype check.
 109     '''
 110     os.environ['LANG'] = os.getenv('LANG', 'C')
 111     os.environ['LC'] = os.getenv('LC_ALL', 'C')
 112     os.environ['LC_MESSAGE'] = os.getenv('LC_MESSAGE', 'C')
 113     os.environ['LC_CTYPE'] = os.getenv('LC_CTYPE', 'C')
 114
 115
 116 def copy_tree(src, dst, preserve_symlinks=False, level=0):
 117     ''' Copy an entire directory tree 'src' to a new location 'dst'.
 118
 119     Code inspired from distutils.copy_tree.
 120          Copying ignores non-regular files and the cache directory.
 121     Pipes may be present as leftovers from LyX for lyx-server.
 122
 123     If 'preserve_symlinks' is true, symlinks will be
 124     copied as symlinks (on platforms that support them!); otherwise
 125     (the default), the destination of the symlink will be copied.
 126     '''
 127
 128     if not os.path.isdir(src):
 129         raise FileError("cannot copy tree '%s': not a directory" % src)
 130     try:
 131         names = os.listdir(src)
 132     except os.error as oserror:
 133         (errno, errstr) = oserror.args
 134         raise FileError("error listing files in '%s': %s" % (src, errstr))
 135
 136     if not os.path.isdir(dst):
 137         os.makedirs(dst)
 138
 139     outputs = []
 140
 141     for name in names:
 142         src_name = os.path.join(src, name)
 143         dst_name = os.path.join(dst, name)
 144         if preserve_symlinks and os.path.islink(src_name):
 145             link_dest = os.readlink(src_name)
 146             os.symlink(link_dest, dst_name)
 147             outputs.append(dst_name)
 148         elif level == 0 and name == 'cache':
 149             logger.info("Skip cache %s", src_name)
 150         elif os.path.isdir(src_name):
 151             outputs.extend(
 152                 copy_tree(src_name, dst_name, preserve_symlinks, level=(level + 1)))
 153         elif stat.S_ISREG(os.stat(src_name).st_mode) or os.path.islink(src_name):
 154             shutil.copy2(src_name, dst_name)
 155             outputs.append(dst_name)
 156         else:
 157             logger.info("Ignore non-regular file %s", src_name)
 158
 159     return outputs
 160
 161
 162 def checkUpgrade():
 163     ''' Check for upgrade from previous version '''
 164     cwd = os.getcwd()
 165     basename = os.path.basename( cwd )
 166     lyxrc = os.path.join(cwd, outfile)
 167     if not os.path.isfile( lyxrc ) and basename.endswith( version_suffix ) :
 168         logger.info('Checking for upgrade from previous version.')
 169         parent = os.path.dirname(cwd)
 170         appname = basename[:(-len(version_suffix))]
 171         for version in ['-2.1', '-2.0', '-1.6' ]:
 172             logger.debug('Checking for upgrade from previous version ' + version)
 173             previous = os.path.join(parent, appname + version)
 174             logger.debug('previous = ' + previous)
 175             if os.path.isdir( previous ):
 176                 logger.info('Found directory "%s".', previous)
 177                 copy_tree( previous, cwd, True )
 178                 logger.info('Content copied to directory "%s".', cwd)
 179                 return
 180
 181
 182 def createDirectories():
 183     ''' Create the build directories if necessary '''
 184     for dir in ['bind', 'clipart', 'doc', 'examples', 'images', 'kbd',
 185         'layouts', 'scripts', 'templates', 'ui' ]:
 186         if not os.path.isdir( dir ):
 187             try:
 188                 os.mkdir( dir)
 189                 logger.debug('Create directory %s.' % dir)
 190             except:
 191                 logger.error('Failed to create directory %s.' % dir)
 192                 sys.exit(1)
 193
 194
 195 def checkTeXPaths():
 196     ''' Determine the path-style needed by the TeX engine on Win32 (Cygwin) '''
 197     windows_style_tex_paths = ''
 198     if LATEX == '':
 199         return windows_style_tex_paths
 200     if os.name == 'nt' or sys.platform == 'cygwin':
 201         from tempfile import mkstemp
 202         fd, tmpfname = mkstemp(suffix='.ltx')
 203         if os.name == 'nt':
 204             encoding = sys.getfilesystemencoding()
 205             if sys.version_info[0] < 3:
 206                 inpname = shortPath(unicode(tmpfname, encoding)).replace('\\', '/')
 207             else:
 208                 inpname = shortPath(tmpfname).replace('\\', '/')
 209         else:
 210             inpname = cmdOutput('cygpath -m ' + tmpfname)
 211         logname = os.path.basename(re.sub("(?i).ltx", ".log", inpname))
 212         inpname = inpname.replace('~', '\\string~')
 213         os.write(fd, b'\\relax')
 214         os.close(fd)
 215         latex_out = cmdOutput(r'latex "\nonstopmode\input{%s}\makeatletter\@@end"'
 216                               % inpname)
 217         if 'Error' in latex_out:
 218             latex_out = cmdOutput(r'latex "\nonstopmode\input{\"%s\"}\makeatletter\@@end"'
 219                                   % inpname)
 220         if 'Error' in latex_out:
 221             logger.warning("configure: TeX engine needs posix-style paths in latex files")
 222             windows_style_tex_paths = 'false'
 223         else:
 224             logger.info("configure: TeX engine needs windows-style paths in latex files")
 225             windows_style_tex_paths = 'true'
 226         removeFiles([tmpfname, logname, 'texput.log'])
 227     return windows_style_tex_paths
 228
 229
 230 ## Searching some useful programs
 231 def checkProg(description, progs, rc_entry = [], path = [], not_found = ''):
 232     '''
 233         This function will search a program in $PATH plus given path
 234         If found, return directory and program name (not the options).
 235
 236         description: description of the program
 237
 238         progs: check programs, for each prog, the first word is used
 239             for searching but the whole string is used to replace
 240             %% for a rc_entry. So, feel free to add '$$i' etc for programs.
 241
 242         path: additional paths (will be prepended to the program name)
 243
 244         rc_entry: entry to outfile, can be
 245             1. emtpy: no rc entry will be added
 246             2. one pattern: %% will be replaced by the first found program,
 247                 or '' if no program is found.
 248             3. several patterns for each prog and not_found. This is used
 249                 when different programs have different usages. If you do not
 250                 want not_found entry to be added to the RC file, you can specify
 251                 an entry for each prog and use '' for the not_found entry.
 252
 253         not_found: the value that should be used instead of '' if no program
 254             was found
 255
 256     '''
 257     # one rc entry for each progs plus not_found entry
 258     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 259         logger.error("rc entry should have one item or item "
 260                      "for each prog and not_found.")
 261         sys.exit(2)
 262     logger.info('checking for ' + description + '...')
 263     ## print '(' + ','.join(progs) + ')',
 264     additional_path = path
 265     path = os.environ["PATH"].split(os.pathsep) + additional_path
 266     extlist = ['']
 267     if "PATHEXT" in os.environ:
 268         extlist = extlist + os.environ["PATHEXT"].split(os.pathsep)
 269     global java, perl
 270     for idx in range(len(progs)):
 271         # ac_prog may have options, ac_word is the command name
 272         ac_prog = progs[idx]
 273         ac_word = ac_prog.split(' ')[0]
 274         if (ac_word.endswith('.class') or ac_word.endswith('.jar')) and java == '':
 275             continue
 276         if ac_word.endswith('.pl') and perl == '':
 277             continue
 278         msg = '+checking for "' + ac_word + '"... '
 279         for ac_dir in path:
 280             if hasattr(os, "access") and not os.access(ac_dir, os.F_OK):
 281                 continue
 282             for ext in extlist:
 283                 if os.path.isfile( os.path.join(ac_dir, ac_word + ext) ):
 284                     logger.info(msg + ' yes')
 285                     # deal with java and perl
 286                     if ac_word.endswith('.class'):
 287                         ac_prog = ac_prog.replace(ac_word, r'%s \"%s\"'
 288                                     % (java, os.path.join(ac_dir, ac_word[:-6])))
 289                     elif ac_word.endswith('.jar'):
 290                         ac_prog = ac_prog.replace(ac_word, r'%s -jar \"%s\"'
 291                                     % (java, os.path.join(ac_dir, ac_word)))
 292                     elif ac_word.endswith('.pl'):
 293                         ac_prog = ac_prog.replace(ac_word, r'%s -w \"%s\"'
 294                                     % (perl, os.path.join(ac_dir, ac_word)))
 295                     elif ac_dir in additional_path:
 296                         ac_prog = ac_prog.replace(ac_word, r'\"%s\"'
 297                                     % (os.path.join(ac_dir, ac_word)))
 298                     # write rc entries for this command
 299                     if len(rc_entry) == 1:
 300                         addToRC(rc_entry[0].replace('%%', ac_prog))
 301                     elif len(rc_entry) > 1:
 302                         addToRC(rc_entry[idx].replace('%%', ac_prog))
 303                     return [ac_dir, ac_word]
 304         # if not successful
 305         logger.info(msg + ' no')
 306     # write rc entries for 'not found'
 307     if len(rc_entry) > 0:  # the last one.
 308         addToRC(rc_entry[-1].replace('%%', not_found))
 309     return ['', not_found]
 310
 311
 312 def checkProgAlternatives(description, progs, rc_entry = [],
 313                           alt_rc_entry = [], path = [], not_found = ''):
 314     '''
 315         The same as checkProg, but additionally, all found programs will be added
 316         as alt_rc_entries
 317     '''
 318     # one rc entry for each progs plus not_found entry
 319     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 320         logger.error("rc entry should have one item or item for each prog and not_found.")
 321         sys.exit(2)
 322     logger.info('checking for ' + description + '...')
 323     ## print '(' + ','.join(progs) + ')',
 324     additional_path = path
 325     path = os.environ["PATH"].split(os.pathsep) + additional_path
 326     extlist = ['']
 327     if "PATHEXT" in os.environ:
 328         extlist = extlist + os.environ["PATHEXT"].split(os.pathsep)
 329     found_prime = False
 330     real_ac_dir = ''
 331     real_ac_word = not_found
 332     global java, perl
 333     for idx in range(len(progs)):
 334         # ac_prog may have options, ac_word is the command name
 335         ac_prog = progs[idx]
 336         ac_word = ac_prog.split(' ')[0]
 337         if (ac_word.endswith('.class') or ac_word.endswith('.jar')) and java == '':
 338             continue
 339         if ac_word.endswith('.pl') and perl == '':
 340             continue
 341         msg = '+checking for "' + ac_word + '"... '
 342         found_alt = False
 343         for ac_dir in path:
 344             if hasattr(os, "access") and not os.access(ac_dir, os.F_OK):
 345                 continue
 346             for ext in extlist:
 347                 if os.path.isfile( os.path.join(ac_dir, ac_word + ext) ):
 348                     logger.info(msg + ' yes')
 349                     pr = re.compile(r'(\\\S+)(.*)$')
 350                     m = None
 351                     # deal with java and perl
 352                     if ac_word.endswith('.class'):
 353                         ac_prog = ac_prog.replace(ac_word, r'%s \"%s\"'
 354                                     % (java, os.path.join(ac_dir, ac_word[:-6])))
 355                     elif ac_word.endswith('.jar'):
 356                         ac_prog = ac_prog.replace(ac_word, r'%s -jar \"%s\"'
 357                                     % (java, os.path.join(ac_dir, ac_word)))
 358                     elif ac_word.endswith('.pl'):
 359                         ac_prog = ac_prog.replace(ac_word, r'%s -w \"%s\"'
 360                                     % (perl, os.path.join(ac_dir, ac_word)))
 361                     elif ac_dir in additional_path:
 362                         ac_prog = ac_prog.replace(ac_word, r'\"%s\"'
 363                                     % (os.path.join(ac_dir, ac_word)))
 364                     # write rc entries for this command
 365                     if found_prime == False:
 366                         if len(rc_entry) == 1:
 367                             addToRC(rc_entry[0].replace('%%', ac_prog))
 368                         elif len(rc_entry) > 1:
 369                             addToRC(rc_entry[idx].replace('%%', ac_prog))
 370                         real_ac_dir = ac_dir
 371                         real_ac_word = ac_word
 372                         found_prime = True
 373                     if len(alt_rc_entry) == 1:
 374                         alt_rc = alt_rc_entry[0]
 375                         if alt_rc == "":
 376                             # if no explicit alt_rc is given, construct one
 377                             m = pr.match(rc_entry[0])
 378                             if m:
 379                                 alt_rc = m.group(1) + "_alternatives" + m.group(2)
 380                         addToRC(alt_rc.replace('%%', ac_prog))
 381                     elif len(alt_rc_entry) > 1:
 382                         alt_rc = alt_rc_entry[idx]
 383                         if alt_rc == "":
 384                             # if no explicit alt_rc is given, construct one
 385                             m = pr.match(rc_entry[idx])
 386                             if m:
 387                                 alt_rc = m.group(1) + "_alternatives" + m.group(2)
 388                         addToRC(alt_rc.replace('%%', ac_prog))
 389                     found_alt = True
 390                     break
 391             if found_alt:
 392                 break
 393         if found_alt == False:
 394             # if not successful
 395             logger.info(msg + ' no')
 396     if found_prime:
 397         return [real_ac_dir, real_ac_word]
 398     # write rc entries for 'not found'
 399     if len(rc_entry) > 0:  # the last one.
 400         addToRC(rc_entry[-1].replace('%%', not_found))
 401     return ['', not_found]
 402
 403
 404 def addAlternatives(rcs, alt_type):
 405     '''
 406         Returns a \\prog_alternatives string to be used as an alternative
 407         rc entry.  alt_type can be a string or a list of strings.
 408     '''
 409     r = re.compile(r'\\Format (\S+).*$')
 410     m = None
 411     alt = ''
 412     alt_token = '\\%s_alternatives '
 413     if isinstance(alt_type, str):
 414         alt_tokens = [alt_token % alt_type]
 415     else:
 416         alt_tokens = [alt_token % s for s in alt_type]
 417     for idxx in range(len(rcs)):
 418         if len(rcs) == 1:
 419             m = r.match(rcs[0])
 420             if m:
 421                 alt = '\n'.join([s + m.group(1) + ' "%%"' for s in alt_tokens])
 422         elif len(rcs) > 1:
 423             m = r.match(rcs[idxx])
 424             if m:
 425                 if idxx > 0:
 426                     alt += '\n'
 427                 alt += '\n'.join([s + m.group(1) + ' "%%"' for s in alt_tokens])
 428     return alt
 429
 430
 431 def listAlternatives(progs, alt_type, rc_entry = []):
 432     '''
 433         Returns a list of \\prog_alternatives strings to be used as alternative
 434         rc entries.  alt_type can be a string or a list of strings.
 435     '''
 436     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 437         logger.error("rc entry should have one item or item for each prog and not_found.")
 438         sys.exit(2)
 439     alt_rc_entry = []
 440     for idx in range(len(progs)):
 441         if len(rc_entry) == 1:
 442             rcs = rc_entry[0].split('\n')
 443             alt = addAlternatives(rcs, alt_type)
 444             alt_rc_entry.insert(0, alt)
 445         elif len(rc_entry) > 1:
 446             rcs = rc_entry[idx].split('\n')
 447             alt = addAlternatives(rcs, alt_type)
 448             alt_rc_entry.insert(idx, alt)
 449     return alt_rc_entry
 450
 451
 452 def checkViewer(description, progs, rc_entry = [], path = []):
 453     ''' The same as checkProgAlternatives, but for viewers '''
 454     alt_rc_entry = listAlternatives(progs, 'viewer', rc_entry)
 455     return checkProgAlternatives(description, progs, rc_entry,
 456                                  alt_rc_entry, path, not_found = 'auto')
 457
 458
 459 def checkEditor(description, progs, rc_entry = [], path = []):
 460     ''' The same as checkProgAlternatives, but for editors '''
 461     alt_rc_entry = listAlternatives(progs, 'editor', rc_entry)
 462     return checkProgAlternatives(description, progs, rc_entry,
 463                                  alt_rc_entry, path, not_found = 'auto')
 464
 465
 466 def checkViewerNoRC(description, progs, rc_entry = [], path = []):
 467     ''' The same as checkViewer, but do not add rc entry '''
 468     alt_rc_entry = listAlternatives(progs, 'viewer', rc_entry)
 469     rc_entry = []
 470     return checkProgAlternatives(description, progs, rc_entry,
 471                                  alt_rc_entry, path, not_found = 'auto')
 472
 473
 474 def checkEditorNoRC(description, progs, rc_entry = [], path = []):
 475     ''' The same as checkViewer, but do not add rc entry '''
 476     alt_rc_entry = listAlternatives(progs, 'editor', rc_entry)
 477     rc_entry = []
 478     return checkProgAlternatives(description, progs, rc_entry,
 479                                  alt_rc_entry, path, not_found = 'auto')
 480
 481
 482 def checkViewerEditor(description, progs, rc_entry = [], path = []):
 483     ''' The same as checkProgAlternatives, but for viewers and editors '''
 484     alt_rc_entry = listAlternatives(progs, ['editor', 'viewer'], rc_entry)
 485     return checkProgAlternatives(description, progs, rc_entry,
 486                                  alt_rc_entry, path, not_found = 'auto')
 487
 488
 489 def checkDTLtools():
 490     ''' Check whether DTL tools are available (Windows only) '''
 491     # Find programs! Returned path is not used now
 492     if ((os.name == 'nt' or sys.platform == 'cygwin') and
 493             checkProg('DVI to DTL converter', ['dv2dt']) != ['', ''] and
 494             checkProg('DTL to DVI converter', ['dt2dv']) != ['', '']):
 495         dtl_tools = True
 496     else:
 497         dtl_tools = False
 498     return dtl_tools
 499
 500 def checkInkscape():
 501     ''' Check whether Inkscape is available and return the full path (Windows only) '''
 502     ''' On Mac OS (darwin) a wrapper is used - therefore the version is checked '''
 503     ''' The answer of the real inkscape is validated and a fake binary used if this fails '''
 504     if sys.platform == 'darwin':
 505         version_string = cmdOutput("inkscape --version")
 506         match = re.match('^Inkscape', version_string)
 507         if match:
 508             return 'inkscape'
 509         else:
 510             return 'inkscape-binary'
 511     elif os.name != 'nt':
 512         return 'inkscape'
 513     if sys.version_info[0] < 3:
 514         import _winreg as winreg
 515     else:
 516         import winreg
 517     aReg = winreg.ConnectRegistry(None, winreg.HKEY_CLASSES_ROOT)
 518     try:
 519         aKey = winreg.OpenKey(aReg, r"inkscape.svg\DefaultIcon")
 520         val = winreg.QueryValueEx(aKey, "")
 521         return str(val[0]).split('"')[1].replace('.exe', '')
 522     except EnvironmentError:
 523         try:
 524             aKey = winreg.OpenKey(aReg, r"Applications\inkscape.exe\shell\open\command")
 525             val = winreg.QueryValueEx(aKey, "")
 526             return str(val[0]).split('"')[1].replace('.exe', '')
 527         except EnvironmentError:
 528             return 'inkscape'
 529
 530 def checkLatex(dtl_tools):
 531     ''' Check latex, return lyx_check_config '''
 532     path, LATEX = checkProg('a Latex2e program', ['latex $$i', 'latex2e $$i'])
 533     path, PPLATEX = checkProg('a DVI postprocessing program', ['pplatex $$i'])
 534     #-----------------------------------------------------------------
 535     path, PLATEX = checkProg('pLaTeX, the Japanese LaTeX', ['platex $$i'])
 536     if PLATEX != '':
 537         # check if PLATEX is pLaTeX2e
 538         writeToFile('chklatex.ltx', r'\nonstopmode\makeatletter\@@end')
 539         # run platex on chklatex.ltx and check result
 540         if cmdOutput(PLATEX + ' chklatex.ltx').find('pLaTeX2e') != -1:
 541             # We have the Japanese pLaTeX2e
 542             addToRC(r'\converter platex   dvi       "%s"   "latex=platex"' % PLATEX)
 543         else:
 544             PLATEX = ''
 545             removeFiles(['chklatex.ltx', 'chklatex.log'])
 546     #-----------------------------------------------------------------
 547     # use LATEX to convert from latex to dvi if PPLATEX is not available
 548     if PPLATEX == '':
 549         PPLATEX = LATEX
 550     if dtl_tools:
 551         # Windows only: DraftDVI
 552         addToRC(r'''\converter latex      dvi2       "%s"       "latex"
 553 \converter dvi2       dvi        "python -tt $$s/scripts/clean_dvi.py $$i $$o"  ""''' % PPLATEX)
 554     else:
 555         addToRC(r'\converter latex      dvi        "%s" "latex"' % PPLATEX)
 556     # no latex
 557     if LATEX != '':
 558         # Check if latex is usable
 559         writeToFile('chklatex.ltx', r'''
 560 \nonstopmode
 561 \ifx\undefined\documentclass\else
 562   \message{ThisIsLaTeX2e}
 563 \fi
 564 \makeatletter
 565 \@@end
 566 ''')
 567         # run latex on chklatex.ltx and check result
 568         if cmdOutput(LATEX + ' chklatex.ltx').find('ThisIsLaTeX2e') != -1:
 569             # valid latex2e
 570             return LATEX
 571         else:
 572             logger.warning("Latex not usable (not LaTeX2e) ")
 573         # remove temporary files
 574         removeFiles(['chklatex.ltx', 'chklatex.log'])
 575     return ''
 576
 577
 578 def checkLuatex():
 579     ''' Check if luatex is there '''
 580     path, LUATEX = checkProg('LuaTeX', ['lualatex $$i'])
 581     path, DVILUATEX = checkProg('LuaTeX (DVI)', ['dvilualatex $$i'])
 582     if LUATEX != '':
 583         addToRC(r'\converter luatex      pdf5       "%s"        "latex=lualatex"' % LUATEX)
 584     if DVILUATEX != '':
 585         addToRC(r'\converter dviluatex   dvi3        "%s"       "latex=dvilualatex"' % DVILUATEX)
 586
 587
 588 def checkModule(module):
 589     ''' Check for a Python module, return the status '''
 590     msg = 'checking for "' + module + ' module"... '
 591     try:
 592       __import__(module)
 593       logger.info(msg + ' yes')
 594       return True
 595     except ImportError:
 596       logger.info(msg + ' no')
 597       return False
 598
 599
 600 texteditors = ['xemacs', 'gvim', 'kedit', 'kwrite', 'kate',
 601                'nedit', 'gedit', 'geany', 'leafpad', 'mousepad',
 602                'xed', 'notepad', 'WinEdt', 'WinShell', 'PSPad']
 603
 604 def checkFormatEntries(dtl_tools):
 605     ''' Check all formats (\Format entries) '''
 606     checkViewerEditor('a Tgif viewer and editor', ['tgif'],
 607         rc_entry = [r'\Format tgif      "obj, tgo" Tgif                 "" "%%" "%%"    "vector"        "application/x-tgif"'])
 608     #
 609     checkViewerEditor('a FIG viewer and editor', ['xfig', 'jfig3-itext.jar', 'jfig3.jar'],
 610         rc_entry = [r'\Format fig        fig     FIG                    "" "%%" "%%"    "vector"        "application/x-xfig"'])
 611     #
 612     checkViewerEditor('a Dia viewer and editor', ['dia'],
 613         rc_entry = [r'\Format dia        dia     DIA                    "" "%%" "%%"    "vector,zipped=native", "application/x-dia-diagram"'])
 614     #
 615     checkViewerEditor('an OpenDocument drawing viewer and editor', ['libreoffice', 'lodraw', 'ooffice', 'oodraw', 'soffice'],
 616         rc_entry = [r'\Format odg        "odg, sxd" "OpenDocument drawing"   "" "%%"    "%%"    "vector,zipped=native"  "application/vnd.oasis.opendocument.graphics"'])
 617     #
 618     checkViewerEditor('a Grace viewer and editor', ['xmgrace'],
 619         rc_entry = [r'\Format agr        agr     Grace                  "" "%%" "%%"    "vector"        ""'])
 620     #
 621     checkViewerEditor('a FEN viewer and editor', ['xboard -lpf $$i -mode EditPosition'],
 622         rc_entry = [r'\Format fen        fen     FEN                    "" "%%" "%%"    ""      ""'])
 623     #
 624     checkViewerEditor('a SVG viewer and editor', [inkscape_name],
 625         rc_entry = [r'''\Format svg        "svg" SVG                "" "%%" "%%"        "vector"        "image/svg+xml"
 626 \Format svgz       "svgz" "SVG (compressed)" "" "%%" "%%"       "vector,zipped=native"  ""'''],
 627         path = [inkscape_path])
 628     #
 629     imageformats = r'''\Format bmp        bmp     BMP                    "" "%s"        "%s"    ""      "image/x-bmp"
 630 \Format gif        gif     GIF                    "" "%s"       "%s"    ""      "image/gif"
 631 \Format jpg       "jpg, jpeg" JPEG                "" "%s"       "%s"    ""      "image/jpeg"
 632 \Format pbm        pbm     PBM                    "" "%s"       "%s"    ""      "image/x-portable-bitmap"
 633 \Format pgm        pgm     PGM                    "" "%s"       "%s"    ""      "image/x-portable-graymap"
 634 \Format png        png     PNG                    "" "%s"       "%s"    ""      "image/x-png"
 635 \Format ppm        ppm     PPM                    "" "%s"       "%s"    ""      "image/x-portable-pixmap"
 636 \Format tiff       tif     TIFF                   "" "%s"       "%s"    ""      "image/tiff"
 637 \Format xbm        xbm     XBM                    "" "%s"       "%s"    ""      "image/x-xbitmap"
 638 \Format xpm        xpm     XPM                    "" "%s"       "%s"    ""      "image/x-xpixmap"'''
 639     path, iv = checkViewerNoRC('a raster image viewer',
 640         ['xv', 'gwenview', 'kview',
 641          'eog', 'xviewer', 'ristretto', 'gpicview', 'lximage-qt',
 642          'xdg-open', 'gimp-remote', 'gimp'],
 643         rc_entry = [imageformats])
 644     path, ie = checkEditorNoRC('a raster image editor',
 645         ['gimp-remote', 'gimp'], rc_entry = [imageformats])
 646     addToRC(imageformats % ((iv, ie)*10))
 647     #
 648     checkViewerEditor('a text editor', texteditors,
 649         rc_entry = [r'''\Format asciichess asc    "Plain text (chess output)"  "" ""    "%%"    ""      ""
 650 \Format docbook    sgml    DocBook                B  "" "%%"    "document,menu=export"  ""
 651 \Format docbook-xml xml   "DocBook (XML)"         "" "" "%%"    "document,menu=export"  "application/docbook+xml"
 652 \Format dot        dot    "Graphviz Dot"          "" "" "%%"    "vector"        "text/vnd.graphviz"
 653 \Format dviluatex  tex    "LaTeX (dviluatex)"     "" "" "%%"    "document,menu=export"  ""
 654 \Format platex     tex    "LaTeX (pLaTeX)"        "" "" "%%"    "document,menu=export"  ""
 655 \Format literate   nw      NoWeb                  N  "" "%%"    "document,menu=export"  ""
 656 \Format sweave     Rnw    "Sweave"                S  "" "%%"    "document,menu=export"  ""
 657 \Format sweave-ja  Rnw    "Sweave (Japanese)"     S  "" "%%"    "document,menu=export"  ""
 658 \Format r          R      "R/S code"              "" "" "%%"    "document,menu=export"  ""
 659 \Format knitr      Rnw    "Rnw (knitr)"           "" "" "%%"    "document,menu=export"  ""
 660 \Format knitr-ja   Rnw    "Rnw (knitr, Japanese)" "" "" "%%"    "document,menu=export"  ""
 661 \Format lilypond-book    lytex "LilyPond book (LaTeX)"   "" ""  "%%"    "document,menu=export"  ""
 662 \Format lilypond-book-ja lytex "LilyPond book (pLaTeX)"   "" "" "%%"    "document,menu=export"  ""
 663 \Format latex      tex    "LaTeX (plain)"         L  "" "%%"    "document,menu=export"  "text/x-tex"
 664 \Format luatex     tex    "LaTeX (LuaTeX)"        "" "" "%%"    "document,menu=export"  ""
 665 \Format pdflatex   tex    "LaTeX (pdflatex)"      "" "" "%%"    "document,menu=export"  ""
 666 \Format xetex      tex    "LaTeX (XeTeX)"         "" "" "%%"    "document,menu=export"  ""
 667 \Format latexclipboard tex "LaTeX (clipboard)"    "" "" "%%"    ""      ""
 668 \Format text       txt    "Plain text"            a  "" "%%"    "document,menu=export"  "text/plain"
 669 \Format text2      txt    "Plain text (pstotext)" "" "" "%%"    "document"      ""
 670 \Format text3      txt    "Plain text (ps2ascii)" "" "" "%%"    "document"      ""
 671 \Format text4      txt    "Plain text (catdvi)"   "" "" "%%"    "document"      ""
 672 \Format textparagraph txt "Plain Text, Join Lines" "" ""        "%%"    "document"      ""
 673 \Format beamer.info pdf.info   "Info (Beamer)"         "" ""   "%%"    "document,menu=export"   ""''' ])
 674    #Lilypond files have special editors, but fall back to plain text editors
 675     checkViewerEditor('a lilypond editor',
 676         ['frescobaldi'] + texteditors,
 677         rc_entry = [r'''\Format lilypond   ly     "LilyPond music"        "" "" "%%"    "vector"        "text/x-lilypond"''' ])
 678    #Spreadsheets using ssconvert from gnumeric
 679     checkViewer('gnumeric spreadsheet software', ['gnumeric'],
 680       rc_entry = [r'''\Format gnumeric gnumeric "Gnumeric spreadsheet" "" ""    "%%"   "document"       "application/x-gnumeric"
 681 \Format excel      xls    "Excel spreadsheet"      "" "" "%%"    "document"     "application/vnd.ms-excel"
 682 \Format excel2     xlsx   "MS Excel Office Open XML" "" "" "%%" "document"      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 683 \Format html_table html   "HTML Table (for spreadsheets)"      "" "" "%%"    "document" "text/html"
 684 \Format oocalc     ods    "OpenDocument spreadsheet" "" "" "%%"    "document"   "application/vnd.oasis.opendocument.spreadsheet"'''])
 685  #
 686     checkViewer('an HTML previewer', ['firefox', 'mozilla file://$$p$$i', 'netscape'],
 687         rc_entry = [r'\Format xhtml      xhtml   "LyXHTML"              y "%%" ""    "document,menu=export"     "application/xhtml+xml"'])
 688  #
 689     checkEditor('a BibTeX editor', ['jabref', 'JabRef',
 690         'pybliographic', 'bibdesk', 'gbib', 'kbib',
 691         'kbibtex', 'sixpack', 'bibedit', 'tkbibtex', 'TeXnicCenter'] +
 692         texteditors,
 693         rc_entry = [r'''\Format bibtex bib    "BibTeX"         "" ""    "%%"    ""      "text/x-bibtex"''' ])
 694     #
 695     #checkProg('a Postscript interpreter', ['gs'],
 696     #  rc_entry = [ r'\ps_command "%%"' ])
 697     checkViewer('a Postscript previewer',
 698                 ['kghostview', 'okular', 'qpdfview --unique',
 699                  'evince', 'xreader',
 700                  'gv', 'ghostview -swap', 'gsview64', 'gsview32'],
 701         rc_entry = [r'''\Format eps        eps     EPS                    "" "%%"       ""      "vector"        "image/x-eps"
 702 \Format eps2       eps    "EPS (uncropped)"       "" "%%"       ""      "vector"        ""
 703 \Format eps3       eps    "EPS (cropped)"         "" "%%"       ""      "document"      ""
 704 \Format ps         ps      Postscript             t  "%%"       ""      "document,vector,menu=export"   "application/postscript"'''])
 705     # for xdg-open issues look here: http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg151818.html
 706     # maybe use "bestApplication()" from https://github.com/jleclanche/python-mime
 707     # the MIME type is set for pdf6, because that one needs to be autodetectable by libmime
 708     checkViewer('a PDF previewer',
 709                 ['pdfview', 'kpdf', 'okular', 'qpdfview --unique',
 710                  'evince', 'xreader', 'kghostview', 'xpdf', 'SumatraPDF',
 711                  'acrobat', 'acroread', 'mupdf',
 712                  'gv', 'ghostview', 'AcroRd32', 'gsview64', 'gsview32'],
 713         rc_entry = [r'''\Format pdf        pdf    "PDF (ps2pdf)"          P  "%%"       ""      "document,vector,menu=export"   ""
 714 \Format pdf2       pdf    "PDF (pdflatex)"        F  "%%"       ""      "document,vector,menu=export"   ""
 715 \Format pdf3       pdf    "PDF (dvipdfm)"         m  "%%"       ""      "document,vector,menu=export"   ""
 716 \Format pdf4       pdf    "PDF (XeTeX)"           X  "%%"       ""      "document,vector,menu=export"   ""
 717 \Format pdf5       pdf    "PDF (LuaTeX)"          u  "%%"       ""      "document,vector,menu=export"   ""
 718 \Format pdf6       pdf    "PDF (graphics)"        "" "%%"       ""      "vector"        "application/pdf"
 719 \Format pdf7       pdf    "PDF (cropped)"         "" "%%"       ""      "document,vector"       ""
 720 \Format pdf8       pdf    "PDF (lower resolution)"         "" "%%"      ""      "document,vector"       ""'''])
 721     #
 722     checkViewer('a DVI previewer', ['xdvi', 'kdvi', 'okular',
 723                                     'evince', 'xreader',
 724                                     'yap', 'dviout -Set=!m'],
 725         rc_entry = [r'''\Format dvi        dvi     DVI                    D  "%%"       ""      "document,vector,menu=export"   "application/x-dvi"
 726 \Format dvi3       dvi     "DVI (LuaTeX)"          V  "%%"      ""      "document,vector,menu=export"   ""'''])
 727     if dtl_tools:
 728         # Windows only: DraftDVI
 729         addToRC(r'\Format dvi2       dvi     DraftDVI               ""  ""      ""      "vector"        ""')
 730     #
 731     checkViewer('an HTML previewer', ['firefox', 'mozilla file://$$p$$i', 'netscape'],
 732         rc_entry = [r'\Format html      "html, htm" HTML                H  "%%" ""      "document,menu=export"  "text/html"'])
 733     #
 734     checkViewerEditor('Noteedit', ['noteedit'],
 735         rc_entry = [r'\Format noteedit   not     Noteedit               "" "%%" "%%"    "vector"        ""'])
 736     #
 737     checkViewerEditor('an OpenDocument viewer', ['libreoffice', 'lwriter', 'lowriter', 'oowriter', 'swriter', 'abiword'],
 738         rc_entry = [r'''\Format odt        odt     "OpenDocument (tex4ht)"  "" "%%"     "%%"    "document,vector,menu=export"   "application/vnd.oasis.opendocument.text"
 739 \Format odt2       odt    "OpenDocument (eLyXer)"  "" "%%"      "%%"    "document,vector,menu=export"   "application/vnd.oasis.opendocument.text"
 740 \Format odt3       odt    "OpenDocument (Pandoc)"  "" "%%"      "%%"    "document,vector,menu=export"   "application/vnd.oasis.opendocument.text"
 741 \Format sxw        sxw    "OpenOffice.Org (sxw)"  "" "" ""      "document,vector"       "application/vnd.sun.xml.writer"'''])
 742     #
 743     checkViewerEditor('a Rich Text and Word viewer', ['libreoffice', 'lwriter', 'lowriter', 'oowriter', 'swriter', 'abiword'],
 744         rc_entry = [r'''\Format rtf        rtf    "Rich Text Format"      "" "%%"       "%%"    "document,vector,menu=export"   "application/rtf"
 745 \Format word       doc    "MS Word"               W  "%%"       "%%"    "document,vector,menu=export"   "application/msword"
 746 \Format word2      docx    "MS Word Office Open XML"               O  "%%"      "%%"    "document,vector,menu=export"   "application/vnd.openxmlformats-officedocument.wordprocessingml.document"'''])
 747     #
 748     # entries that do not need checkProg
 749     addToRC(r'''\Format csv        csv    "Table (CSV)"           "" "" ""      "document"      "text/csv"
 750 \Format fax        ""      Fax                    "" "" ""      "document"      ""
 751 \Format lyx        lyx     LyX                    "" "" ""      ""      "application/x-lyx"
 752 \Format lyx13x     13.lyx "LyX 1.3.x"             "" "" ""      "document"      ""
 753 \Format lyx14x     14.lyx "LyX 1.4.x"             "" "" ""      "document"      ""
 754 \Format lyx15x     15.lyx "LyX 1.5.x"             "" "" ""      "document"      ""
 755 \Format lyx16x     16.lyx "LyX 1.6.x"             "" "" ""      "document"      ""
 756 \Format lyx20x     20.lyx "LyX 2.0.x"             "" "" ""      "document"      ""
 757 \Format lyx21x     21.lyx "LyX 2.1.x"             "" "" ""      "document"      ""
 758 \Format lyx22x     22.lyx "LyX 2.2.x"             "" "" ""      "document,menu=export"  ""
 759 \Format clyx       cjklyx "CJK LyX 1.4.x (big5)"  "" "" ""      "document"      ""
 760 \Format jlyx       cjklyx "CJK LyX 1.4.x (euc-jp)" "" ""        ""      "document"      ""
 761 \Format klyx       cjklyx "CJK LyX 1.4.x (euc-kr)" "" ""        ""      "document"      ""
 762 \Format lyxpreview lyxpreview "LyX Preview"       "" "" ""      ""      ""
 763 \Format pdftex     "pdftex_t, pdf_tex" PDFTEX                "" ""      ""      ""      ""
 764 \Format program    ""      Program                "" "" ""      ""      ""
 765 \Format pstex      "pstex_t, ps_tex" PSTEX                  "" ""       ""      ""      ""
 766 \Format wmf        wmf    "Windows Metafile"      "" "" ""      "vector"        "image/x-wmf"
 767 \Format emf        emf    "Enhanced Metafile"     "" "" ""      "vector"        "image/x-emf"
 768 \Format wordhtml  "html, htm" "HTML (MS Word)"    "" "" ""      "document"      ""
 769 ''')
 770
 771
 772 def checkConverterEntries():
 773     ''' Check all converters (\converter entries) '''
 774     checkProg('the pdflatex program', ['pdflatex $$i'],
 775         rc_entry = [ r'\converter pdflatex   pdf2       "%%"    "latex=pdflatex"' ])
 776
 777     checkProg('XeTeX', ['xelatex $$i'],
 778         rc_entry = [ r'\converter xetex      pdf4       "%%"    "latex=xelatex"' ])
 779
 780     checkLuatex()
 781
 782     # Look for tex2lyx in this order (see bugs #3308 and #6986):
 783     #   1)  If we're building LyX with autotools then tex2lyx is found
 784     #       in the subdirectory tex2lyx with respect to the binary dir.
 785     #   2)  If we're building LyX with cmake then tex2lyx is found
 786     #       in the binary dir.
 787     #   3)  If LyX was configured with a version suffix then tex2lyx
 788     #       will also have this version suffix.
 789     #   4)  Otherwise always use tex2lyx.
 790     in_binary_subdir = os.path.join(lyx_binary_dir, 'tex2lyx', 'tex2lyx')
 791     in_binary_subdir = os.path.abspath(in_binary_subdir).replace('\\', '/')
 792
 793     in_binary_dir = os.path.join(lyx_binary_dir, 'tex2lyx')
 794     in_binary_dir = os.path.abspath(in_binary_dir).replace('\\', '/')
 795
 796     path, t2l = checkProg('a LaTeX/Noweb -> LyX converter', [in_binary_subdir, in_binary_subdir + version_suffix, in_binary_dir, in_binary_dir + version_suffix, 'tex2lyx' + version_suffix, 'tex2lyx'],
 797         rc_entry = [r'''\converter latex      lyx        "%% -f $$i $$o"        ""
 798 \converter latexclipboard lyx        "%% -fixedenc utf8 -f $$i $$o"     ""
 799 \converter literate   lyx        "%% -n -m noweb -f $$i $$o"    ""
 800 \converter sweave   lyx        "%% -n -m sweave -f $$i $$o"     "needauth"
 801 \converter knitr   lyx        "%% -n -m knitr -f $$i $$o"       "needauth"'''], not_found = 'tex2lyx')
 802     if path == '':
 803         logger.warning("Failed to find tex2lyx on your system.")
 804
 805     #
 806     checkProg('a Noweb -> LaTeX converter', ['noweave -delay -index $$i > $$o'],
 807         rc_entry = [r'''\converter literate   latex      "%%"   ""
 808 \converter literate   pdflatex      "%%"        ""
 809 \converter literate   xetex         "%%"        ""
 810 \converter literate   luatex        "%%"        ""
 811 \converter literate   dviluatex     "%%"        ""'''])
 812     #
 813     checkProg('a Sweave -> LaTeX converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxsweave.R $$p$$i $$p$$o $$e $$r'],
 814         rc_entry = [r'''\converter sweave   latex      "%%"     "needauth"
 815 \converter sweave   pdflatex   "%%"     "needauth"
 816 \converter sweave-ja   platex     "%%"  "needauth"
 817 \converter sweave   xetex      "%%"     "needauth"
 818 \converter sweave   luatex     "%%"     "needauth"
 819 \converter sweave   dviluatex  "%%"     "needauth"'''])
 820     #
 821     checkProg('a knitr -> LaTeX converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxknitr.R $$p$$i $$p$$o $$e $$r'],
 822         rc_entry = [r'''\converter knitr   latex      "%%"      "needauth"
 823 \converter knitr   pdflatex   "%%"      "needauth"
 824 \converter knitr-ja   platex     "%%"   "needauth"
 825 \converter knitr   xetex      "%%"      "needauth"
 826 \converter knitr   luatex     "%%"      "needauth"
 827 \converter knitr   dviluatex  "%%"      "needauth"'''])
 828     #
 829     checkProg('a Sweave -> R/S code converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxstangle.R $$i $$e $$r'],
 830         rc_entry = [ r'\converter sweave      r      "%%"    "needauth"',
 831                      r'\converter sweave-ja   r      "%%"    "needauth"' ])
 832     #
 833     checkProg('a knitr -> R/S code converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxknitr.R $$p$$i $$p$$o $$e $$r tangle'],
 834         rc_entry = [ r'\converter knitr      r      "%%"    "needauth"',
 835                      r'\converter knitr-ja   r      "%%"    "needauth"' ])
 836     #
 837     checkProg('an HTML -> LaTeX converter', ['html2latex $$i', 'gnuhtml2latex',
 838         'htmltolatex -input $$i -output $$o', 'htmltolatex.jar -input $$i -output $$o'],
 839         rc_entry = [ r'\converter html       latex      "%%"    ""',
 840                      r'\converter html       latex      "python -tt $$s/scripts/html2latexwrapper.py %% $$i $$o"        ""',
 841                      r'\converter html       latex      "%%"    ""',
 842                      r'\converter html       latex      "%%"    ""', '' ])
 843     #
 844     checkProg('an MS Word -> LaTeX converter', ['wvCleanLatex $$i $$o'],
 845         rc_entry = [ r'\converter word       latex      "%%"    ""' ])
 846
 847     # eLyXer: search as an executable (elyxer.py, elyxer)
 848     path, elyxer = checkProg('a LyX -> HTML converter',
 849         ['elyxer.py --nofooter --directory $$r $$i $$o', 'elyxer --nofooter --directory $$r $$i $$o'],
 850         rc_entry = [ r'\converter lyx      html       "%%"      ""' ])
 851     path, elyxer = checkProg('a LyX -> HTML (MS Word) converter',
 852         ['elyxer.py --nofooter --html --directory $$r $$i $$o', 'elyxer --nofooter --html --directory $$r $$i $$o'],
 853         rc_entry = [ r'\converter lyx      wordhtml       "%%"  ""' ])
 854     path, elyxer = checkProg('a LyX -> OpenDocument (eLyXer) converter',
 855         ['elyxer.py --html --nofooter --unicode --directory $$r $$i $$o', 'elyxer --html --nofooter --unicode --directory $$r $$i $$o'],
 856         rc_entry = [ r'\converter lyx      odt2       "%%"      ""' ])
 857     path, elyxer = checkProg('a LyX -> Word converter',
 858         ['elyxer.py --html --nofooter --unicode --directory $$r $$i $$o', 'elyxer --html --nofooter --unicode --directory $$r $$i $$o'],
 859         rc_entry = [ r'\converter lyx      word      "%%"       ""' ])
 860     if elyxer.find('elyxer') >= 0:
 861       addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py -e html,png,jpg,jpeg,css $$i $$o"''')
 862       addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py -e html,png,jpg,jpeg,css $$i $$o"''')
 863     else:
 864       # search for HTML converters other than eLyXer
 865       # On SuSE the scripts have a .sh suffix, and on debian they are in /usr/share/tex4ht/
 866       path, htmlconv = checkProg('a LaTeX -> HTML converter', ['htlatex $$i', 'htlatex.sh $$i',
 867           '/usr/share/tex4ht/htlatex $$i', 'tth  -t -e2 -L$$b < $$i > $$o',
 868           'latex2html -no_subdir -split 0 -show_section_numbers $$i', 'hevea -s $$i'],
 869           rc_entry = [ r'\converter latex      html       "%%"  "needaux"' ])
 870       if htmlconv.find('htlatex') >= 0 or htmlconv == 'latex2html':
 871         addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py -e html,png,css $$i $$o"''')
 872       else:
 873         addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py $$i $$o"''')
 874       path, htmlconv = checkProg('a LaTeX -> HTML (MS Word) converter', ["htlatex $$i 'html,word' 'symbol/!' '-cvalidate'",
 875           "htlatex.sh $$i 'html,word' 'symbol/!' '-cvalidate'",
 876           "/usr/share/tex4ht/htlatex $$i 'html,word' 'symbol/!' '-cvalidate'"],
 877           rc_entry = [ r'\converter latex      wordhtml   "%%"  "needaux"' ])
 878       if htmlconv.find('htlatex') >= 0:
 879         addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py -e html,png,css $$i $$o"''')
 880       else:
 881         addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py $$i $$o"''')
 882
 883
 884     # Check if LyXBlogger is installed
 885     lyxblogger_found = checkModule('lyxblogger')
 886     if lyxblogger_found:
 887       addToRC(r'\Format    blog       blog       "LyXBlogger"           "" "" ""  "document"  ""')
 888       addToRC(r'\converter xhtml      blog       "python -m lyxblogger $$i"       ""')
 889
 890     #
 891     checkProg('an OpenOffice.org -> LaTeX converter', ['w2l -clean $$i'],
 892         rc_entry = [ r'\converter sxw        latex      "%%"    ""' ])
 893     #
 894     checkProg('an OpenDocument -> LaTeX converter', ['w2l -clean $$i'],
 895         rc_entry = [ r'\converter odt        latex      "%%"    ""' ])
 896     #
 897     checkProg('an Open Document (Pandoc) -> LaTeX converter', ['pandoc -s -f odt -o $$o -t latex $$i'],
 898         rc_entry = [ r'\converter odt3        latex      "%%"   ""' ])
 899     #
 900     checkProg('a MS Word Office Open XML converter -> LaTeX', ['pandoc -s -f docx -o $$o -t latex $$i'],
 901         rc_entry = [ r'\converter word2      latex      "%%"    ""' ])
 902     # Only define a converter to pdf6, otherwise the odt format could be
 903     # used as an intermediate step for export to pdf, which is not wanted.
 904     checkProg('an OpenDocument -> PDF converter', ['unoconv -f pdf --stdout $$i > $$o'],
 905         rc_entry = [ r'\converter odt        pdf6       "%%"    ""' ])
 906     # According to http://www.tug.org/applications/tex4ht/mn-commands.html
 907     # the command mk4ht oolatex $$i has to be used as default,
 908     # but as this would require to have Perl installed, in MiKTeX oolatex is
 909     # directly available as application.
 910     # On SuSE the scripts have a .sh suffix, and on debian they are in /usr/share/tex4ht/
 911     # Both SuSE and debian have oolatex
 912     checkProg('a LaTeX -> Open Document (tex4ht) converter', [
 913         'oolatex $$i', 'mk4ht oolatex $$i', 'oolatex.sh $$i', '/usr/share/tex4ht/oolatex $$i',
 914         'htlatex $$i \'xhtml,ooffice\' \'ooffice/! -cmozhtf\' \'-coo\' \'-cvalidate\''],
 915         rc_entry = [ r'\converter latex      odt        "%%"    "needaux"' ])
 916     # On windows it is called latex2rt.exe
 917     checkProg('a LaTeX -> RTF converter', ['latex2rtf -p -S -o $$o $$i', 'latex2rt -p -S -o $$o $$i'],
 918         rc_entry = [ r'\converter latex      rtf        "%%"    "needaux"' ])
 919     #
 920     checkProg('a LaTeX -> Open Document (Pandoc) converter', ['pandoc -s -f latex -o $$o -t odt $$i'],
 921         rc_entry = [ r'\converter latex      odt3        "%%"   ""' ])
 922     #
 923     checkProg('a LaTeX -> MS Word Office Open XML converter', ['pandoc -s -f latex -o $$o -t docx $$i'],
 924         rc_entry = [ r'\converter latex      word2       "%%"   ""' ])
 925     #
 926     checkProg('a RTF -> HTML converter', ['unrtf --html  $$i > $$o'],
 927         rc_entry = [ r'\converter rtf      html        "%%"     ""' ])
 928     # Do not define a converter to pdf6, ps is a pure export format
 929     checkProg('a PS to PDF converter', ['ps2pdf $$i $$o'],
 930         rc_entry = [ r'\converter ps         pdf        "%%"    ""' ])
 931     #
 932     checkProg('a PS to TXT converter', ['pstotext $$i > $$o'],
 933         rc_entry = [ r'\converter ps         text2      "%%"    ""' ])
 934     #
 935     checkProg('a PS to TXT converter', ['ps2ascii $$i $$o'],
 936         rc_entry = [ r'\converter ps         text3      "%%"    ""' ])
 937     # Need to call ps2eps in a pipe, otherwise it would name the output file
 938     # depending on the extension of the input file. We do not know the input
 939     # file extension in general, so the resultfile= flag would not help.
 940     # Since ps2eps crops the image, we do not use it to convert from ps->eps.
 941     # This would create additional paths in the converter graph with unwanted
 942     # side effects (e.g. ps->pdf via ps2pdf would create a different result
 943     # than ps->eps->pdf via ps2eps and epstopdf).
 944     checkProg('a PS to EPS converter', ['ps2eps -- < $$i > $$o'],
 945         rc_entry = [ r'\converter eps2       eps      "%%"      ""' ])
 946     #
 947     checkProg('a PDF to PS converter', ['pdftops $$i $$o', 'pdf2ps $$i $$o'],
 948         rc_entry = [ r'\converter pdf         ps        "%%"    ""' ])
 949     # Only define a converter from pdf6 for graphics
 950     checkProg('a PDF to EPS converter', ['pdftops -eps -f 1 -l 1 $$i $$o'],
 951         rc_entry = [ r'\converter pdf6        eps        "%%"   ""' ])
 952     # Define a converter from pdf6 to png for Macs where pdftops is missing.
 953     # The converter utility sips allows to force the dimensions of the resulting
 954     # png image. The value of 800 pixel for the width is arbitrary and not
 955     # related to the current screen resolution or width.
 956     # There is no converter parameter for this information.
 957     checkProg('a PDF to PNG converter',
 958         ['sips --resampleWidth 800 --setProperty format png $$i --out $$o'],
 959         rc_entry = [ r'\converter pdf6        png        "%%" ""' ])
 960     # Create one converter for a PDF produced using TeX fonts and one for a
 961     # PDF produced using non-TeX fonts. This does not produce non-unique
 962     # conversion paths, since a given document either uses TeX fonts or not.
 963     checkProg('a PDF cropping tool', ['pdfcrop $$i $$o'],
 964         rc_entry = [ r'''\converter pdf2   pdf7       "%%"      ""
 965 \converter pdf4   pdf7       "%%"       ""''' ])
 966     # Create one converter for a PDF produced using TeX fonts and one for a
 967     # PDF produced using non-TeX fonts. This does not produce non-unique
 968     # conversion paths, since a given document either uses TeX fonts or not.
 969     checkProg('Ghostscript', ["gswin32c", "gswin64c", "gs"],
 970         rc_entry = [ r'''\converter pdf2   pdf8       "python -tt $$s/scripts/convert_pdf.py $$i $$o ebook"     ""
 971 \converter pdf4   pdf8       "python -tt $$s/scripts/convert_pdf.py $$i $$o ebook"      ""''' ])
 972     #
 973     checkProg('a Beamer info extractor', ['makebeamerinfo -p $$i'],
 974         rc_entry = [ r'\converter pdf2         beamer.info        "%%"  ""' ])
 975     #
 976     checkProg('a DVI to TXT converter', ['catdvi $$i > $$o'],
 977         rc_entry = [ r'\converter dvi        text4      "%%"    ""' ])
 978     #
 979     checkProg('a DVI to PS converter', ['dvips -o $$o $$i'],
 980         rc_entry = [ r'\converter dvi        ps         "%%"    ""' ])
 981     #
 982     checkProg('a DVI to cropped EPS converter', ['dvips -E -o $$o $$i'],
 983         rc_entry = [ r'\converter dvi        eps3         "%%"  ""' ])
 984     #
 985     checkProg('a DVI to PDF converter', ['dvipdfmx -o $$o $$i', 'dvipdfm -o $$o $$i'],
 986         rc_entry = [ r'\converter dvi        pdf3       "%%"    ""' ])
 987     #
 988     checkProg('a fax program', ['kdeprintfax $$i', 'ksendfax $$i', 'hylapex $$i'],
 989         rc_entry = [ r'\converter ps         fax        "%%"    ""'])
 990     #
 991     path, fig2dev = checkProg('a FIG -> Image converter', ['fig2dev'])
 992     if fig2dev == "fig2dev":
 993         addToRC(r'''\converter fig        eps        "fig2dev -L eps $$i $$o"   ""
 994 \converter fig        ppm        "fig2dev -L ppm $$i $$o"       ""
 995 \converter fig        svg        "fig2dev -L svg $$i $$o"       ""
 996 \converter fig        png        "fig2dev -L png $$i $$o"       ""
 997 \converter fig        pdftex     "python -tt $$s/scripts/fig2pdftex.py $$i $$o" ""
 998 \converter fig        pstex      "python -tt $$s/scripts/fig2pstex.py $$i $$o"  ""''')
 999     #
1000     checkProg('a SVG -> PDFTeX converter', [inkscape_name],
1001         rc_entry = [ r'\converter svg        pdftex     "python -tt $$s/scripts/svg2pdftex.py %% $$p$$i $$p$$o" ""'],
1002         path = [inkscape_path])
1003     #
1004     checkProg('a SVG -> PSTeX converter', [inkscape_name],
1005         rc_entry = [ r'\converter svg        pstex     "python -tt $$s/scripts/svg2pstex.py %% $$p$$i $$p$$o" ""'],
1006         path = [inkscape_path])
1007     #
1008     checkProg('a TIFF -> PS converter', ['tiff2ps $$i > $$o'],
1009         rc_entry = [ r'\converter tiff       eps        "%%"    ""'])
1010     #
1011     checkProg('a TGIF -> EPS/PPM converter', ['tgif'],
1012         rc_entry = [
1013             r'''\converter tgif       eps        "tgif -print -color -eps -stdout $$i > $$o"    ""
1014 \converter tgif       png        "tgif -print -color -png -o $$d $$i"   ""
1015 \converter tgif       pdf6       "tgif -print -color -pdf -stdout $$i > $$o"    ""'''])
1016     #
1017     checkProg('a WMF -> EPS converter', ['metafile2eps $$i $$o', 'wmf2eps -o $$o $$i', inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-eps=%s$$o'
1018                % (inkscape_fileprefix, inkscape_fileprefix)],
1019         rc_entry = [ r'\converter wmf        eps        "%%"    ""'])
1020     #
1021     checkProg('an EMF -> EPS converter', ['metafile2eps $$i $$o', inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-eps=%s$$o'
1022                % (inkscape_fileprefix, inkscape_fileprefix)],
1023         rc_entry = [ r'\converter emf        eps        "%%"    ""'])
1024     #
1025     checkProg('a WMF -> PDF converter', [inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-pdf=%s$$o' % (inkscape_fileprefix, inkscape_fileprefix)],
1026         rc_entry = [ r'\converter wmf        pdf6        "%%"   ""'])
1027     #
1028     checkProg('an EMF -> PDF converter', [inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-pdf=%s$$o' % (inkscape_fileprefix, inkscape_fileprefix)],
1029         rc_entry = [ r'\converter emf        pdf6        "%%"   ""'])
1030     # Only define a converter to pdf6 for graphics
1031     checkProg('an EPS -> PDF converter', ['epstopdf'],
1032         rc_entry = [ r'\converter eps        pdf6       "epstopdf --outfile=$$o $$i"    ""'])
1033     #
1034     checkProg('an EPS -> PNG converter', ['magick $$i $$o', 'convert $$i $$o'],
1035         rc_entry = [ r'\converter eps        png        "%%"    ""'])
1036     #
1037     # no agr -> pdf6 converter, since the pdf library used by gracebat is not
1038     # free software and therefore not compiled in in many installations.
1039     # Fortunately, this is not a big problem, because we will use epstopdf to
1040     # convert from agr to pdf6 via eps without loss of quality.
1041     checkProg('a Grace -> Image converter', ['gracebat'],
1042         rc_entry = [
1043             r'''\converter agr        eps        "gracebat -hardcopy -printfile $$o -hdevice EPS $$i 2>/dev/null"       ""
1044 \converter agr        png        "gracebat -hardcopy -printfile $$o -hdevice PNG $$i 2>/dev/null"       ""
1045 \converter agr        jpg        "gracebat -hardcopy -printfile $$o -hdevice JPEG $$i 2>/dev/null"      ""
1046 \converter agr        ppm        "gracebat -hardcopy -printfile $$o -hdevice PNM $$i 2>/dev/null"       ""'''])
1047     #
1048     checkProg('a Dot -> Image converter', ['dot'],
1049         rc_entry = [
1050             r'''\converter dot        eps        "dot -Teps $$i -o $$o" ""
1051 \converter dot        png        "dot -Tpng $$i -o $$o" ""'''])
1052     #
1053     path, dia = checkProg('a Dia -> Image converter', ['dia'])
1054     if dia == 'dia':
1055         addToRC(r'''\converter dia        png        "dia -e $$o -t png $$i"    ""
1056 \converter dia        eps        "dia -e $$o -t eps $$i"        ""
1057 \converter dia        svg        "dia -e $$o -t svg $$i"        ""''')
1058
1059     #
1060     # Actually, this produces EPS, but with a wrong bounding box (usually A4 or letter).
1061     # The eps2->eps converter then fixes the bounding box by cropping.
1062     # Although unoconv can convert to png and pdf as well, do not define
1063     # odg->png and odg->pdf converters, since the bb would be too large as well.
1064     checkProg('an OpenDocument -> EPS converter', ['libreoffice --headless --nologo --convert-to eps $$i', 'unoconv -f eps --stdout $$i > $$o'],
1065         rc_entry = [ r'\converter odg        eps2       "%%"    ""'])
1066     #
1067     checkProg('a SVG (compressed) -> SVG converter', ['gunzip -c $$i > $$o'],
1068         rc_entry = [ r'\converter svgz       svg        "%%"    ""'])
1069     #
1070     checkProg('a SVG -> SVG (compressed) converter', ['gzip -c $$i > $$o'],
1071         rc_entry = [ r'\converter svg        svgz       "%%"    ""'])
1072     # Only define a converter to pdf6 for graphics
1073     # Prefer rsvg-convert over inkscape since it is faster (see http://www.lyx.org/trac/ticket/9891)
1074     checkProg('a SVG -> PDF converter', ['rsvg-convert -f pdf -o $$o $$i', inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-pdf=%s$$o'
1075                % (inkscape_fileprefix, inkscape_fileprefix)],
1076         rc_entry = [ r'''\converter svg        pdf6       "%%"    ""
1077 \converter svgz       pdf6       "%%"    ""'''],
1078         path = ['', inkscape_path])
1079     #
1080     checkProg('a SVG -> EPS converter', ['rsvg-convert -f ps -o $$o $$i', inkscape_name + ' --file=%s$$i --export-area-drawing --without-gui --export-eps=%s$$o'
1081                % (inkscape_fileprefix, inkscape_fileprefix)],
1082         rc_entry = [ r'''\converter svg        eps        "%%"    ""
1083 \converter svgz       eps        "%%"    ""'''],
1084         path = ['', inkscape_path])
1085     #
1086     checkProg('a SVG -> PNG converter', ['rsvg-convert -f png -o $$o $$i', inkscape_name + ' --without-gui --file=%s$$i --export-png=%s$$o'
1087                % (inkscape_fileprefix, inkscape_fileprefix)],
1088         rc_entry = [ r'''\converter svg        png        "%%"    "",
1089 \converter svgz       png        "%%"    ""'''],
1090         path = ['', inkscape_path])
1091     #
1092     checkProg('Gnuplot', ['gnuplot'],
1093         rc_entry = [ r'''\Format gnuplot     "gp, gnuplot"    "Gnuplot"     "" "" ""  "vector"  "text/plain"
1094 \converter gnuplot      pdf6      "python -tt $$s/scripts/gnuplot2pdf.py $$i $$o"    "needauth"''' ])
1095     #
1096     # gnumeric/xls/ods to tex
1097     checkProg('a spreadsheet -> latex converter', ['ssconvert'],
1098        rc_entry = [ r'''\converter gnumeric latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1099 \converter oocalc latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1100 \converter excel  latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1101 \converter excel2 latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1102 \converter gnumeric html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1103 \converter oocalc html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1104 \converter excel  html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1105 \converter excel2 html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1106 '''])
1107
1108     path, lilypond = checkProg('a LilyPond -> EPS/PDF/PNG converter', ['lilypond'])
1109     if (lilypond != ''):
1110         version_string = cmdOutput("lilypond --version")
1111         match = re.match('GNU LilyPond (\S+)', version_string)
1112         if match:
1113             version_number = match.groups()[0]
1114             version = version_number.split('.')
1115             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 11):
1116                 addToRC(r'''\converter lilypond   eps        "lilypond -dbackend=eps -dsafe --ps $$i"   ""
1117 \converter lilypond   png        "lilypond -dbackend=eps -dsafe --png $$i"      ""''')
1118                 addToRC(r'\converter lilypond   pdf6       "lilypond -dbackend=eps -dsafe --pdf $$i"    ""')
1119                 logger.info('+  found LilyPond version %s.' % version_number)
1120             elif int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 6):
1121                 addToRC(r'''\converter lilypond   eps        "lilypond -b eps --ps --safe $$i"  ""
1122 \converter lilypond   png        "lilypond -b eps --png $$i"    ""''')
1123                 if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 9):
1124                     addToRC(r'\converter lilypond   pdf6       "lilypond -b eps --pdf --safe $$i"       ""')
1125                 logger.info('+  found LilyPond version %s.' % version_number)
1126             else:
1127                 logger.info('+  found LilyPond, but version %s is too old.' % version_number)
1128         else:
1129             logger.info('+  found LilyPond, but could not extract version number.')
1130     #
1131     path, lilypond_book = checkProg('a LilyPond book (LaTeX) -> LaTeX converter', ['lilypond-book'])
1132     if (lilypond_book != ''):
1133         version_string = cmdOutput("lilypond-book --version")
1134         match = re.match('^(\S+)$', version_string)
1135         if match:
1136             version_number = match.groups()[0]
1137             version = version_number.split('.')
1138             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 13):
1139                 # Note: The --lily-output-dir flag is required because lilypond-book
1140                 #       does not process input again unless the input has changed,
1141                 #       even if the output format being requested is different. So
1142                 #       once a .eps file exists, lilypond-book won't create a .pdf
1143                 #       even when requested with --pdf. This is a problem if a user
1144                 #       clicks View PDF after having done a View DVI. To circumvent
1145                 #       this, use different output folders for eps and pdf outputs.
1146                 addToRC(r'\converter lilypond-book latex    "lilypond-book --safe --lily-output-dir=ly-eps $$i"                                ""')
1147                 addToRC(r'\converter lilypond-book pdflatex "lilypond-book --safe --pdf --latex-program=pdflatex --lily-output-dir=ly-pdf $$i" ""')
1148                 addToRC(r'\converter lilypond-book-ja platex "lilypond-book --safe --pdf --latex-program=platex --lily-output-dir=ly-pdf $$i" ""')
1149                 addToRC(r'\converter lilypond-book xetex    "lilypond-book --safe --pdf --latex-program=xelatex --lily-output-dir=ly-pdf $$i"  ""')
1150                 addToRC(r'\converter lilypond-book luatex   "lilypond-book --safe --pdf --latex-program=lualatex --lily-output-dir=ly-pdf $$i" ""')
1151                 addToRC(r'\converter lilypond-book dviluatex "lilypond-book --safe --latex-program=dvilualatex --lily-output-dir=ly-eps $$i" ""')
1152                 logger.info('+  found LilyPond-book version %s.' % version_number)
1153             else:
1154                 logger.info('+  found LilyPond-book, but version %s is too old.' % version_number)
1155         else:
1156             logger.info('+  found LilyPond-book, but could not extract version number.')
1157     #
1158     checkProg('a Noteedit -> LilyPond converter', ['noteedit --export-lilypond $$i'],
1159         rc_entry = [ r'\converter noteedit   lilypond   "%%"    ""' ])
1160     #
1161     # Currently, lyxpak outputs a gzip compressed tar archive on *nix
1162     # and a zip archive on Windows.
1163     # So, we configure the appropriate version according to the platform.
1164     cmd = r'\converter lyx %s "python -tt $$s/scripts/lyxpak.py $$r/$$f" ""'
1165     if os.name == 'nt':
1166         addToRC(r'\Format lyxzip     zip    "LyX Archive (zip)"     "" "" ""  "document,menu=export"    ""')
1167         addToRC(cmd % "lyxzip")
1168     else:
1169         addToRC(r'\Format lyxgz      gz     "LyX Archive (tar.gz)"  "" "" ""  "document,menu=export"    ""')
1170         addToRC(cmd % "lyxgz")
1171
1172     #
1173     # FIXME: no rc_entry? comment it out
1174     # checkProg('Image converter', ['convert $$i $$o'])
1175     #
1176     # Entries that do not need checkProg
1177     addToRC(r'''
1178 \converter csv        lyx        "python -tt $$s/scripts/csv2lyx.py $$i $$o"    ""
1179 \converter docbook    docbook-xml "cp $$i $$o"  "xml"
1180 \converter fen        asciichess "python -tt $$s/scripts/fen2ascii.py $$i $$o"  ""
1181 \converter lyx        lyx13x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.3 -o $$o $$i"     ""
1182 \converter lyx        lyx14x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o $$i"     ""
1183 \converter lyx        lyx15x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.5 -o $$o $$i"     ""
1184 \converter lyx        lyx16x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.6 -o $$o $$i"     ""
1185 \converter lyx        lyx20x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.0 -o $$o $$i"     ""
1186 \converter lyx        lyx21x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.1 -o $$o $$i"     ""
1187 \converter lyx        lyx22x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.2 -o $$o $$i"     ""
1188 \converter lyx        clyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c big5   $$i"   ""
1189 \converter lyx        jlyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c euc_jp $$i"   ""
1190 \converter lyx        klyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c euc_kr $$i"   ""
1191 \converter clyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c big5   -o $$o $$i"  ""
1192 \converter jlyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_jp -o $$o $$i"  ""
1193 \converter klyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_kr -o $$o $$i"  ""
1194 \converter lyxpreview png        "python -tt $$s/scripts/lyxpreview2bitmap.py --png"    ""
1195 \converter lyxpreview ppm        "python -tt $$s/scripts/lyxpreview2bitmap.py --ppm"    ""
1196 ''')
1197
1198
1199 def checkDocBook():
1200     ''' Check docbook '''
1201     path, DOCBOOK = checkProg('SGML-tools 2.x (DocBook), db2x scripts or xsltproc', ['sgmltools', 'db2dvi', 'xsltproc'],
1202         rc_entry = [
1203             r'''\converter docbook    dvi        "sgmltools -b dvi $$i" ""
1204 \converter docbook    html       "sgmltools -b html $$i"        ""
1205 \converter docbook    ps         "sgmltools -b ps $$i"  ""''',
1206             r'''\converter docbook    dvi        "db2dvi $$i"   ""
1207 \converter docbook    html       "db2html $$i"  ""''',
1208             r'''\converter docbook    dvi        ""     ""
1209 \converter docbook    html       "" ""''',
1210             r'''\converter docbook    dvi        ""     ""
1211 \converter docbook    html       ""     ""'''])
1212     #
1213     if DOCBOOK != '':
1214         return ('yes', 'true', '\\def\\hasdocbook{yes}')
1215     else:
1216         return ('no', 'false', '')
1217
1218
1219 def checkOtherEntries():
1220     ''' entries other than Format and Converter '''
1221     checkProg('ChkTeX', ['chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38'],
1222         rc_entry = [ r'\chktex_command "%%"' ])
1223     checkProgAlternatives('BibTeX or alternative programs',
1224         ['bibtex', 'bibtex8', 'biber'],
1225         rc_entry = [ r'\bibtex_command "automatic"' ],
1226         alt_rc_entry = [ r'\bibtex_alternatives "%%"' ])
1227     checkProgAlternatives('a specific Japanese BibTeX variant',
1228         ['pbibtex', 'upbibtex', 'jbibtex', 'bibtex', 'biber'],
1229         rc_entry = [ r'\jbibtex_command "automatic"' ],
1230         alt_rc_entry = [ r'\jbibtex_alternatives "%%"' ])
1231     checkProgAlternatives('available index processors',
1232         ['texindy', 'makeindex -c -q', 'xindy'],
1233         rc_entry = [ r'\index_command "%%"' ],
1234         alt_rc_entry = [ r'\index_alternatives "%%"' ])
1235     checkProg('an index processor appropriate to Japanese',
1236         ['mendex -c -q', 'jmakeindex -c -q', 'makeindex -c -q'],
1237         rc_entry = [ r'\jindex_command "%%"' ])
1238     checkProg('the splitindex processor', ['splitindex.pl', 'splitindex',
1239         'splitindex.class'], rc_entry = [ r'\splitindex_command "%%"' ])
1240     checkProg('a nomenclature processor', ['makeindex'],
1241         rc_entry = [ r'\nomencl_command "makeindex -s nomencl.ist"' ])
1242     checkProg('a python-pygments driver command', ['pygmentize'],
1243         rc_entry = [ r'\pygmentize_command "%%"' ])
1244     ## FIXME: OCTAVE is not used anywhere
1245     # path, OCTAVE = checkProg('Octave', ['octave'])
1246     ## FIXME: MAPLE is not used anywhere
1247     # path, MAPLE = checkProg('Maple', ['maple'])
1248     # Add the rest of the entries (no checkProg is required)
1249     addToRC(r'''\copier    fig        "python -tt $$s/scripts/fig_copy.py $$i $$o"
1250 \copier    pstex      "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
1251 \copier    pdftex     "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
1252 \copier    program    "python -tt $$s/scripts/ext_copy.py $$i $$o"
1253 ''')
1254
1255
1256 def processLayoutFile(file, bool_docbook):
1257     ''' process layout file and get a line of result
1258
1259         Declare lines look like this:
1260
1261         \DeclareLaTeXClass[<requirements>]{<description>}
1262
1263         Optionally, a \DeclareCategory line follows:
1264
1265         \DeclareCategory{<category>}
1266
1267         So for example (article.layout, scrbook.layout, svjog.layout)
1268
1269         \DeclareLaTeXClass{article}
1270         \DeclareCategory{Articles}
1271
1272         \DeclareLaTeXClass[scrbook]{book (koma-script)}
1273         \DeclareCategory{Books}
1274
1275         \DeclareLaTeXClass[svjour,svjog.clo]{article (Springer - svjour/jog)}
1276
1277         we'd expect this output:
1278
1279         "article" "article" "article" "false" "article.cls" "Articles"
1280         "scrbook" "scrbook" "book (koma-script)" "false" "scrbook.cls" "Books"
1281         "svjog" "svjour" "article (Springer - svjour/jog)" "false" "svjour.cls,svjog.clo" ""
1282     '''
1283     def checkForClassExtension(x):
1284         '''if the extension for a latex class is not
1285            provided, add .cls to the classname'''
1286         if not b'.' in x:
1287             return x.strip() + b'.cls'
1288         else:
1289             return x.strip()
1290     classname = file.split(os.sep)[-1].split('.')[0]
1291     # return ('LaTeX', '[a,b]', 'a', ',b,c', 'article') for \DeclareLaTeXClass[a,b,c]{article}
1292     p = re.compile(b'^\s*#\s*\\Declare(LaTeX|DocBook)Class\s*(\[([^,]*)(,.*)*\])*\s*{(.*)}\s*$')
1293     q = re.compile(b'^\s*#\s*\\DeclareCategory{(.*)}\s*$')
1294     classdeclaration = b""
1295     categorydeclaration = b'""'
1296     for line in open(file, 'rb').readlines():
1297         res = p.search(line)
1298         qres = q.search(line)
1299         if res != None:
1300             (classtype, optAll, opt, opt1, desc) = res.groups()
1301             avai = {b'LaTeX':b'false', b'DocBook':bool_docbook.encode('ascii')}[classtype]
1302             if opt == None:
1303                 opt = classname.encode('ascii')
1304                 prereq_latex = checkForClassExtension(classname.encode('ascii'))
1305             else:
1306                 prereq_list = optAll[1:-1].split(b',')
1307                 prereq_list = list(map(checkForClassExtension, prereq_list))
1308                 prereq_latex = b','.join(prereq_list)
1309             prereq_docbook = {'true':b'', 'false':b'docbook'}[bool_docbook]
1310             prereq = {b'LaTeX':prereq_latex, b'DocBook':prereq_docbook}[classtype]
1311             classdeclaration = (b'"%s" "%s" "%s" "%s" "%s"'
1312                                % (classname, opt, desc, avai, prereq))
1313             if categorydeclaration != b'""':
1314                 return classdeclaration + b" " + categorydeclaration
1315         if qres != None:
1316              categorydeclaration = b'"%s"' % (qres.groups()[0])
1317              if classdeclaration != b"":
1318                  return classdeclaration + b" " + categorydeclaration
1319     if classdeclaration != b"":
1320         return classdeclaration + b" " + categorydeclaration
1321     logger.warning("Layout file " + file + " has no \DeclareXXClass line. ")
1322     return b""
1323
1324
1325 def checkLatexConfig(check_config, bool_docbook):
1326     ''' Explore the LaTeX configuration
1327         Return None (will be passed to sys.exit()) for success.
1328     '''
1329     msg = 'checking LaTeX configuration... '
1330     # if --without-latex-config is forced, or if there is no previous
1331     # version of textclass.lst, re-generate a default file.
1332     if not os.path.isfile('textclass.lst') or not check_config:
1333         # remove the files only if we want to regenerate
1334         removeFiles(['textclass.lst', 'packages.lst'])
1335         #
1336         # Then, generate a default textclass.lst. In case configure.py
1337         # fails, we still have something to start lyx.
1338         logger.info(msg + ' default values')
1339         logger.info('+checking list of textclasses... ')
1340         tx = open('textclass.lst', 'wb')
1341         tx.write(b'''
1342 # This file declares layouts and their associated definition files
1343 # (include dir. relative to the place where this file is).
1344 # It contains only default values, since chkconfig.ltx could not be run
1345 # for some reason. Run ./configure.py if you need to update it after a
1346 # configuration change.
1347 ''')
1348         # build the list of available layout files and convert it to commands
1349         # for chkconfig.ltx
1350         foundClasses = []
1351         for file in (glob.glob(os.path.join('layouts', '*.layout'))
1352                      + glob.glob(os.path.join(srcdir, 'layouts', '*.layout'))):
1353             # valid file?
1354             if not os.path.isfile(file):
1355                 continue
1356             # get stuff between /xxxx.layout .
1357             classname = file.split(os.sep)[-1].split('.')[0]
1358             #  tr ' -' '__'`
1359             cleanclass = classname.replace(' ', '_')
1360             cleanclass = cleanclass.replace('-', '_')
1361             # make sure the same class is not considered twice
1362             if foundClasses.count(cleanclass) == 0: # not found before
1363                 foundClasses.append(cleanclass)
1364                 retval = processLayoutFile(file, bool_docbook)
1365                 if retval != b"":
1366                     tx.write(retval)
1367         tx.close()
1368         logger.info('\tdone')
1369     if not os.path.isfile('packages.lst') or not check_config:
1370         logger.info('+generating default list of packages... ')
1371         removeFiles(['packages.lst'])
1372         tx = open('packages.lst', 'w')
1373         tx.close()
1374         logger.info('\tdone')
1375     if not check_config:
1376         return None
1377     # the following will generate textclass.lst.tmp, and packages.lst.tmp
1378     logger.info(msg + '\tauto')
1379     removeFiles(['chkconfig.classes', 'chkconfig.vars', 'chklayouts.tex',
1380         'wrap_chkconfig.ltx'])
1381     rmcopy = False
1382     if not os.path.isfile( 'chkconfig.ltx' ):
1383         shutil.copyfile( os.path.join(srcdir, 'chkconfig.ltx'), 'chkconfig.ltx' )
1384         rmcopy = True
1385     writeToFile('wrap_chkconfig.ltx', '%s\n\\input{chkconfig.ltx}\n' % docbook_cmd)
1386     # Construct the list of classes to test for.
1387     # build the list of available layout files and convert it to commands
1388     # for chkconfig.ltx
1389     declare = re.compile(b'^\\s*#\\s*\\\\Declare(LaTeX|DocBook)Class\\s*(\[([^,]*)(,.*)*\])*\\s*{(.*)}\\s*$')
1390     category = re.compile(b'^\\s*#\\s*\\\\DeclareCategory{(.*)}\\s*$')
1391     empty = re.compile(b'^\\s*$')
1392     testclasses = list()
1393     for file in (glob.glob( os.path.join('layouts', '*.layout') )
1394                  + glob.glob( os.path.join(srcdir, 'layouts', '*.layout' ) ) ):
1395         nodeclaration = False
1396         if not os.path.isfile(file):
1397             continue
1398         classname = file.split(os.sep)[-1].split('.')[0]
1399         decline = b""
1400         catline = b""
1401         for line in open(file, 'rb').readlines():
1402             if not empty.match(line) and line[0] != b'#'[0]:
1403                 if decline == b"":
1404                     logger.warning("Failed to find valid \Declare line "
1405                         "for layout file `%s'.\n\t=> Skipping this file!" % file)
1406                     nodeclaration = True
1407                 # A class, but no category declaration. Just break.
1408                 break
1409             if declare.search(line) != None:
1410                 decline = b"\\TestDocClass{%s}{%s}" \
1411                            % (classname.encode('ascii'), line[1:].strip())
1412                 testclasses.append(decline)
1413             elif category.search(line) != None:
1414                 catline = (b"\\DeclareCategory{%s}{%s}"
1415                            % (classname.encode('ascii'),
1416                               category.search(line).groups()[0]))
1417                 testclasses.append(catline)
1418             if catline == b"" or decline == b"":
1419                 continue
1420             break
1421         if nodeclaration:
1422             continue
1423     testclasses.sort()
1424     cl = open('chklayouts.tex', 'wb')
1425     for line in testclasses:
1426         cl.write(line + b'\n')
1427     cl.close()
1428     #
1429     # we have chklayouts.tex, then process it
1430     latex_out = cmdOutput(LATEX + ' wrap_chkconfig.ltx', True)
1431     while True:
1432         line = latex_out.readline()
1433         if not line:
1434             break;
1435         if re.match('^\+', line):
1436             logger.info(line.strip())
1437     # if the command succeeds, None will be returned
1438     ret = latex_out.close()
1439     #
1440     # remove the copied file
1441     if rmcopy:
1442         removeFiles( [ 'chkconfig.ltx' ] )
1443     #
1444     # currently, values in chkconfig are only used to set
1445     # \font_encoding
1446     values = {}
1447     for line in open('chkconfig.vars').readlines():
1448         key, val = re.sub('-', '_', line).split('=')
1449         val = val.strip()
1450         values[key] = val.strip("'")
1451     # chk_fontenc may not exist
1452     try:
1453         addToRC(r'\font_encoding "%s"' % values["chk_fontenc"])
1454     except:
1455         pass
1456     # if configure successed, move textclass.lst.tmp to textclass.lst
1457     # and packages.lst.tmp to packages.lst
1458     if (os.path.isfile('textclass.lst.tmp')
1459           and len(open('textclass.lst.tmp').read()) > 0
1460         and os.path.isfile('packages.lst.tmp')
1461           and len(open('packages.lst.tmp').read()) > 0):
1462         shutil.move('textclass.lst.tmp', 'textclass.lst')
1463         shutil.move('packages.lst.tmp', 'packages.lst')
1464     return ret
1465
1466
1467 def checkModulesConfig():
1468   removeFiles(['lyxmodules.lst', 'chkmodules.tex'])
1469
1470   logger.info('+checking list of modules... ')
1471   tx = open('lyxmodules.lst', 'wb')
1472   tx.write(b'''## This file declares modules and their associated definition files.
1473 ## It has been automatically generated by configure
1474 ## Use "Options/Reconfigure" if you need to update it after a
1475 ## configuration change.
1476 ## "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1477 ''')
1478
1479   # build the list of available modules
1480   seen = []
1481   # note that this searches the local directory first, then the
1482   # system directory. that way, we pick up the user's version first.
1483   for file in (glob.glob( os.path.join('layouts', '*.module') )
1484                + glob.glob( os.path.join(srcdir, 'layouts', '*.module' ) ) ):
1485       # valid file?
1486       logger.info(file)
1487       if not os.path.isfile(file):
1488           continue
1489
1490       filename = file.split(os.sep)[-1]
1491       filename = filename[:-7]
1492       if seen.count(filename):
1493           continue
1494
1495       seen.append(filename)
1496       retval = processModuleFile(file, filename.encode('ascii'), bool_docbook)
1497       if retval != b"":
1498           tx.write(retval)
1499   tx.close()
1500   logger.info('\tdone')
1501
1502
1503 def processModuleFile(file, filename, bool_docbook):
1504     ''' process module file and get a line of result
1505
1506         The top of a module file should look like this:
1507           #\DeclareLyXModule[LaTeX Packages]{ModuleName}
1508           #DescriptionBegin
1509           #...body of description...
1510           #DescriptionEnd
1511           #Requires: [list of required modules]
1512           #Excludes: [list of excluded modules]
1513           #Category: [category name]
1514         The last three lines are optional (though do give a category).
1515         We expect output:
1516           "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1517     '''
1518     remods = re.compile(b'\DeclareLyXModule\s*(?:\[([^]]*?)\])?{(.*)}')
1519     rereqs = re.compile(b'#+\s*Requires: (.*)')
1520     reexcs = re.compile(b'#+\s*Excludes: (.*)')
1521     recaty = re.compile(b'#+\s*Category: (.*)')
1522     redbeg = re.compile(b'#+\s*DescriptionBegin\s*$')
1523     redend = re.compile(b'#+\s*DescriptionEnd\s*$')
1524
1525     modname = desc = pkgs = req = excl = catgy = b""
1526     readingDescription = False
1527     descLines = []
1528
1529     for line in open(file, 'rb').readlines():
1530       if readingDescription:
1531         res = redend.search(line)
1532         if res != None:
1533           readingDescription = False
1534           desc = b" ".join(descLines)
1535           # Escape quotes.
1536           desc = desc.replace(b'"', b'\\"')
1537           continue
1538         descLines.append(line[1:].strip())
1539         continue
1540       res = redbeg.search(line)
1541       if res != None:
1542         readingDescription = True
1543         continue
1544       res = remods.search(line)
1545       if res != None:
1546           (pkgs, modname) = res.groups()
1547           if pkgs == None:
1548             pkgs = b""
1549           else:
1550             tmp = [s.strip() for s in pkgs.split(b",")]
1551             pkgs = b",".join(tmp)
1552           continue
1553       res = rereqs.search(line)
1554       if res != None:
1555         req = res.group(1)
1556         tmp = [s.strip() for s in req.split(b"|")]
1557         req = b"|".join(tmp)
1558         continue
1559       res = reexcs.search(line)
1560       if res != None:
1561         excl = res.group(1)
1562         tmp = [s.strip() for s in excl.split(b"|")]
1563         excl = b"|".join(tmp)
1564         continue
1565       res = recaty.search(line)
1566       if res != None:
1567         catgy = res.group(1)
1568         continue
1569
1570     if modname == b"":
1571       logger.warning("Module file without \DeclareLyXModule line. ")
1572       return b""
1573
1574     if pkgs != b"":
1575         # this module has some latex dependencies:
1576         # append the dependencies to chkmodules.tex,
1577         # which is \input'ed by chkconfig.ltx
1578         testpackages = list()
1579         for pkg in pkgs.split(b","):
1580             if b"->" in pkg:
1581                 # this is a converter dependency: skip
1582                 continue
1583             if pkg.endswith(b".sty"):
1584                 pkg = pkg[:-4]
1585             testpackages.append("\\TestPackage{%s}" % (pkg.decode('ascii'),))
1586         cm = open('chkmodules.tex', 'a')
1587         for line in testpackages:
1588             cm.write(line + '\n')
1589         cm.close()
1590
1591     return (b'"%s" "%s" "%s" "%s" "%s" "%s" "%s"\n'
1592             % (modname, filename, desc, pkgs, req, excl, catgy))
1593
1594
1595 def checkCiteEnginesConfig():
1596   removeFiles(['lyxciteengines.lst', 'chkciteengines.tex'])
1597
1598   logger.info('+checking list of cite engines... ')
1599   tx = open('lyxciteengines.lst', 'wb')
1600   tx.write(b'''## This file declares cite engines and their associated definition files.
1601 ## It has been automatically generated by configure
1602 ## Use "Options/Reconfigure" if you need to update it after a
1603 ## configuration change.
1604 ## "CiteEngineName" "filename" "CiteEngineType" "CiteFramework" "DefaultBiblio" "Description" "Packages"
1605 ''')
1606
1607   # build the list of available modules
1608   seen = []
1609   # note that this searches the local directory first, then the
1610   # system directory. that way, we pick up the user's version first.
1611   for file in glob.glob( os.path.join('citeengines', '*.citeengine') ) + \
1612       glob.glob( os.path.join(srcdir, 'citeengines', '*.citeengine' ) ) :
1613       # valid file?
1614       logger.info(file)
1615       if not os.path.isfile(file):
1616           continue
1617
1618       filename = file.split(os.sep)[-1]
1619       filename = filename[:-11]
1620       if seen.count(filename):
1621           continue
1622
1623       seen.append(filename)
1624       retval = processCiteEngineFile(file, filename.encode('ascii'), bool_docbook)
1625       if retval != b"":
1626           tx.write(retval)
1627   tx.close()
1628   logger.info('\tdone')
1629
1630
1631 def processCiteEngineFile(file, filename, bool_docbook):
1632     ''' process cite engines file and get a line of result
1633
1634         The top of a cite engine file should look like this:
1635           #\DeclareLyXCiteEngine[LaTeX Packages]{CiteEngineName}
1636           #DescriptionBegin
1637           #...body of description...
1638           #DescriptionEnd
1639         We expect output:
1640           "CiteEngineName" "filename" "CiteEngineType" "CiteFramework" "DefaultBiblio" "Description" "Packages"
1641     '''
1642     remods = re.compile(b'\DeclareLyXCiteEngine\s*(?:\[([^]]*?)\])?{(.*)}')
1643     redbeg = re.compile(b'#+\s*DescriptionBegin\s*$')
1644     redend = re.compile(b'#+\s*DescriptionEnd\s*$')
1645     recet = re.compile(b'\s*CiteEngineType\s*(.*)')
1646     redb = re.compile(b'\s*DefaultBiblio\s*(.*)')
1647     resfm = re.compile(b'\s*CiteFramework\s*(.*)')
1648
1649     modname = desc = pkgs = cet = db = cfm = ""
1650     readingDescription = False
1651     descLines = []
1652
1653     for line in open(file, 'rb').readlines():
1654       if readingDescription:
1655         res = redend.search(line)
1656         if res != None:
1657           readingDescription = False
1658           desc = b" ".join(descLines)
1659           # Escape quotes.
1660           desc = desc.replace(b'"', b'\\"')
1661           continue
1662         descLines.append(line[1:].strip())
1663         continue
1664       res = redbeg.search(line)
1665       if res != None:
1666         readingDescription = True
1667         continue
1668       res = remods.search(line)
1669       if res != None:
1670           (pkgs, modname) = res.groups()
1671           if pkgs == None:
1672             pkgs = b""
1673           else:
1674             tmp = [s.strip() for s in pkgs.split(b",")]
1675             pkgs = b",".join(tmp)
1676           continue
1677       res = recet.search(line)
1678       if res != None:
1679         cet = res.group(1)
1680         continue
1681       res = redb.search(line)
1682       if res != None:
1683         db = res.group(1)
1684         continue
1685       res = resfm.search(line)
1686       if res != None:
1687         cfm = res.group(1)
1688         continue
1689
1690     if modname == b"":
1691       logger.warning("Cite Engine File file without \DeclareLyXCiteEngine line. ")
1692       return b""
1693
1694     if pkgs != b"":
1695         # this cite engine has some latex dependencies:
1696         # append the dependencies to chkciteengines.tex,
1697         # which is \input'ed by chkconfig.ltx
1698         testpackages = list()
1699         for pkg in pkgs.split(b","):
1700             if b"->" in pkg:
1701                 # this is a converter dependency: skip
1702                 continue
1703             if pkg.endswith(b".sty"):
1704                 pkg = pkg[:-4]
1705             testpackages.append("\\TestPackage{%s}" % (pkg.decode('ascii'),))
1706         cm = open('chkciteengines.tex', 'a')
1707         for line in testpackages:
1708             cm.write(line + '\n')
1709         cm.close()
1710
1711     return (b'"%s" "%s" "%s" "%s" "%s" "%s" "%s"\n' % (modname, filename, cet, cfm, db, desc, pkgs))
1712
1713
1714 def checkXTemplates():
1715   removeFiles(['xtemplates.lst'])
1716
1717   logger.info('+checking list of external templates... ')
1718   tx = open('xtemplates.lst', 'w')
1719   tx.write('''## This file lists external templates.
1720 ## It has been automatically generated by configure
1721 ## Use "Options/Reconfigure" if you need to update it after a
1722 ## configuration change.
1723 ''')
1724
1725   # build the list of available templates
1726   seen = []
1727   # note that this searches the local directory first, then the
1728   # system directory. that way, we pick up the user's version first.
1729   for file in glob.glob( os.path.join('xtemplates', '*.xtemplate') ) + \
1730       glob.glob( os.path.join(srcdir, 'xtemplates', '*.xtemplate' ) ) :
1731       # valid file?
1732       logger.info(file)
1733       if not os.path.isfile(file):
1734           continue
1735
1736       filename = file.split(os.sep)[-1]
1737       if seen.count(filename):
1738           continue
1739
1740       seen.append(filename)
1741       if filename != "":
1742           tx.write(filename + "\n")
1743   tx.close()
1744   logger.info('\tdone')
1745
1746
1747 def checkTeXAllowSpaces():
1748     ''' Let's check whether spaces are allowed in TeX file names '''
1749     tex_allows_spaces = 'false'
1750     if lyx_check_config:
1751         msg = "Checking whether TeX allows spaces in file names... "
1752         writeToFile('a b.tex', r'\message{working^^J}' )
1753         if LATEX != '':
1754             if os.name == 'nt' or sys.platform == 'cygwin':
1755                 latex_out = cmdOutput(LATEX + r""" "\nonstopmode\input{\"a b\"}\makeatletter\@@end" """)
1756             else:
1757                 latex_out = cmdOutput(LATEX + r""" '\nonstopmode\input{"a b"}\makeatletter\@@end' """)
1758         else:
1759             latex_out = ''
1760         if 'working' in latex_out:
1761             logger.info(msg + 'yes')
1762             tex_allows_spaces = 'true'
1763         else:
1764             logger.info(msg + 'no')
1765             tex_allows_spaces = 'false'
1766         addToRC(r'\tex_allows_spaces ' + tex_allows_spaces)
1767         removeFiles( [ 'a b.tex', 'a b.log', 'texput.log' ])
1768
1769
1770 def rescanTeXFiles():
1771     ''' Run kpsewhich to update information about TeX files '''
1772     logger.info("+Indexing TeX files... ")
1773     if not os.path.isfile( os.path.join(srcdir, 'scripts', 'TeXFiles.py') ):
1774         logger.error("configure: error: cannot find TeXFiles.py script")
1775         sys.exit(1)
1776     interpreter = sys.executable
1777     if interpreter == '':
1778         interpreter = "python"
1779     tfp = cmdOutput(interpreter + " -tt " + '"'
1780                     + os.path.join(srcdir, 'scripts', 'TeXFiles.py') + '"')
1781     logger.info(tfp)
1782     logger.info("\tdone")
1783
1784
1785 def removeTempFiles():
1786     # Final clean-up
1787     if not lyx_keep_temps:
1788         removeFiles(['chkconfig.vars', 'chklatex.ltx', 'chklatex.log',
1789             'chklayouts.tex', 'chkmodules.tex', 'chkciteengines.tex',
1790             'missfont.log', 'wrap_chkconfig.ltx', 'wrap_chkconfig.log'])
1791
1792
1793 if __name__ == '__main__':
1794     lyx_check_config = True
1795     lyx_kpsewhich = True
1796     outfile = 'lyxrc.defaults'
1797     lyxrc_fileformat = 25
1798     rc_entries = ''
1799     lyx_keep_temps = False
1800     version_suffix = ''
1801     lyx_binary_dir = ''
1802     ## Parse the command line
1803     for op in sys.argv[1:]:   # default shell/for list is $*, the options
1804         if op in [ '-help', '--help', '-h' ]:
1805             print('''Usage: configure [options]
1806 Options:
1807     --help                   show this help lines
1808     --keep-temps             keep temporary files (for debug. purposes)
1809     --without-kpsewhich      do not update TeX files information via kpsewhich
1810     --without-latex-config   do not run LaTeX to determine configuration
1811     --with-version-suffix=suffix suffix of binary installed files
1812     --binary-dir=directory   directory of binary installed files
1813 ''')
1814             sys.exit(0)
1815         elif op == '--without-kpsewhich':
1816             lyx_kpsewhich = False
1817         elif op == '--without-latex-config':
1818             lyx_check_config = False
1819         elif op == '--keep-temps':
1820             lyx_keep_temps = True
1821         elif op[0:22] == '--with-version-suffix=':  # never mind if op is not long enough
1822             version_suffix = op[22:]
1823         elif op[0:13] == '--binary-dir=':
1824             lyx_binary_dir = op[13:]
1825         else:
1826             print("Unknown option %s" % op)
1827             sys.exit(1)
1828     #
1829     # check if we run from the right directory
1830     srcdir = os.path.dirname(sys.argv[0])
1831     if srcdir == '':
1832         srcdir = '.'
1833     if not os.path.isfile( os.path.join(srcdir, 'chkconfig.ltx') ):
1834         logger.error("configure: error: cannot find chkconfig.ltx script")
1835         sys.exit(1)
1836     setEnviron()
1837     if sys.platform == 'darwin' and len(version_suffix) > 0:
1838         checkUpgrade()
1839     createDirectories()
1840     dtl_tools = checkDTLtools()
1841     ## Write the first part of outfile
1842     writeToFile(outfile, '''# This file has been automatically generated by LyX' lib/configure.py
1843 # script. It contains default settings that have been determined by
1844 # examining your system. PLEASE DO NOT MODIFY ANYTHING HERE! If you
1845 # want to customize LyX, use LyX' Preferences dialog or modify directly
1846 # the "preferences" file instead. Any setting in that file will
1847 # override the values given here.
1848
1849 Format %i
1850
1851 ''' % lyxrc_fileformat)
1852     # check latex
1853     LATEX = checkLatex(dtl_tools)
1854     # check java and perl before any checkProg that may require them
1855     java = checkProg('a java interpreter', ['java'])[1]
1856     perl = checkProg('a perl interpreter', ['perl'])[1]
1857     (inkscape_path, inkscape_name) = os.path.split(checkInkscape())
1858     # On MacOSX, Inkscape requires full path file arguments. This
1859     # is not needed on Linux and Win and even breaks the latter.
1860     inkscape_fileprefix = ""
1861     if sys.platform == 'darwin':
1862         inkscape_fileprefix = "$$p"
1863     checkFormatEntries(dtl_tools)
1864     checkConverterEntries()
1865     (chk_docbook, bool_docbook, docbook_cmd) = checkDocBook()
1866     checkTeXAllowSpaces()
1867     windows_style_tex_paths = checkTeXPaths()
1868     if windows_style_tex_paths != '':
1869         addToRC(r'\tex_expects_windows_paths %s' % windows_style_tex_paths)
1870     checkOtherEntries()
1871     if lyx_kpsewhich:
1872         rescanTeXFiles()
1873     checkModulesConfig()
1874     checkCiteEnginesConfig()
1875     checkXTemplates()
1876     # --without-latex-config can disable lyx_check_config
1877     ret = checkLatexConfig(lyx_check_config and LATEX != '', bool_docbook)
1878     removeTempFiles()
1879     # The return error code can be 256. Because most systems expect an error code
1880     # in the range 0-127, 256 can be interpretted as 'success'. Because we expect
1881     # a None for success, 'ret is not None' is used to exit.
1882     sys.exit(ret is not None)