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=$$p$$i --export-area-drawing --without-gui --export-eps=$$p$$o'],
1018         rc_entry = [ r'\converter wmf        eps        "%%"    ""'])
1019     #
1020     checkProg('an EMF -> EPS converter', ['metafile2eps $$i $$o', 'wmf2eps -o $$o $$i', inkscape_name + ' --file=$$p$$i --export-area-drawing --without-gui --export-eps=$$p$$o'],
1021         rc_entry = [ r'\converter emf        eps        "%%"    ""'])
1022     #
1023     checkProg('a WMF -> PDF converter', [inkscape_name + ' --file=$$p$$i --export-area-drawing --without-gui --export-pdf=$$p$$o'],
1024         rc_entry = [ r'\converter wmf        pdf6        "%%"   ""'])
1025     #
1026     checkProg('an EMF -> PDF converter', [inkscape_name + ' --file=$$p$$i --export-area-drawing --without-gui --export-pdf=$$p$$o'],
1027         rc_entry = [ r'\converter emf        pdf6        "%%"   ""'])
1028     # Only define a converter to pdf6 for graphics
1029     checkProg('an EPS -> PDF converter', ['epstopdf'],
1030         rc_entry = [ r'\converter eps        pdf6       "epstopdf --outfile=$$o $$i"    ""'])
1031     #
1032     checkProg('an EPS -> PNG converter', ['magick $$i $$o', 'convert $$i $$o'],
1033         rc_entry = [ r'\converter eps        png        "%%"    ""'])
1034     #
1035     # no agr -> pdf6 converter, since the pdf library used by gracebat is not
1036     # free software and therefore not compiled in in many installations.
1037     # Fortunately, this is not a big problem, because we will use epstopdf to
1038     # convert from agr to pdf6 via eps without loss of quality.
1039     checkProg('a Grace -> Image converter', ['gracebat'],
1040         rc_entry = [
1041             r'''\converter agr        eps        "gracebat -hardcopy -printfile $$o -hdevice EPS $$i 2>/dev/null"       ""
1042 \converter agr        png        "gracebat -hardcopy -printfile $$o -hdevice PNG $$i 2>/dev/null"       ""
1043 \converter agr        jpg        "gracebat -hardcopy -printfile $$o -hdevice JPEG $$i 2>/dev/null"      ""
1044 \converter agr        ppm        "gracebat -hardcopy -printfile $$o -hdevice PNM $$i 2>/dev/null"       ""'''])
1045     #
1046     checkProg('a Dot -> Image converter', ['dot'],
1047         rc_entry = [
1048             r'''\converter dot        eps        "dot -Teps $$i -o $$o" ""
1049 \converter dot        png        "dot -Tpng $$i -o $$o" ""'''])
1050     #
1051     path, dia = checkProg('a Dia -> Image converter', ['dia'])
1052     if dia == 'dia':
1053         addToRC(r'''\converter dia        png        "dia -e $$o -t png $$i"    ""
1054 \converter dia        eps        "dia -e $$o -t eps $$i"        ""
1055 \converter dia        svg        "dia -e $$o -t svg $$i"        ""''')
1056
1057     #
1058     # Actually, this produces EPS, but with a wrong bounding box (usually A4 or letter).
1059     # The eps2->eps converter then fixes the bounding box by cropping.
1060     # Although unoconv can convert to png and pdf as well, do not define
1061     # odg->png and odg->pdf converters, since the bb would be too large as well.
1062     checkProg('an OpenDocument -> EPS converter', ['libreoffice --headless --nologo --convert-to eps $$i', 'unoconv -f eps --stdout $$i > $$o'],
1063         rc_entry = [ r'\converter odg        eps2       "%%"    ""'])
1064     #
1065     checkProg('a SVG (compressed) -> SVG converter', ['gunzip -c $$i > $$o'],
1066         rc_entry = [ r'\converter svgz       svg        "%%"    ""'])
1067     #
1068     checkProg('a SVG -> SVG (compressed) converter', ['gzip -c $$i > $$o'],
1069         rc_entry = [ r'\converter svg        svgz       "%%"    ""'])
1070     # Only define a converter to pdf6 for graphics
1071     # Prefer rsvg-convert over inkscape since it is faster (see http://www.lyx.org/trac/ticket/9891)
1072     checkProg('a SVG -> PDF converter', ['rsvg-convert -f pdf -o $$o $$i', inkscape_name + ' --file=$$p$$i --export-area-drawing --without-gui --export-pdf=$$p$$o'],
1073         rc_entry = [ r'''\converter svg        pdf6       "%%"    ""
1074 \converter svgz       pdf6       "%%"    ""'''],
1075         path = ['', inkscape_path])
1076     #
1077     checkProg('a SVG -> EPS converter', ['rsvg-convert -f ps -o $$o $$i', inkscape_name + ' --file=$$p$$i --export-area-drawing --without-gui --export-eps=$$p$$o'],
1078         rc_entry = [ r'''\converter svg        eps        "%%"    ""
1079 \converter svgz       eps        "%%"    ""'''],
1080         path = ['', inkscape_path])
1081     #
1082     checkProg('a SVG -> PNG converter', ['rsvg-convert -f png -o $$o $$i', inkscape_name + ' --without-gui --file=$$i --export-png=$$o'],
1083         rc_entry = [ r'''\converter svg        png        "%%"    "",
1084 \converter svgz       png        "%%"    ""'''],
1085         path = ['', inkscape_path])
1086     #
1087     checkProg('Gnuplot', ['gnuplot'],
1088         rc_entry = [ r'''\Format gnuplot     "gp, gnuplot"    "Gnuplot"     "" "" ""  "vector"  "text/plain"
1089 \converter gnuplot      pdf6      "python -tt $$s/scripts/gnuplot2pdf.py $$i $$o"    "needauth"''' ])
1090     #
1091     # gnumeric/xls/ods to tex
1092     checkProg('a spreadsheet -> latex converter', ['ssconvert'],
1093        rc_entry = [ r'''\converter gnumeric latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1094 \converter oocalc latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1095 \converter excel  latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1096 \converter excel2 latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
1097 \converter gnumeric html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1098 \converter oocalc html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1099 \converter excel  html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1100 \converter excel2 html_table "ssconvert --export-type=Gnumeric_html:html40frag $$i $$o" ""
1101 '''])
1102
1103     path, lilypond = checkProg('a LilyPond -> EPS/PDF/PNG converter', ['lilypond'])
1104     if (lilypond != ''):
1105         version_string = cmdOutput("lilypond --version")
1106         match = re.match('GNU LilyPond (\S+)', version_string)
1107         if match:
1108             version_number = match.groups()[0]
1109             version = version_number.split('.')
1110             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 11):
1111                 addToRC(r'''\converter lilypond   eps        "lilypond -dbackend=eps -dsafe --ps $$i"   ""
1112 \converter lilypond   png        "lilypond -dbackend=eps -dsafe --png $$i"      ""''')
1113                 addToRC(r'\converter lilypond   pdf6       "lilypond -dbackend=eps -dsafe --pdf $$i"    ""')
1114                 logger.info('+  found LilyPond version %s.' % version_number)
1115             elif int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 6):
1116                 addToRC(r'''\converter lilypond   eps        "lilypond -b eps --ps --safe $$i"  ""
1117 \converter lilypond   png        "lilypond -b eps --png $$i"    ""''')
1118                 if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 9):
1119                     addToRC(r'\converter lilypond   pdf6       "lilypond -b eps --pdf --safe $$i"       ""')
1120                 logger.info('+  found LilyPond version %s.' % version_number)
1121             else:
1122                 logger.info('+  found LilyPond, but version %s is too old.' % version_number)
1123         else:
1124             logger.info('+  found LilyPond, but could not extract version number.')
1125     #
1126     path, lilypond_book = checkProg('a LilyPond book (LaTeX) -> LaTeX converter', ['lilypond-book'])
1127     if (lilypond_book != ''):
1128         version_string = cmdOutput("lilypond-book --version")
1129         match = re.match('^(\S+)$', version_string)
1130         if match:
1131             version_number = match.groups()[0]
1132             version = version_number.split('.')
1133             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 13):
1134                 # Note: The --lily-output-dir flag is required because lilypond-book
1135                 #       does not process input again unless the input has changed,
1136                 #       even if the output format being requested is different. So
1137                 #       once a .eps file exists, lilypond-book won't create a .pdf
1138                 #       even when requested with --pdf. This is a problem if a user
1139                 #       clicks View PDF after having done a View DVI. To circumvent
1140                 #       this, use different output folders for eps and pdf outputs.
1141                 addToRC(r'\converter lilypond-book latex    "lilypond-book --safe --lily-output-dir=ly-eps $$i"                                ""')
1142                 addToRC(r'\converter lilypond-book pdflatex "lilypond-book --safe --pdf --latex-program=pdflatex --lily-output-dir=ly-pdf $$i" ""')
1143                 addToRC(r'\converter lilypond-book-ja platex "lilypond-book --safe --pdf --latex-program=platex --lily-output-dir=ly-pdf $$i" ""')
1144                 addToRC(r'\converter lilypond-book xetex    "lilypond-book --safe --pdf --latex-program=xelatex --lily-output-dir=ly-pdf $$i"  ""')
1145                 addToRC(r'\converter lilypond-book luatex   "lilypond-book --safe --pdf --latex-program=lualatex --lily-output-dir=ly-pdf $$i" ""')
1146                 addToRC(r'\converter lilypond-book dviluatex "lilypond-book --safe --latex-program=dvilualatex --lily-output-dir=ly-eps $$i" ""')
1147                 logger.info('+  found LilyPond-book version %s.' % version_number)
1148             else:
1149                 logger.info('+  found LilyPond-book, but version %s is too old.' % version_number)
1150         else:
1151             logger.info('+  found LilyPond-book, but could not extract version number.')
1152     #
1153     checkProg('a Noteedit -> LilyPond converter', ['noteedit --export-lilypond $$i'],
1154         rc_entry = [ r'\converter noteedit   lilypond   "%%"    ""' ])
1155     #
1156     # Currently, lyxpak outputs a gzip compressed tar archive on *nix
1157     # and a zip archive on Windows.
1158     # So, we configure the appropriate version according to the platform.
1159     cmd = r'\converter lyx %s "python -tt $$s/scripts/lyxpak.py $$r/$$f" ""'
1160     if os.name == 'nt':
1161         addToRC(r'\Format lyxzip     zip    "LyX Archive (zip)"     "" "" ""  "document,menu=export"    ""')
1162         addToRC(cmd % "lyxzip")
1163     else:
1164         addToRC(r'\Format lyxgz      gz     "LyX Archive (tar.gz)"  "" "" ""  "document,menu=export"    ""')
1165         addToRC(cmd % "lyxgz")
1166
1167     #
1168     # FIXME: no rc_entry? comment it out
1169     # checkProg('Image converter', ['convert $$i $$o'])
1170     #
1171     # Entries that do not need checkProg
1172     addToRC(r'''
1173 \converter csv        lyx        "python -tt $$s/scripts/csv2lyx.py $$i $$o"    ""
1174 \converter docbook    docbook-xml "cp $$i $$o"  "xml"
1175 \converter fen        asciichess "python -tt $$s/scripts/fen2ascii.py $$i $$o"  ""
1176 \converter lyx        lyx13x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.3 -o $$o $$i"     ""
1177 \converter lyx        lyx14x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o $$i"     ""
1178 \converter lyx        lyx15x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.5 -o $$o $$i"     ""
1179 \converter lyx        lyx16x     "python -tt $$s/lyx2lyx/lyx2lyx -V 1.6 -o $$o $$i"     ""
1180 \converter lyx        lyx20x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.0 -o $$o $$i"     ""
1181 \converter lyx        lyx21x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.1 -o $$o $$i"     ""
1182 \converter lyx        lyx22x     "python -tt $$s/lyx2lyx/lyx2lyx -V 2.2 -o $$o $$i"     ""
1183 \converter lyx        clyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c big5   $$i"   ""
1184 \converter lyx        jlyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c euc_jp $$i"   ""
1185 \converter lyx        klyx       "python -tt $$s/lyx2lyx/lyx2lyx -V 1.4 -o $$o -c euc_kr $$i"   ""
1186 \converter clyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c big5   -o $$o $$i"  ""
1187 \converter jlyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_jp -o $$o $$i"  ""
1188 \converter klyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_kr -o $$o $$i"  ""
1189 \converter lyxpreview png        "python -tt $$s/scripts/lyxpreview2bitmap.py --png"    ""
1190 \converter lyxpreview ppm        "python -tt $$s/scripts/lyxpreview2bitmap.py --ppm"    ""
1191 ''')
1192
1193
1194 def checkDocBook():
1195     ''' Check docbook '''
1196     path, DOCBOOK = checkProg('SGML-tools 2.x (DocBook), db2x scripts or xsltproc', ['sgmltools', 'db2dvi', 'xsltproc'],
1197         rc_entry = [
1198             r'''\converter docbook    dvi        "sgmltools -b dvi $$i" ""
1199 \converter docbook    html       "sgmltools -b html $$i"        ""
1200 \converter docbook    ps         "sgmltools -b ps $$i"  ""''',
1201             r'''\converter docbook    dvi        "db2dvi $$i"   ""
1202 \converter docbook    html       "db2html $$i"  ""''',
1203             r'''\converter docbook    dvi        ""     ""
1204 \converter docbook    html       "" ""''',
1205             r'''\converter docbook    dvi        ""     ""
1206 \converter docbook    html       ""     ""'''])
1207     #
1208     if DOCBOOK != '':
1209         return ('yes', 'true', '\\def\\hasdocbook{yes}')
1210     else:
1211         return ('no', 'false', '')
1212
1213
1214 def checkOtherEntries():
1215     ''' entries other than Format and Converter '''
1216     checkProg('ChkTeX', ['chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38'],
1217         rc_entry = [ r'\chktex_command "%%"' ])
1218     checkProgAlternatives('BibTeX or alternative programs',
1219         ['bibtex', 'bibtex8', 'biber'],
1220         rc_entry = [ r'\bibtex_command "automatic"' ],
1221         alt_rc_entry = [ r'\bibtex_alternatives "%%"' ])
1222     checkProgAlternatives('a specific Japanese BibTeX variant',
1223         ['pbibtex', 'upbibtex', 'jbibtex', 'bibtex', 'biber'],
1224         rc_entry = [ r'\jbibtex_command "automatic"' ],
1225         alt_rc_entry = [ r'\jbibtex_alternatives "%%"' ])
1226     checkProgAlternatives('available index processors',
1227         ['texindy', 'makeindex -c -q', 'xindy'],
1228         rc_entry = [ r'\index_command "%%"' ],
1229         alt_rc_entry = [ r'\index_alternatives "%%"' ])
1230     checkProg('an index processor appropriate to Japanese',
1231         ['mendex -c -q', 'jmakeindex -c -q', 'makeindex -c -q'],
1232         rc_entry = [ r'\jindex_command "%%"' ])
1233     checkProg('the splitindex processor', ['splitindex.pl', 'splitindex',
1234         'splitindex.class'], rc_entry = [ r'\splitindex_command "%%"' ])
1235     checkProg('a nomenclature processor', ['makeindex'],
1236         rc_entry = [ r'\nomencl_command "makeindex -s nomencl.ist"' ])
1237     checkProg('a python-pygments driver command', ['pygmentize'],
1238         rc_entry = [ r'\pygmentize_command "%%"' ])
1239     ## FIXME: OCTAVE is not used anywhere
1240     # path, OCTAVE = checkProg('Octave', ['octave'])
1241     ## FIXME: MAPLE is not used anywhere
1242     # path, MAPLE = checkProg('Maple', ['maple'])
1243     # Add the rest of the entries (no checkProg is required)
1244     addToRC(r'''\copier    fig        "python -tt $$s/scripts/fig_copy.py $$i $$o"
1245 \copier    pstex      "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
1246 \copier    pdftex     "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
1247 \copier    program    "python -tt $$s/scripts/ext_copy.py $$i $$o"
1248 ''')
1249
1250
1251 def processLayoutFile(file, bool_docbook):
1252     ''' process layout file and get a line of result
1253
1254         Declare lines look like this:
1255
1256         \DeclareLaTeXClass[<requirements>]{<description>}
1257
1258         Optionally, a \DeclareCategory line follows:
1259
1260         \DeclareCategory{<category>}
1261
1262         So for example (article.layout, scrbook.layout, svjog.layout)
1263
1264         \DeclareLaTeXClass{article}
1265         \DeclareCategory{Articles}
1266
1267         \DeclareLaTeXClass[scrbook]{book (koma-script)}
1268         \DeclareCategory{Books}
1269
1270         \DeclareLaTeXClass[svjour,svjog.clo]{article (Springer - svjour/jog)}
1271
1272         we'd expect this output:
1273
1274         "article" "article" "article" "false" "article.cls" "Articles"
1275         "scrbook" "scrbook" "book (koma-script)" "false" "scrbook.cls" "Books"
1276         "svjog" "svjour" "article (Springer - svjour/jog)" "false" "svjour.cls,svjog.clo" ""
1277     '''
1278     def checkForClassExtension(x):
1279         '''if the extension for a latex class is not
1280            provided, add .cls to the classname'''
1281         if not '.' in x:
1282             return x.strip() + '.cls'
1283         else:
1284             return x.strip()
1285     classname = file.split(os.sep)[-1].split('.')[0]
1286     # return ('LaTeX', '[a,b]', 'a', ',b,c', 'article') for \DeclareLaTeXClass[a,b,c]{article}
1287     p = re.compile(r'^\s*#\s*\\Declare(LaTeX|DocBook)Class\s*(\[([^,]*)(,.*)*\])*\s*{(.*)}\s*$')
1288     q = re.compile(r'^\s*#\s*\\DeclareCategory{(.*)}\s*$')
1289     classdeclaration = ""
1290     categorydeclaration = '""'
1291     for line in open(file).readlines():
1292         res = p.search(line)
1293         qres = q.search(line)
1294         if res != None:
1295             (classtype, optAll, opt, opt1, desc) = res.groups()
1296             avai = {'LaTeX':'false', 'DocBook':bool_docbook}[classtype]
1297             if opt == None:
1298                 opt = classname
1299                 prereq_latex = checkForClassExtension(classname)
1300             else:
1301                 prereq_list = optAll[1:-1].split(',')
1302                 prereq_list = list(map(checkForClassExtension, prereq_list))
1303                 prereq_latex = ','.join(prereq_list)
1304             prereq_docbook = {'true':'', 'false':'docbook'}[bool_docbook]
1305             prereq = {'LaTeX':prereq_latex, 'DocBook':prereq_docbook}[classtype]
1306             classdeclaration = ('"%s" "%s" "%s" "%s" "%s"'
1307                                % (classname, opt, desc, avai, prereq))
1308             if categorydeclaration != '""':
1309                 return classdeclaration + " " + categorydeclaration
1310         if qres != None:
1311              categorydeclaration = '"%s"' % (qres.groups()[0])
1312              if classdeclaration != "":
1313                  return classdeclaration + " " + categorydeclaration
1314     if classdeclaration != "":
1315         return classdeclaration + " " + categorydeclaration
1316     logger.warning("Layout file " + file + " has no \DeclareXXClass line. ")
1317     return ""
1318
1319
1320 def checkLatexConfig(check_config, bool_docbook):
1321     ''' Explore the LaTeX configuration
1322         Return None (will be passed to sys.exit()) for success.
1323     '''
1324     msg = 'checking LaTeX configuration... '
1325     # if --without-latex-config is forced, or if there is no previous
1326     # version of textclass.lst, re-generate a default file.
1327     if not os.path.isfile('textclass.lst') or not check_config:
1328         # remove the files only if we want to regenerate
1329         removeFiles(['textclass.lst', 'packages.lst'])
1330         #
1331         # Then, generate a default textclass.lst. In case configure.py
1332         # fails, we still have something to start lyx.
1333         logger.info(msg + ' default values')
1334         logger.info('+checking list of textclasses... ')
1335         tx = open('textclass.lst', 'w')
1336         tx.write('''
1337 # This file declares layouts and their associated definition files
1338 # (include dir. relative to the place where this file is).
1339 # It contains only default values, since chkconfig.ltx could not be run
1340 # for some reason. Run ./configure.py if you need to update it after a
1341 # configuration change.
1342 ''')
1343         # build the list of available layout files and convert it to commands
1344         # for chkconfig.ltx
1345         foundClasses = []
1346         for file in (glob.glob(os.path.join('layouts', '*.layout'))
1347                      + glob.glob(os.path.join(srcdir, 'layouts', '*.layout'))):
1348             # valid file?
1349             if not os.path.isfile(file):
1350                 continue
1351             # get stuff between /xxxx.layout .
1352             classname = file.split(os.sep)[-1].split('.')[0]
1353             #  tr ' -' '__'`
1354             cleanclass = classname.replace(' ', '_')
1355             cleanclass = cleanclass.replace('-', '_')
1356             # make sure the same class is not considered twice
1357             if foundClasses.count(cleanclass) == 0: # not found before
1358                 foundClasses.append(cleanclass)
1359                 retval = processLayoutFile(file, bool_docbook)
1360                 if retval != "":
1361                     tx.write(retval)
1362         tx.close()
1363         logger.info('\tdone')
1364     if not os.path.isfile('packages.lst') or not check_config:
1365         logger.info('+generating default list of packages... ')
1366         removeFiles(['packages.lst'])
1367         tx = open('packages.lst', 'w')
1368         tx.close()
1369         logger.info('\tdone')
1370     if not check_config:
1371         return None
1372     # the following will generate textclass.lst.tmp, and packages.lst.tmp
1373     logger.info(msg + '\tauto')
1374     removeFiles(['chkconfig.classes', 'chkconfig.vars', 'chklayouts.tex',
1375         'wrap_chkconfig.ltx'])
1376     rmcopy = False
1377     if not os.path.isfile( 'chkconfig.ltx' ):
1378         shutil.copyfile( os.path.join(srcdir, 'chkconfig.ltx'), 'chkconfig.ltx' )
1379         rmcopy = True
1380     writeToFile('wrap_chkconfig.ltx', '%s\n\\input{chkconfig.ltx}\n' % docbook_cmd)
1381     # Construct the list of classes to test for.
1382     # build the list of available layout files and convert it to commands
1383     # for chkconfig.ltx
1384     declare = re.compile(b'^\\s*#\\s*\\\\Declare(LaTeX|DocBook)Class\\s*(\[([^,]*)(,.*)*\])*\\s*{(.*)}\\s*$')
1385     category = re.compile(b'^\\s*#\\s*\\\\DeclareCategory{(.*)}\\s*$')
1386     empty = re.compile(b'^\\s*$')
1387     testclasses = list()
1388     for file in (glob.glob( os.path.join('layouts', '*.layout') )
1389                  + glob.glob( os.path.join(srcdir, 'layouts', '*.layout' ) ) ):
1390         nodeclaration = False
1391         if not os.path.isfile(file):
1392             continue
1393         classname = file.split(os.sep)[-1].split('.')[0]
1394         decline = b""
1395         catline = b""
1396         for line in open(file, 'rb').readlines():
1397             if not empty.match(line) and line[0] != b'#'[0]:
1398                 if decline == b"":
1399                     logger.warning("Failed to find valid \Declare line "
1400                         "for layout file `%s'.\n\t=> Skipping this file!" % file)
1401                     nodeclaration = True
1402                 # A class, but no category declaration. Just break.
1403                 break
1404             if declare.search(line) != None:
1405                 decline = b"\\TestDocClass{%s}{%s}" \
1406                            % (classname.encode('ascii'), line[1:].strip())
1407                 testclasses.append(decline)
1408             elif category.search(line) != None:
1409                 catline = (b"\\DeclareCategory{%s}{%s}"
1410                            % (classname.encode('ascii'),
1411                               category.search(line).groups()[0]))
1412                 testclasses.append(catline)
1413             if catline == b"" or decline == b"":
1414                 continue
1415             break
1416         if nodeclaration:
1417             continue
1418     testclasses.sort()
1419     cl = open('chklayouts.tex', 'wb')
1420     for line in testclasses:
1421         cl.write(line + b'\n')
1422     cl.close()
1423     #
1424     # we have chklayouts.tex, then process it
1425     latex_out = cmdOutput(LATEX + ' wrap_chkconfig.ltx', True)
1426     while True:
1427         line = latex_out.readline()
1428         if not line:
1429             break;
1430         if re.match('^\+', line):
1431             logger.info(line.strip())
1432     # if the command succeeds, None will be returned
1433     ret = latex_out.close()
1434     #
1435     # remove the copied file
1436     if rmcopy:
1437         removeFiles( [ 'chkconfig.ltx' ] )
1438     #
1439     # currently, values in chkconfig are only used to set
1440     # \font_encoding
1441     values = {}
1442     for line in open('chkconfig.vars').readlines():
1443         key, val = re.sub('-', '_', line).split('=')
1444         val = val.strip()
1445         values[key] = val.strip("'")
1446     # chk_fontenc may not exist
1447     try:
1448         addToRC(r'\font_encoding "%s"' % values["chk_fontenc"])
1449     except:
1450         pass
1451     # if configure successed, move textclass.lst.tmp to textclass.lst
1452     # and packages.lst.tmp to packages.lst
1453     if (os.path.isfile('textclass.lst.tmp')
1454           and len(open('textclass.lst.tmp').read()) > 0
1455         and os.path.isfile('packages.lst.tmp')
1456           and len(open('packages.lst.tmp').read()) > 0):
1457         shutil.move('textclass.lst.tmp', 'textclass.lst')
1458         shutil.move('packages.lst.tmp', 'packages.lst')
1459     return ret
1460
1461
1462 def checkModulesConfig():
1463   removeFiles(['lyxmodules.lst', 'chkmodules.tex'])
1464
1465   logger.info('+checking list of modules... ')
1466   tx = open('lyxmodules.lst', 'w')
1467   tx.write('''## This file declares modules and their associated definition files.
1468 ## It has been automatically generated by configure
1469 ## Use "Options/Reconfigure" if you need to update it after a
1470 ## configuration change.
1471 ## "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1472 ''')
1473
1474   # build the list of available modules
1475   seen = []
1476   # note that this searches the local directory first, then the
1477   # system directory. that way, we pick up the user's version first.
1478   for file in (glob.glob( os.path.join('layouts', '*.module') )
1479                + glob.glob( os.path.join(srcdir, 'layouts', '*.module' ) ) ):
1480       # valid file?
1481       logger.info(file)
1482       if not os.path.isfile(file):
1483           continue
1484
1485       filename = file.split(os.sep)[-1]
1486       filename = filename[:-7]
1487       if seen.count(filename):
1488           continue
1489
1490       seen.append(filename)
1491       retval = processModuleFile(file, filename, bool_docbook)
1492       if retval != "":
1493           tx.write(retval)
1494   tx.close()
1495   logger.info('\tdone')
1496
1497
1498 def processModuleFile(file, filename, bool_docbook):
1499     ''' process module file and get a line of result
1500
1501         The top of a module file should look like this:
1502           #\DeclareLyXModule[LaTeX Packages]{ModuleName}
1503           #DescriptionBegin
1504           #...body of description...
1505           #DescriptionEnd
1506           #Requires: [list of required modules]
1507           #Excludes: [list of excluded modules]
1508           #Category: [category name]
1509         The last three lines are optional (though do give a category).
1510         We expect output:
1511           "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1512     '''
1513     remods = re.compile(r'\DeclareLyXModule\s*(?:\[([^]]*?)\])?{(.*)}')
1514     rereqs = re.compile(r'#+\s*Requires: (.*)')
1515     reexcs = re.compile(r'#+\s*Excludes: (.*)')
1516     recaty = re.compile(r'#+\s*Category: (.*)')
1517     redbeg = re.compile(r'#+\s*DescriptionBegin\s*$')
1518     redend = re.compile(r'#+\s*DescriptionEnd\s*$')
1519
1520     modname = desc = pkgs = req = excl = catgy = ""
1521     readingDescription = False
1522     descLines = []
1523
1524     for line in open(file).readlines():
1525       if readingDescription:
1526         res = redend.search(line)
1527         if res != None:
1528           readingDescription = False
1529           desc = " ".join(descLines)
1530           # Escape quotes.
1531           desc = desc.replace('"', '\\"')
1532           continue
1533         descLines.append(line[1:].strip())
1534         continue
1535       res = redbeg.search(line)
1536       if res != None:
1537         readingDescription = True
1538         continue
1539       res = remods.search(line)
1540       if res != None:
1541           (pkgs, modname) = res.groups()
1542           if pkgs == None:
1543             pkgs = ""
1544           else:
1545             tmp = [s.strip() for s in pkgs.split(",")]
1546             pkgs = ",".join(tmp)
1547           continue
1548       res = rereqs.search(line)
1549       if res != None:
1550         req = res.group(1)
1551         tmp = [s.strip() for s in req.split("|")]
1552         req = "|".join(tmp)
1553         continue
1554       res = reexcs.search(line)
1555       if res != None:
1556         excl = res.group(1)
1557         tmp = [s.strip() for s in excl.split("|")]
1558         excl = "|".join(tmp)
1559         continue
1560       res = recaty.search(line)
1561       if res != None:
1562         catgy = res.group(1)
1563         continue
1564
1565     if modname == "":
1566       logger.warning("Module file without \DeclareLyXModule line. ")
1567       return ""
1568
1569     if pkgs != "":
1570         # this module has some latex dependencies:
1571         # append the dependencies to chkmodules.tex,
1572         # which is \input'ed by chkconfig.ltx
1573         testpackages = list()
1574         for pkg in pkgs.split(","):
1575             if "->" in pkg:
1576                 # this is a converter dependency: skip
1577                 continue
1578             if pkg.endswith(".sty"):
1579                 pkg = pkg[:-4]
1580             testpackages.append("\\TestPackage{%s}" % (pkg,))
1581         cm = open('chkmodules.tex', 'a')
1582         for line in testpackages:
1583             cm.write(line + '\n')
1584         cm.close()
1585
1586     return ('"%s" "%s" "%s" "%s" "%s" "%s" "%s"\n'
1587             % (modname, filename, desc, pkgs, req, excl, catgy))
1588
1589
1590 def checkCiteEnginesConfig():
1591   removeFiles(['lyxciteengines.lst', 'chkciteengines.tex'])
1592
1593   logger.info('+checking list of cite engines... ')
1594   tx = open('lyxciteengines.lst', 'w')
1595   tx.write('''## This file declares cite engines and their associated definition files.
1596 ## It has been automatically generated by configure
1597 ## Use "Options/Reconfigure" if you need to update it after a
1598 ## configuration change.
1599 ## "CiteEngineName" "filename" "CiteEngineType" "CiteFramework" "DefaultBiblio" "Description" "Packages"
1600 ''')
1601
1602   # build the list of available modules
1603   seen = []
1604   # note that this searches the local directory first, then the
1605   # system directory. that way, we pick up the user's version first.
1606   for file in glob.glob( os.path.join('citeengines', '*.citeengine') ) + \
1607       glob.glob( os.path.join(srcdir, 'citeengines', '*.citeengine' ) ) :
1608       # valid file?
1609       logger.info(file)
1610       if not os.path.isfile(file):
1611           continue
1612
1613       filename = file.split(os.sep)[-1]
1614       filename = filename[:-11]
1615       if seen.count(filename):
1616           continue
1617
1618       seen.append(filename)
1619       retval = processCiteEngineFile(file, filename, bool_docbook)
1620       if retval != "":
1621           tx.write(retval)
1622   tx.close()
1623   logger.info('\tdone')
1624
1625
1626 def processCiteEngineFile(file, filename, bool_docbook):
1627     ''' process cite engines file and get a line of result
1628
1629         The top of a cite engine file should look like this:
1630           #\DeclareLyXCiteEngine[LaTeX Packages]{CiteEngineName}
1631           #DescriptionBegin
1632           #...body of description...
1633           #DescriptionEnd
1634         We expect output:
1635           "CiteEngineName" "filename" "CiteEngineType" "CiteFramework" "DefaultBiblio" "Description" "Packages"
1636     '''
1637     remods = re.compile(r'\DeclareLyXCiteEngine\s*(?:\[([^]]*?)\])?{(.*)}')
1638     redbeg = re.compile(r'#+\s*DescriptionBegin\s*$')
1639     redend = re.compile(r'#+\s*DescriptionEnd\s*$')
1640     recet = re.compile(r'\s*CiteEngineType\s*(.*)')
1641     redb = re.compile(r'\s*DefaultBiblio\s*(.*)')
1642     resfm = re.compile(r'\s*CiteFramework\s*(.*)')
1643
1644     modname = desc = pkgs = cet = db = cfm = ""
1645     readingDescription = False
1646     descLines = []
1647
1648     for line in open(file).readlines():
1649       if readingDescription:
1650         res = redend.search(line)
1651         if res != None:
1652           readingDescription = False
1653           desc = " ".join(descLines)
1654           # Escape quotes.
1655           desc = desc.replace('"', '\\"')
1656           continue
1657         descLines.append(line[1:].strip())
1658         continue
1659       res = redbeg.search(line)
1660       if res != None:
1661         readingDescription = True
1662         continue
1663       res = remods.search(line)
1664       if res != None:
1665           (pkgs, modname) = res.groups()
1666           if pkgs == None:
1667             pkgs = ""
1668           else:
1669             tmp = [s.strip() for s in pkgs.split(",")]
1670             pkgs = ",".join(tmp)
1671           continue
1672       res = recet.search(line)
1673       if res != None:
1674         cet = res.group(1)
1675         continue
1676       res = redb.search(line)
1677       if res != None:
1678         db = res.group(1)
1679         continue
1680       res = resfm.search(line)
1681       if res != None:
1682         cfm = res.group(1)
1683         continue
1684
1685     if modname == "":
1686       logger.warning("Cite Engine File file without \DeclareLyXCiteEngine line. ")
1687       return ""
1688
1689     if pkgs != "":
1690         # this cite engine has some latex dependencies:
1691         # append the dependencies to chkciteengines.tex,
1692         # which is \input'ed by chkconfig.ltx
1693         testpackages = list()
1694         for pkg in pkgs.split(","):
1695             if "->" in pkg:
1696                 # this is a converter dependency: skip
1697                 continue
1698             if pkg.endswith(".sty"):
1699                 pkg = pkg[:-4]
1700             testpackages.append("\\TestPackage{%s}" % (pkg,))
1701         cm = open('chkciteengines.tex', 'a')
1702         for line in testpackages:
1703             cm.write(line + '\n')
1704         cm.close()
1705
1706     return '"%s" "%s" "%s" "%s" "%s" "%s" "%s"\n' % (modname, filename, cet, cfm, db, desc, pkgs)
1707
1708
1709 def checkXTemplates():
1710   removeFiles(['xtemplates.lst'])
1711
1712   logger.info('+checking list of external templates... ')
1713   tx = open('xtemplates.lst', 'w')
1714   tx.write('''## This file lists external templates.
1715 ## It has been automatically generated by configure
1716 ## Use "Options/Reconfigure" if you need to update it after a
1717 ## configuration change.
1718 ''')
1719
1720   # build the list of available templates
1721   seen = []
1722   # note that this searches the local directory first, then the
1723   # system directory. that way, we pick up the user's version first.
1724   for file in glob.glob( os.path.join('xtemplates', '*.xtemplate') ) + \
1725       glob.glob( os.path.join(srcdir, 'xtemplates', '*.xtemplate' ) ) :
1726       # valid file?
1727       logger.info(file)
1728       if not os.path.isfile(file):
1729           continue
1730
1731       filename = file.split(os.sep)[-1]
1732       if seen.count(filename):
1733           continue
1734
1735       seen.append(filename)
1736       if filename != "":
1737           tx.write(filename + "\n")
1738   tx.close()
1739   logger.info('\tdone')
1740
1741
1742 def checkTeXAllowSpaces():
1743     ''' Let's check whether spaces are allowed in TeX file names '''
1744     tex_allows_spaces = 'false'
1745     if lyx_check_config:
1746         msg = "Checking whether TeX allows spaces in file names... "
1747         writeToFile('a b.tex', r'\message{working^^J}' )
1748         if LATEX != '':
1749             if os.name == 'nt' or sys.platform == 'cygwin':
1750                 latex_out = cmdOutput(LATEX + r""" "\nonstopmode\input{\"a b\"}\makeatletter\@@end" """)
1751             else:
1752                 latex_out = cmdOutput(LATEX + r""" '\nonstopmode\input{"a b"}\makeatletter\@@end' """)
1753         else:
1754             latex_out = ''
1755         if 'working' in latex_out:
1756             logger.info(msg + 'yes')
1757             tex_allows_spaces = 'true'
1758         else:
1759             logger.info(msg + 'no')
1760             tex_allows_spaces = 'false'
1761         addToRC(r'\tex_allows_spaces ' + tex_allows_spaces)
1762         removeFiles( [ 'a b.tex', 'a b.log', 'texput.log' ])
1763
1764
1765 def rescanTeXFiles():
1766     ''' Run kpsewhich to update information about TeX files '''
1767     logger.info("+Indexing TeX files... ")
1768     if not os.path.isfile( os.path.join(srcdir, 'scripts', 'TeXFiles.py') ):
1769         logger.error("configure: error: cannot find TeXFiles.py script")
1770         sys.exit(1)
1771     interpreter = sys.executable
1772     if interpreter == '':
1773         interpreter = "python"
1774     tfp = cmdOutput(interpreter + " -tt " + '"'
1775                     + os.path.join(srcdir, 'scripts', 'TeXFiles.py') + '"')
1776     logger.info(tfp)
1777     logger.info("\tdone")
1778
1779
1780 def removeTempFiles():
1781     # Final clean-up
1782     if not lyx_keep_temps:
1783         removeFiles(['chkconfig.vars', 'chklatex.ltx', 'chklatex.log',
1784             'chklayouts.tex', 'chkmodules.tex', 'chkciteengines.tex',
1785             'missfont.log', 'wrap_chkconfig.ltx', 'wrap_chkconfig.log'])
1786
1787
1788 if __name__ == '__main__':
1789     lyx_check_config = True
1790     lyx_kpsewhich = True
1791     outfile = 'lyxrc.defaults'
1792     lyxrc_fileformat = 24
1793     rc_entries = ''
1794     lyx_keep_temps = False
1795     version_suffix = ''
1796     lyx_binary_dir = ''
1797     ## Parse the command line
1798     for op in sys.argv[1:]:   # default shell/for list is $*, the options
1799         if op in [ '-help', '--help', '-h' ]:
1800             print('''Usage: configure [options]
1801 Options:
1802     --help                   show this help lines
1803     --keep-temps             keep temporary files (for debug. purposes)
1804     --without-kpsewhich      do not update TeX files information via kpsewhich
1805     --without-latex-config   do not run LaTeX to determine configuration
1806     --with-version-suffix=suffix suffix of binary installed files
1807     --binary-dir=directory   directory of binary installed files
1808 ''')
1809             sys.exit(0)
1810         elif op == '--without-kpsewhich':
1811             lyx_kpsewhich = False
1812         elif op == '--without-latex-config':
1813             lyx_check_config = False
1814         elif op == '--keep-temps':
1815             lyx_keep_temps = True
1816         elif op[0:22] == '--with-version-suffix=':  # never mind if op is not long enough
1817             version_suffix = op[22:]
1818         elif op[0:13] == '--binary-dir=':
1819             lyx_binary_dir = op[13:]
1820         else:
1821             print("Unknown option %s" % op)
1822             sys.exit(1)
1823     #
1824     # check if we run from the right directory
1825     srcdir = os.path.dirname(sys.argv[0])
1826     if srcdir == '':
1827         srcdir = '.'
1828     if not os.path.isfile( os.path.join(srcdir, 'chkconfig.ltx') ):
1829         logger.error("configure: error: cannot find chkconfig.ltx script")
1830         sys.exit(1)
1831     setEnviron()
1832     if sys.platform == 'darwin' and len(version_suffix) > 0:
1833         checkUpgrade()
1834     createDirectories()
1835     dtl_tools = checkDTLtools()
1836     ## Write the first part of outfile
1837     writeToFile(outfile, '''# This file has been automatically generated by LyX' lib/configure.py
1838 # script. It contains default settings that have been determined by
1839 # examining your system. PLEASE DO NOT MODIFY ANYTHING HERE! If you
1840 # want to customize LyX, use LyX' Preferences dialog or modify directly
1841 # the "preferences" file instead. Any setting in that file will
1842 # override the values given here.
1843
1844 Format %i
1845
1846 ''' % lyxrc_fileformat)
1847     # check latex
1848     LATEX = checkLatex(dtl_tools)
1849     # check java and perl before any checkProg that may require them
1850     java = checkProg('a java interpreter', ['java'])[1]
1851     perl = checkProg('a perl interpreter', ['perl'])[1]
1852     (inkscape_path, inkscape_name) = os.path.split(checkInkscape())
1853     checkFormatEntries(dtl_tools)
1854     checkConverterEntries()
1855     (chk_docbook, bool_docbook, docbook_cmd) = checkDocBook()
1856     checkTeXAllowSpaces()
1857     windows_style_tex_paths = checkTeXPaths()
1858     if windows_style_tex_paths != '':
1859         addToRC(r'\tex_expects_windows_paths %s' % windows_style_tex_paths)
1860     checkOtherEntries()
1861     if lyx_kpsewhich:
1862         rescanTeXFiles()
1863     checkModulesConfig()
1864     checkCiteEnginesConfig()
1865     checkXTemplates()
1866     # --without-latex-config can disable lyx_check_config
1867     ret = checkLatexConfig(lyx_check_config and LATEX != '', bool_docbook)
1868     removeTempFiles()
1869     # The return error code can be 256. Because most systems expect an error code
1870     # in the range 0-127, 256 can be interpretted as 'success'. Because we expect
1871     # a None for success, 'ret is not None' is used to exit.
1872     sys.exit(ret is not None)