From: Enrico Forestieri Date: Fri, 9 Feb 2024 21:46:05 +0000 (+0100) Subject: Adapt lyxpak.py to work with Python 3 on Windows X-Git-Url: https://git.lyx.org/gitweb/?a=commitdiff_plain;h=fe99f7b01e6ace4db716326a9d5455b2a168e3fd;p=features.git Adapt lyxpak.py to work with Python 3 on Windows Seemingly, the elements of argv on Windows are a different type with respect to Linux. A patched version of getopt.py has to be used on Windows in order to match variable types. --- diff --git a/lib/Makefile.am b/lib/Makefile.am index d5b0d4441d..efe9cc969e 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -2746,6 +2746,7 @@ dist_scripts_DATA += \ scripts/lyxpaperview.py \ scripts/lyxpreview2bitmap.py \ scripts/lyxpreview_tools.py \ + scripts/lyxwin_getopt.py \ scripts/lyx_batch.pl.in \ scripts/prefs2prefs.py \ scripts/prefs2prefs_lfuns.py \ diff --git a/lib/scripts/lyxpak.py b/lib/scripts/lyxpak.py index 6cdea5c53f..07091f208c 100755 --- a/lib/scripts/lyxpak.py +++ b/lib/scripts/lyxpak.py @@ -17,7 +17,6 @@ from __future__ import print_function import gzip, os, re, sys -from getopt import getopt from io import BytesIO import subprocess @@ -35,6 +34,9 @@ running_on_windows = (os.name == 'nt') if running_on_windows: from shutil import copyfile from tempfile import NamedTemporaryFile + from lyxwin_getopt import getopt +else: + from getopt import getopt # Pre-compiled regular expressions. re_lyxfile = re.compile(br"\.lyx$") @@ -128,7 +130,7 @@ def gather_files(curfile, incfiles, lyx2lyx): elif running_on_windows: # For some unknown reason, there can be a spurious '\r' in the line # separators, causing spurious empty lines when calling splitlines. - l2l_stdout = l2l_stdout.replace('\r\r\n', '\r\n') + l2l_stdout = l2l_stdout.replace(b'\r\r\n', b'\r\n') lines = l2l_stdout.splitlines() else: input = gzopen(curfile) @@ -224,7 +226,10 @@ def find_lyx2lyx(progloc, path): # for $SOMEDIR/lyx2lyx/lyx2lyx. ourpath = os.path.dirname(abspath(progloc)) (upone, discard) = os.path.split(ourpath) - tryit = os.path.join(upone, "lyx2lyx", "lyx2lyx") + if running_on_windows: + tryit = os.path.join(upone, b"lyx2lyx", b"lyx2lyx") + else: + tryit = os.path.join(upone, "lyx2lyx", "lyx2lyx") if os.access(tryit, os.X_OK): return tryit @@ -265,7 +270,10 @@ def main(args): ourprog = args[0] try: - (options, argv) = getopt(args[1:], "htzl:o:") + if running_on_windows: + (options, argv) = getopt(args[1:], b"htzl:o:") + else: + (options, argv) = getopt(args[1:], "htzl:o:") except: error(usage(ourprog)) @@ -393,7 +401,7 @@ if __name__ == "__main__": argv = [argv_unicode[i].encode('utf-8') for i in range(1, argc.value)] # Also skip option arguments to the Python interpreter. while len(argv) > 0: - if not argv[0].startswith("-"): + if not argv[0].startswith(b"-"): break argv = argv[1:] sys.argv = argv diff --git a/lib/scripts/lyxwin_getopt.py b/lib/scripts/lyxwin_getopt.py new file mode 100755 index 0000000000..a6f356a084 --- /dev/null +++ b/lib/scripts/lyxwin_getopt.py @@ -0,0 +1,217 @@ +# -*- coding: utf-8 -*- + +"""Parser for command line options. + +This module helps scripts to parse the command line arguments in +sys.argv. It supports the same conventions as the Unix getopt() +function (including the special meanings of arguments of the form `-' +and `--'). Long options similar to those supported by GNU software +may be used as well via an optional third argument. This module +provides two functions and an exception: + +getopt() -- Parse command line options +gnu_getopt() -- Like getopt(), but allow option and non-option arguments +to be intermixed. +GetoptError -- exception (class) raised with 'opt' attribute, which is the +option involved with the exception. +""" + +# Long option support added by Lars Wirzenius . +# +# Gerrit Holl moved the string-based exceptions +# to class-based exceptions. +# +# Peter Åstrand added gnu_getopt(). +# +# TODO for gnu_getopt(): +# +# - GNU getopt_long_only mechanism +# - allow the caller to specify ordering +# - RETURN_IN_ORDER option +# - GNU extension with '-' as first character of option string +# - optional arguments, specified by double colons +# - an option string with a W followed by semicolon should +# treat "-W foo" as "--foo" + +__all__ = ["GetoptError","error","getopt","gnu_getopt"] + +import os +try: + from gettext import gettext as _ +except ImportError: + # Bootstrapping Python: gettext's dependencies not built yet + def _(s): return s + +class GetoptError(Exception): + opt = '' + msg = '' + def __init__(self, msg, opt=''): + self.msg = msg + self.opt = opt + Exception.__init__(self, msg, opt) + + def __str__(self): + return self.msg + +error = GetoptError # backward compatibility + +def getopt(args, shortopts, longopts = []): + """getopt(args, options[, long_options]) -> opts, args + + Parses command line options and parameter list. args is the + argument list to be parsed, without the leading reference to the + running program. Typically, this means "sys.argv[1:]". shortopts + is the string of option letters that the script wants to + recognize, with options that require an argument followed by a + colon (i.e., the same format that Unix getopt() uses). If + specified, longopts is a list of strings with the names of the + long options which should be supported. The leading '--' + characters should not be included in the option name. Options + which require an argument should be followed by an equal sign + ('='). + + The return value consists of two elements: the first is a list of + (option, value) pairs; the second is the list of program arguments + left after the option list was stripped (this is a trailing slice + of the first argument). Each option-and-value pair returned has + the option as its first element, prefixed with a hyphen (e.g., + '-x'), and the option argument as its second element, or an empty + string if the option has no argument. The options occur in the + list in the same order in which they were found, thus allowing + multiple occurrences. Long and short options may be mixed. + + """ + + opts = [] + if type(longopts) == type(""): + longopts = [longopts] + else: + longopts = list(longopts) + while args and args[0].startswith(b'-') and args[0] != '-': + if args[0] == '--': + args = args[1:] + break + if args[0].startswith(b'--'): + opts, args = do_longs(opts, args[0][2:], longopts, args[1:]) + else: + opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:]) + + return opts, args + +def gnu_getopt(args, shortopts, longopts = []): + """getopt(args, options[, long_options]) -> opts, args + + This function works like getopt(), except that GNU style scanning + mode is used by default. This means that option and non-option + arguments may be intermixed. The getopt() function stops + processing options as soon as a non-option argument is + encountered. + + If the first character of the option string is `+', or if the + environment variable POSIXLY_CORRECT is set, then option + processing stops as soon as a non-option argument is encountered. + + """ + + opts = [] + prog_args = [] + if isinstance(longopts, str): + longopts = [longopts] + else: + longopts = list(longopts) + + # Allow options after non-option arguments? + if shortopts.startswith(b'+'): + shortopts = shortopts[1:] + all_options_first = True + elif os.environ.get("POSIXLY_CORRECT"): + all_options_first = True + else: + all_options_first = False + + while args: + if args[0] == '--': + prog_args += args[1:] + break + + if args[0][:2] == '--': + opts, args = do_longs(opts, args[0][2:], longopts, args[1:]) + elif args[0][:1] == '-' and args[0] != '-': + opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:]) + else: + if all_options_first: + prog_args += args + break + else: + prog_args.append(args[0]) + args = args[1:] + + return opts, prog_args + +def do_longs(opts, opt, longopts, args): + try: + i = opt.index('=') + except ValueError: + optarg = None + else: + opt, optarg = opt[:i], opt[i+1:] + + has_arg, opt = long_has_args(opt, longopts) + if has_arg: + if optarg is None: + if not args: + raise GetoptError(_('option --%s requires argument') % opt, opt) + optarg, args = args[0], args[1:] + elif optarg is not None: + raise GetoptError(_('option --%s must not have an argument') % opt, opt) + opts.append(('--' + opt, optarg or '')) + return opts, args + +# Return: +# has_arg? +# full option name +def long_has_args(opt, longopts): + possibilities = [o for o in longopts if o.startswith(opt)] + if not possibilities: + raise GetoptError(_('option --%s not recognized') % opt, opt) + # Is there an exact match? + if opt in possibilities: + return False, opt + elif opt + '=' in possibilities: + return True, opt + # No exact match, so better be unique. + if len(possibilities) > 1: + # XXX since possibilities contains all valid continuations, might be + # nice to work them into the error msg + raise GetoptError(_('option --%s not a unique prefix') % opt, opt) + assert len(possibilities) == 1 + unique_match = possibilities[0] + has_arg = unique_match.endswith('=') + if has_arg: + unique_match = unique_match[:-1] + return has_arg, unique_match + +def do_shorts(opts, optstring, shortopts, args): + while optstring != '': + opt, optstring = optstring[0], optstring[1:] + if short_has_arg(opt, shortopts): + if optstring == '': + if not args: + raise GetoptError(_('option -%s requires argument') % opt, + opt) + optstring, args = args[0], args[1:] + optarg, optstring = optstring, '' + else: + optarg = '' + opts.append(('-' + opt, optarg)) + return opts, args + +def short_has_arg(opt, shortopts): + for i in range(len(shortopts)): + if opt == shortopts[i] != ':': + return shortopts.startswith(b':', i+1) + raise GetoptError(_('option -%s not recognized') % opt, opt) + +if __name__ == '__main__': + import sys + print(getopt(sys.argv[1:], "a:b", ["alpha=", "beta"]))