cleanup: update references to /help/ that should now be /helptext/

I noticed this only because the WiX build was broken after
2e017696181f. I haven't tested this change with WiX, but it seems
pretty obvious by inspection this should fix it.

Differential Revision: https://phab.mercurial-scm.org/D7472

Makefile

@@ -1,258 +1,258 b''
 # If you want to change PREFIX, do not just edit it below. The changed
 # value wont get passed on to recursive make calls. You should instead
 # override the variable on the command like:
 #
 # % make PREFIX=/opt/ install
 
 export PREFIX=/usr/local
 PYTHON?=python
 $(eval HGROOT := $(shell pwd))
 HGPYTHONS ?= $(HGROOT)/build/pythons
 PURE=
 PYFILESCMD=find mercurial hgext doc -name '*.py'
 PYFILES:=$(shell $(PYFILESCMD))
-DOCFILES=mercurial/help/*.txt
+DOCFILES=mercurial/helptext/*.txt
 export LANGUAGE=C
 export LC_ALL=C
 TESTFLAGS ?= $(shell echo $$HGTESTFLAGS)
 OSXVERSIONFLAGS ?= $(shell echo $$OSXVERSIONFLAGS)
 CARGO = cargo
 
 # Set this to e.g. "mingw32" to use a non-default compiler.
 COMPILER=
 
 COMPILERFLAG_tmp_ =
 COMPILERFLAG_tmp_${COMPILER} ?= -c $(COMPILER)
 COMPILERFLAG=${COMPILERFLAG_tmp_${COMPILER}}
 
 help:
 	@echo 'Commonly used make targets:'
 	@echo '  all          - build program and documentation'
 	@echo '  install      - install program and man pages to $$PREFIX ($(PREFIX))'
 	@echo '  install-home - install with setup.py install --home=$$HOME ($(HOME))'
 	@echo '  local        - build for inplace usage'
 	@echo '  tests        - run all tests in the automatic test suite'
 	@echo '  test-foo     - run only specified tests (e.g. test-merge1.t)'
 	@echo '  dist         - run all tests and create a source tarball in dist/'
 	@echo '  clean        - remove files created by other targets'
 	@echo '                 (except installed files or dist source tarball)'
 	@echo '  update-pot   - update i18n/hg.pot'
 	@echo
 	@echo 'Example for a system-wide installation under /usr/local:'
 	@echo '  make all && su -c "make install" && hg version'
 	@echo
 	@echo 'Example for a local installation (usable in this directory):'
 	@echo '  make local && ./hg version'
 
 all: build doc
 
 local:
 	$(PYTHON) setup.py $(PURE) \
 	  build_py -c -d . \
 	  build_ext $(COMPILERFLAG) -i \
 	  build_hgexe $(COMPILERFLAG) -i \
 	  build_mo
 	env HGRCPATH= $(PYTHON) hg version
 
 build:
 	$(PYTHON) setup.py $(PURE) build $(COMPILERFLAG)
 
 wheel:
 	FORCE_SETUPTOOLS=1 $(PYTHON) setup.py $(PURE) bdist_wheel $(COMPILERFLAG)
 
 doc:
 	$(MAKE) -C doc
 
 cleanbutpackages:
 	-$(PYTHON) setup.py clean --all # ignore errors from this command
 	find contrib doc hgext hgext3rd i18n mercurial tests hgdemandimport \
 		\( -name '*.py[cdo]' -o -name '*.so' \) -exec rm -f '{}' ';'
 	rm -f MANIFEST MANIFEST.in hgext/__index__.py tests/*.err
 	rm -f mercurial/__modulepolicy__.py
 	if test -d .hg; then rm -f mercurial/__version__.py; fi
 	rm -rf build mercurial/locale
 	$(MAKE) -C doc clean
 	$(MAKE) -C contrib/chg distclean
 	rm -rf rust/target
 	rm -f mercurial/rustext.so
 
 clean: cleanbutpackages
 	rm -rf packages
 
 install: install-bin install-doc
 
 install-bin: build
 	$(PYTHON) setup.py $(PURE) install --root="$(DESTDIR)/" --prefix="$(PREFIX)" --force
 
 install-doc: doc
 	cd doc && $(MAKE) $(MFLAGS) install
 
 install-home: install-home-bin install-home-doc
 
 install-home-bin: build
 	$(PYTHON) setup.py $(PURE) install --home="$(HOME)" --prefix="" --force
 
 install-home-doc: doc
 	cd doc && $(MAKE) $(MFLAGS) PREFIX="$(HOME)" install
 
 MANIFEST-doc:
 	$(MAKE) -C doc MANIFEST
 
 MANIFEST.in: MANIFEST-doc
 	hg manifest | sed -e 's/^/include /' > MANIFEST.in
 	echo include mercurial/__version__.py >> MANIFEST.in
 	sed -e 's/^/include /' < doc/MANIFEST >> MANIFEST.in
 
 dist:	tests dist-notests
 
 dist-notests:	doc MANIFEST.in
 	TAR_OPTIONS="--owner=root --group=root --mode=u+w,go-w,a+rX-s" $(PYTHON) setup.py -q sdist
 
 check: tests
 
 tests:
         # Run Rust tests if cargo is installed
 	if command -v $(CARGO) >/dev/null 2>&1; then \
 		$(MAKE) rust-tests; \
 	fi
 	cd tests && $(PYTHON) run-tests.py $(TESTFLAGS)
 
 test-%:
 	cd tests && $(PYTHON) run-tests.py $(TESTFLAGS) $@
 
 testpy-%:
 	@echo Looking for Python $* in $(HGPYTHONS)
 	[ -e $(HGPYTHONS)/$*/bin/python ] || ( \
 	cd $$(mktemp --directory --tmpdir) && \
         $(MAKE) -f $(HGROOT)/contrib/Makefile.python PYTHONVER=$* PREFIX=$(HGPYTHONS)/$* python )
 	cd tests && $(HGPYTHONS)/$*/bin/python run-tests.py $(TESTFLAGS)
 
 rust-tests: py_feature = $(shell $(PYTHON) -c \
  'import sys; print(["python27-bin", "python3-bin"][sys.version_info[0] >= 3])')
 rust-tests:
 	cd $(HGROOT)/rust/hg-cpython \
 		&& $(CARGO) test --quiet --all \
 			--no-default-features --features "$(py_feature)"
 
 check-code:
 	hg manifest | xargs python contrib/check-code.py
 
 format-c:
 	clang-format --style file -i \
 	  `hg files 'set:(**.c or **.cc or **.h) and not "listfile:contrib/clang-format-ignorelist"'`
 
 update-pot: i18n/hg.pot
 
 i18n/hg.pot: $(PYFILES) $(DOCFILES) i18n/posplit i18n/hggettext
 	$(PYTHON) i18n/hggettext mercurial/commands.py \
 	  hgext/*.py hgext/*/__init__.py \
 	  mercurial/fileset.py mercurial/revset.py \
 	  mercurial/templatefilters.py \
 	  mercurial/templatefuncs.py \
 	  mercurial/templatekw.py \
 	  mercurial/filemerge.py \
 	  mercurial/hgweb/webcommands.py \
 	  mercurial/util.py \
 	  $(DOCFILES) > i18n/hg.pot.tmp
         # All strings marked for translation in Mercurial contain
         # ASCII characters only. But some files contain string
         # literals like this '\037\213'. xgettext thinks it has to
         # parse them even though they are not marked for translation.
         # Extracting with an explicit encoding of ISO-8859-1 will make
         # xgettext "parse" and ignore them.
 	$(PYFILESCMD) | xargs \
 	  xgettext --package-name "Mercurial" \
 	  --msgid-bugs-address "<[e-mail]>" \
 	  --copyright-holder "Matt Mackall <[e-mail]> and others" \
 	  --from-code ISO-8859-1 --join --sort-by-file --add-comments=i18n: \
 	  -d hg -p i18n -o hg.pot.tmp
 	$(PYTHON) i18n/posplit i18n/hg.pot.tmp
         # The target file is not created before the last step. So it never is in
         # an intermediate state.
 	mv -f i18n/hg.pot.tmp i18n/hg.pot
 
 %.po: i18n/hg.pot
         # work on a temporary copy for never having a half completed target
 	cp $@ $@.tmp
 	msgmerge --no-location --update $@.tmp $^
 	mv -f $@.tmp $@
 
 # Packaging targets
 
 packaging_targets := \
   centos5 \
   centos6 \
   centos7 \
   centos8 \
   deb \
   docker-centos5 \
   docker-centos6 \
   docker-centos7 \
   docker-centos8 \
   docker-debian-bullseye \
   docker-debian-buster \
   docker-debian-stretch \
   docker-fedora \
   docker-ubuntu-trusty \
   docker-ubuntu-trusty-ppa \
   docker-ubuntu-xenial \
   docker-ubuntu-xenial-ppa \
   docker-ubuntu-artful \
   docker-ubuntu-artful-ppa \
   docker-ubuntu-bionic \
   docker-ubuntu-bionic-ppa \
   fedora \
   linux-wheels \
   linux-wheels-x86_64 \
   linux-wheels-i686 \
   ppa
 
 # Forward packaging targets for convenience.
 $(packaging_targets):
 	$(MAKE) -C contrib/packaging $@
 
 osx:
 	rm -rf build/mercurial
 	/usr/bin/python2.7 setup.py install --optimize=1 \
 	  --root=build/mercurial/ --prefix=/usr/local/ \
 	  --install-lib=/Library/Python/2.7/site-packages/
 	make -C doc all install DESTDIR="$(PWD)/build/mercurial/"
         # Place a bogon .DS_Store file in the target dir so we can be
         # sure it doesn't get included in the final package.
 	touch build/mercurial/.DS_Store
         # install zsh completions - this location appears to be
         # searched by default as of macOS Sierra.
 	install -d build/mercurial/usr/local/share/zsh/site-functions/
 	install -m 0644 contrib/zsh_completion build/mercurial/usr/local/share/zsh/site-functions/_hg
         # install bash completions - there doesn't appear to be a
         # place that's searched by default for bash, so we'll follow
         # the lead of Apple's git install and just put it in a
         # location of our own.
 	install -d build/mercurial/usr/local/hg/contrib/
 	install -m 0644 contrib/bash_completion build/mercurial/usr/local/hg/contrib/hg-completion.bash
 	make -C contrib/chg \
 	  HGPATH=/usr/local/bin/hg \
 	  PYTHON=/usr/bin/python2.7 \
 	  HGEXTDIR=/Library/Python/2.7/site-packages/hgext \
 	  DESTDIR=../../build/mercurial \
 	  PREFIX=/usr/local \
 	  clean install
 	mkdir -p $${OUTPUTDIR:-dist}
 	HGVER=$$(python contrib/genosxversion.py $(OSXVERSIONFLAGS) build/mercurial/Library/Python/2.7/site-packages/mercurial/__version__.py) && \
 	OSXVER=$$(sw_vers -productVersion | cut -d. -f1,2) && \
 	pkgbuild --filter \\.DS_Store --root build/mercurial/ \
 	  --identifier org.mercurial-scm.mercurial \
 	  --version "$${HGVER}" \
 	  build/mercurial.pkg && \
 	productbuild --distribution contrib/packaging/macosx/distribution.xml \
 	  --package-path build/ \
 	  --version "$${HGVER}" \
 	  --resources contrib/packaging/macosx/ \
 	  "$${OUTPUTDIR:-dist/}"/Mercurial-"$${HGVER}"-macosx"$${OSXVER}".pkg
 
 .PHONY: help all local build doc cleanbutpackages clean install install-bin \
 	install-doc install-home install-home-bin install-home-doc \
 	dist dist-notests check tests rust-tests check-code format-c \
 	update-pot \
 	$(packaging_targets) \
 	osx

contrib/packaging/hgpackaging/py2exe.py

@@ -1,245 +1,245 b''
 # py2exe.py - Functionality for performing py2exe builds.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import subprocess
 
 from .downloads import download_entry
 from .util import (
     extract_tar_to_directory,
     extract_zip_to_directory,
     process_install_rules,
     python_exe_info,
 )
 
 
 STAGING_RULES = [
     ('contrib/bash_completion', 'Contrib/'),
     ('contrib/hgk', 'Contrib/hgk.tcl'),
     ('contrib/hgweb.fcgi', 'Contrib/'),
     ('contrib/hgweb.wsgi', 'Contrib/'),
     ('contrib/logo-droplets.svg', 'Contrib/'),
     ('contrib/mercurial.el', 'Contrib/'),
     ('contrib/mq.el', 'Contrib/'),
     ('contrib/tcsh_completion', 'Contrib/'),
     ('contrib/tcsh_completion_build.sh', 'Contrib/'),
     ('contrib/vim/*', 'Contrib/Vim/'),
     ('contrib/win32/postinstall.txt', 'ReleaseNotes.txt'),
     ('contrib/win32/ReadMe.html', 'ReadMe.html'),
     ('contrib/xml.rnc', 'Contrib/'),
     ('contrib/zsh_completion', 'Contrib/'),
     ('dist/hg.exe', './'),
     ('dist/lib/*.dll', 'lib/'),
     ('dist/lib/*.pyd', 'lib/'),
     ('dist/lib/library.zip', 'lib/'),
     ('dist/Microsoft.VC*.CRT.manifest', './'),
     ('dist/msvc*.dll', './'),
     ('dist/python*.dll', './'),
     ('doc/*.html', 'doc/'),
     ('doc/style.css', 'doc/'),
-    ('mercurial/help/**/*.txt', 'help/'),
+    ('mercurial/helptext/**/*.txt', 'helptext/'),
     ('mercurial/default.d/*.rc', 'hgrc.d/'),
     ('mercurial/locale/**/*', 'locale/'),
     ('mercurial/templates/**/*', 'Templates/'),
     ('COPYING', 'Copying.txt'),
 ]
 
 # List of paths to exclude from the staging area.
 STAGING_EXCLUDES = [
     'doc/hg-ssh.8.html',
 ]
 
 
 def build_py2exe(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     python_exe: pathlib.Path,
     build_name: str,
     venv_requirements_txt: pathlib.Path,
     extra_packages=None,
     extra_excludes=None,
     extra_dll_excludes=None,
     extra_packages_script=None,
 ):
     """Build Mercurial with py2exe.
 
     Build files will be placed in ``build_dir``.
 
     py2exe's setup.py doesn't use setuptools. It doesn't have modern logic
     for finding the Python 2.7 toolchain. So, we require the environment
     to already be configured with an active toolchain.
     """
     if 'VCINSTALLDIR' not in os.environ:
         raise Exception(
             'not running from a Visual C++ build environment; '
             'execute the "Visual C++ <version> Command Prompt" '
             'application shortcut or a vcsvarsall.bat file'
         )
 
     # Identity x86/x64 and validate the environment matches the Python
     # architecture.
     vc_x64 = r'\x64' in os.environ['LIB']
 
     py_info = python_exe_info(python_exe)
 
     if vc_x64:
         if py_info['arch'] != '64bit':
             raise Exception(
                 'architecture mismatch: Visual C++ environment '
                 'is configured for 64-bit but Python is 32-bit'
             )
     else:
         if py_info['arch'] != '32bit':
             raise Exception(
                 'architecture mismatch: Visual C++ environment '
                 'is configured for 32-bit but Python is 64-bit'
             )
 
     if py_info['py3']:
         raise Exception('Only Python 2 is currently supported')
 
     build_dir.mkdir(exist_ok=True)
 
     gettext_pkg, gettext_entry = download_entry('gettext', build_dir)
     gettext_dep_pkg = download_entry('gettext-dep', build_dir)[0]
     virtualenv_pkg, virtualenv_entry = download_entry('virtualenv', build_dir)
     py2exe_pkg, py2exe_entry = download_entry('py2exe', build_dir)
 
     venv_path = build_dir / (
         'venv-%s-%s' % (build_name, 'x64' if vc_x64 else 'x86')
     )
 
     gettext_root = build_dir / ('gettext-win-%s' % gettext_entry['version'])
 
     if not gettext_root.exists():
         extract_zip_to_directory(gettext_pkg, gettext_root)
         extract_zip_to_directory(gettext_dep_pkg, gettext_root)
 
     # This assumes Python 2. We don't need virtualenv on Python 3.
     virtualenv_src_path = build_dir / (
         'virtualenv-%s' % virtualenv_entry['version']
     )
     virtualenv_py = virtualenv_src_path / 'virtualenv.py'
 
     if not virtualenv_src_path.exists():
         extract_tar_to_directory(virtualenv_pkg, build_dir)
 
     py2exe_source_path = build_dir / ('py2exe-%s' % py2exe_entry['version'])
 
     if not py2exe_source_path.exists():
         extract_zip_to_directory(py2exe_pkg, build_dir)
 
     if not venv_path.exists():
         print('creating virtualenv with dependencies')
         subprocess.run(
             [str(python_exe), str(virtualenv_py), str(venv_path)], check=True
         )
 
     venv_python = venv_path / 'Scripts' / 'python.exe'
     venv_pip = venv_path / 'Scripts' / 'pip.exe'
 
     subprocess.run(
         [str(venv_pip), 'install', '-r', str(venv_requirements_txt)], check=True
     )
 
     # Force distutils to use VC++ settings from environment, which was
     # validated above.
     env = dict(os.environ)
     env['DISTUTILS_USE_SDK'] = '1'
     env['MSSdk'] = '1'
 
     if extra_packages_script:
         more_packages = set(
             subprocess.check_output(extra_packages_script, cwd=build_dir)
             .split(b'\0')[-1]
             .strip()
             .decode('utf-8')
             .splitlines()
         )
         if more_packages:
             if not extra_packages:
                 extra_packages = more_packages
             else:
                 extra_packages |= more_packages
 
     if extra_packages:
         env['HG_PY2EXE_EXTRA_PACKAGES'] = ' '.join(sorted(extra_packages))
         hgext3rd_extras = sorted(
             e for e in extra_packages if e.startswith('hgext3rd.')
         )
         if hgext3rd_extras:
             env['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'] = ' '.join(hgext3rd_extras)
     if extra_excludes:
         env['HG_PY2EXE_EXTRA_EXCLUDES'] = ' '.join(sorted(extra_excludes))
     if extra_dll_excludes:
         env['HG_PY2EXE_EXTRA_DLL_EXCLUDES'] = ' '.join(
             sorted(extra_dll_excludes)
         )
 
     py2exe_py_path = venv_path / 'Lib' / 'site-packages' / 'py2exe'
     if not py2exe_py_path.exists():
         print('building py2exe')
         subprocess.run(
             [str(venv_python), 'setup.py', 'install'],
             cwd=py2exe_source_path,
             env=env,
             check=True,
         )
 
     # Register location of msgfmt and other binaries.
     env['PATH'] = '%s%s%s' % (
         env['PATH'],
         os.pathsep,
         str(gettext_root / 'bin'),
     )
 
     print('building Mercurial')
     subprocess.run(
         [str(venv_python), 'setup.py', 'py2exe', 'build_doc', '--html'],
         cwd=str(source_dir),
         env=env,
         check=True,
     )
 
 
 def stage_install(
     source_dir: pathlib.Path, staging_dir: pathlib.Path, lower_case=False
 ):
     """Copy all files to be installed to a directory.
 
     This allows packaging to simply walk a directory tree to find source
     files.
     """
     if lower_case:
         rules = []
         for source, dest in STAGING_RULES:
             # Only lower directory names.
             if '/' in dest:
                 parent, leaf = dest.rsplit('/', 1)
                 dest = '%s/%s' % (parent.lower(), leaf)
             rules.append((source, dest))
     else:
         rules = STAGING_RULES
 
     process_install_rules(rules, source_dir, staging_dir)
 
     # Write out a default editor.rc file to configure notepad as the
     # default editor.
     with (staging_dir / 'hgrc.d' / 'editor.rc').open(
         'w', encoding='utf-8'
     ) as fh:
         fh.write('[ui]\neditor = notepad\n')
 
     # Purge any files we don't want to be there.
     for f in STAGING_EXCLUDES:
         p = staging_dir / f
         if p.exists():
             print('removing %s' % p)
             p.unlink()

doc/Makefile

@@ -1,48 +1,48 b''
-SOURCES=$(notdir $(wildcard ../mercurial/help/*.[0-9].txt))
+SOURCES=$(notdir $(wildcard ../mercurial/helptext/*.[0-9].txt))
 MAN=$(SOURCES:%.txt=%)
 HTML=$(SOURCES:%.txt=%.html)
 GENDOC=gendoc.py ../mercurial/commands.py ../mercurial/help.py \
-	../mercurial/help/*.txt ../hgext/*.py ../hgext/*/__init__.py
+	../mercurial/helptext/*.txt ../hgext/*.py ../hgext/*/__init__.py
 PREFIX=/usr/local
 MANDIR=$(PREFIX)/share/man
 INSTALL=install -c -m 644
 PYTHON?=python
 RSTARGS=
 
 export HGENCODING=UTF-8
 
 all: man html
 
 man: $(MAN)
 
 html: $(HTML)
 
 # This logic is duplicated in setup.py:hgbuilddoc()
 common.txt $(SOURCES) $(SOURCES:%.txt=%.gendoc.txt): $(GENDOC)
 	${PYTHON} gendoc.py "$(basename $@)" > $@.tmp
 	mv $@.tmp $@
 
 %: %.txt %.gendoc.txt common.txt
 	$(PYTHON) runrst hgmanpage $(RSTARGS) --halt warning \
 	  --strip-elements-with-class htmlonly $*.txt $*
 
 %.html: %.txt %.gendoc.txt common.txt
 	$(PYTHON) runrst html $(RSTARGS) --halt warning \
 	  --link-stylesheet --stylesheet-path style.css $*.txt $*.html
 
 MANIFEST: man html
 # tracked files are already in the main MANIFEST
 	$(RM) $@
 	for i in $(MAN) $(HTML); do \
 	  echo "doc/$$i" >> $@ ; \
 	done
 
 install: man
 	for i in $(MAN) ; do \
 	  subdir=`echo $$i | sed -n 's/^.*\.\([0-9]\)$$/man\1/p'` ; \
 	  mkdir -p "$(DESTDIR)$(MANDIR)"/$$subdir ; \
 	  $(INSTALL) $$i "$(DESTDIR)$(MANDIR)"/$$subdir ; \
 	done
 
 clean:
 	$(RM) $(MAN) $(HTML) common.txt $(SOURCES) $(SOURCES:%.txt=%.gendoc.txt) MANIFEST

mercurial/linelog.py

@@ -1,467 +1,467 b''
 # linelog - efficient cache for annotate data
 #
 # Copyright 2018 Google LLC.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """linelog is an efficient cache for annotate data inspired by SCCS Weaves.
 
 SCCS Weaves are an implementation of
 https://en.wikipedia.org/wiki/Interleaved_deltas. See
-mercurial/help/internals/linelog.txt for an exploration of SCCS weaves
+mercurial/helptext/internals/linelog.txt for an exploration of SCCS weaves
 and how linelog works in detail.
 
 Here's a hacker's summary: a linelog is a program which is executed in
 the context of a revision. Executing the program emits information
 about lines, including the revision that introduced them and the line
 number in the file at the introducing revision. When an insertion or
 deletion is performed on the file, a jump instruction is used to patch
 in a new body of annotate information.
 """
 from __future__ import absolute_import, print_function
 
 import abc
 import struct
 
 from .thirdparty import attr
 from . import pycompat
 
 _llentry = struct.Struct(b'>II')
 
 
 class LineLogError(Exception):
     """Error raised when something bad happens internally in linelog."""
 
 
 @attr.s
 class lineinfo(object):
     # Introducing revision of this line.
     rev = attr.ib()
     # Line number for this line in its introducing revision.
     linenum = attr.ib()
     # Private. Offset in the linelog program of this line. Used internally.
     _offset = attr.ib()
 
 
 @attr.s
 class annotateresult(object):
     rev = attr.ib()
     lines = attr.ib()
     _eof = attr.ib()
 
     def __iter__(self):
         return iter(self.lines)
 
 
 class _llinstruction(object):  # pytype: disable=ignored-metaclass
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def __init__(self, op1, op2):
         pass
 
     @abc.abstractmethod
     def __str__(self):
         pass
 
     def __repr__(self):
         return str(self)
 
     @abc.abstractmethod
     def __eq__(self, other):
         pass
 
     @abc.abstractmethod
     def encode(self):
         """Encode this instruction to the binary linelog format."""
 
     @abc.abstractmethod
     def execute(self, rev, pc, emit):
         """Execute this instruction.
 
         Args:
           rev: The revision we're annotating.
           pc: The current offset in the linelog program.
           emit: A function that accepts a single lineinfo object.
 
         Returns:
           The new value of pc. Returns None if exeuction should stop
           (that is, we've found the end of the file.)
         """
 
 
 class _jge(_llinstruction):
     """If the current rev is greater than or equal to op1, jump to op2."""
 
     def __init__(self, op1, op2):
         self._cmprev = op1
         self._target = op2
 
     def __str__(self):
         return 'JGE %d %d' % (self._cmprev, self._target)
 
     def __eq__(self, other):
         return (
             type(self) == type(other)
             and self._cmprev == other._cmprev
             and self._target == other._target
         )
 
     def encode(self):
         return _llentry.pack(self._cmprev << 2, self._target)
 
     def execute(self, rev, pc, emit):
         if rev >= self._cmprev:
             return self._target
         return pc + 1
 
 
 class _jump(_llinstruction):
     """Unconditional jumps are expressed as a JGE with op1 set to 0."""
 
     def __init__(self, op1, op2):
         if op1 != 0:
             raise LineLogError(b"malformed JUMP, op1 must be 0, got %d" % op1)
         self._target = op2
 
     def __str__(self):
         return 'JUMP %d' % (self._target)
 
     def __eq__(self, other):
         return type(self) == type(other) and self._target == other._target
 
     def encode(self):
         return _llentry.pack(0, self._target)
 
     def execute(self, rev, pc, emit):
         return self._target
 
 
 class _eof(_llinstruction):
     """EOF is expressed as a JGE that always jumps to 0."""
 
     def __init__(self, op1, op2):
         if op1 != 0:
             raise LineLogError(b"malformed EOF, op1 must be 0, got %d" % op1)
         if op2 != 0:
             raise LineLogError(b"malformed EOF, op2 must be 0, got %d" % op2)
 
     def __str__(self):
         return r'EOF'
 
     def __eq__(self, other):
         return type(self) == type(other)
 
     def encode(self):
         return _llentry.pack(0, 0)
 
     def execute(self, rev, pc, emit):
         return None
 
 
 class _jl(_llinstruction):
     """If the current rev is less than op1, jump to op2."""
 
     def __init__(self, op1, op2):
         self._cmprev = op1
         self._target = op2
 
     def __str__(self):
         return 'JL %d %d' % (self._cmprev, self._target)
 
     def __eq__(self, other):
         return (
             type(self) == type(other)
             and self._cmprev == other._cmprev
             and self._target == other._target
         )
 
     def encode(self):
         return _llentry.pack(1 | (self._cmprev << 2), self._target)
 
     def execute(self, rev, pc, emit):
         if rev < self._cmprev:
             return self._target
         return pc + 1
 
 
 class _line(_llinstruction):
     """Emit a line."""
 
     def __init__(self, op1, op2):
         # This line was introduced by this revision number.
         self._rev = op1
         # This line had the specified line number in the introducing revision.
         self._origlineno = op2
 
     def __str__(self):
         return 'LINE %d %d' % (self._rev, self._origlineno)
 
     def __eq__(self, other):
         return (
             type(self) == type(other)
             and self._rev == other._rev
             and self._origlineno == other._origlineno
         )
 
     def encode(self):
         return _llentry.pack(2 | (self._rev << 2), self._origlineno)
 
     def execute(self, rev, pc, emit):
         emit(lineinfo(self._rev, self._origlineno, pc))
         return pc + 1
 
 
 def _decodeone(data, offset):
     """Decode a single linelog instruction from an offset in a buffer."""
     try:
         op1, op2 = _llentry.unpack_from(data, offset)
     except struct.error as e:
         raise LineLogError(b'reading an instruction failed: %r' % e)
     opcode = op1 & 0b11
     op1 = op1 >> 2
     if opcode == 0:
         if op1 == 0:
             if op2 == 0:
                 return _eof(op1, op2)
             return _jump(op1, op2)
         return _jge(op1, op2)
     elif opcode == 1:
         return _jl(op1, op2)
     elif opcode == 2:
         return _line(op1, op2)
     raise NotImplementedError(b'Unimplemented opcode %r' % opcode)
 
 
 class linelog(object):
     """Efficient cache for per-line history information."""
 
     def __init__(self, program=None, maxrev=0):
         if program is None:
             # We pad the program with an extra leading EOF so that our
             # offsets will match the C code exactly. This means we can
             # interoperate with the C code.
             program = [_eof(0, 0), _eof(0, 0)]
         self._program = program
         self._lastannotate = None
         self._maxrev = maxrev
 
     def __eq__(self, other):
         return (
             type(self) == type(other)
             and self._program == other._program
             and self._maxrev == other._maxrev
         )
 
     def __repr__(self):
         return b'<linelog at %s: maxrev=%d size=%d>' % (
             hex(id(self)),
             self._maxrev,
             len(self._program),
         )
 
     def debugstr(self):
         fmt = '%%%dd %%s' % len(str(len(self._program)))
         return pycompat.sysstr(b'\n').join(
             fmt % (idx, i) for idx, i in enumerate(self._program[1:], 1)
         )
 
     @classmethod
     def fromdata(cls, buf):
         if len(buf) % _llentry.size != 0:
             raise LineLogError(
                 b"invalid linelog buffer size %d (must be a multiple of %d)"
                 % (len(buf), _llentry.size)
             )
         expected = len(buf) / _llentry.size
         fakejge = _decodeone(buf, 0)
         if isinstance(fakejge, _jump):
             maxrev = 0
         elif isinstance(fakejge, (_jge, _jl)):
             maxrev = fakejge._cmprev
         else:
             raise LineLogError(
                 'Expected one of _jump, _jge, or _jl. Got %s.'
                 % type(fakejge).__name__
             )
         assert isinstance(fakejge, (_jump, _jge, _jl))  # help pytype
         numentries = fakejge._target
         if expected != numentries:
             raise LineLogError(
                 b"corrupt linelog data: claimed"
                 b" %d entries but given data for %d entries"
                 % (expected, numentries)
             )
         instructions = [_eof(0, 0)]
         for offset in pycompat.xrange(1, numentries):
             instructions.append(_decodeone(buf, offset * _llentry.size))
         return cls(instructions, maxrev=maxrev)
 
     def encode(self):
         hdr = _jge(self._maxrev, len(self._program)).encode()
         return hdr + b''.join(i.encode() for i in self._program[1:])
 
     def clear(self):
         self._program = []
         self._maxrev = 0
         self._lastannotate = None
 
     def replacelines_vec(self, rev, a1, a2, blines):
         return self.replacelines(
             rev, a1, a2, 0, len(blines), _internal_blines=blines
         )
 
     def replacelines(self, rev, a1, a2, b1, b2, _internal_blines=None):
         """Replace lines [a1, a2) with lines [b1, b2)."""
         if self._lastannotate:
             # TODO(augie): make replacelines() accept a revision at
             # which we're editing as well as a revision to mark
             # responsible for the edits. In hg-experimental it's
             # stateful like this, so we're doing the same thing to
             # retain compatibility with absorb until that's imported.
             ar = self._lastannotate
         else:
             ar = self.annotate(rev)
             #        ar = self.annotate(self._maxrev)
         if a1 > len(ar.lines):
             raise LineLogError(
                 b'%d contains %d lines, tried to access line %d'
                 % (rev, len(ar.lines), a1)
             )
         elif a1 == len(ar.lines):
             # Simulated EOF instruction since we're at EOF, which
             # doesn't have a "real" line.
             a1inst = _eof(0, 0)
             a1info = lineinfo(0, 0, ar._eof)
         else:
             a1info = ar.lines[a1]
             a1inst = self._program[a1info._offset]
         programlen = self._program.__len__
         oldproglen = programlen()
         appendinst = self._program.append
 
         # insert
         blineinfos = []
         bappend = blineinfos.append
         if b1 < b2:
             # Determine the jump target for the JGE at the start of
             # the new block.
             tgt = oldproglen + (b2 - b1 + 1)
             # Jump to skip the insert if we're at an older revision.
             appendinst(_jl(rev, tgt))
             for linenum in pycompat.xrange(b1, b2):
                 if _internal_blines is None:
                     bappend(lineinfo(rev, linenum, programlen()))
                     appendinst(_line(rev, linenum))
                 else:
                     newrev, newlinenum = _internal_blines[linenum]
                     bappend(lineinfo(newrev, newlinenum, programlen()))
                     appendinst(_line(newrev, newlinenum))
         # delete
         if a1 < a2:
             if a2 > len(ar.lines):
                 raise LineLogError(
                     b'%d contains %d lines, tried to access line %d'
                     % (rev, len(ar.lines), a2)
                 )
             elif a2 == len(ar.lines):
                 endaddr = ar._eof
             else:
                 endaddr = ar.lines[a2]._offset
             if a2 > 0 and rev < self._maxrev:
                 # If we're here, we're deleting a chunk of an old
                 # commit, so we need to be careful and not touch
                 # invisible lines between a2-1 and a2 (IOW, lines that
                 # are added later).
                 endaddr = ar.lines[a2 - 1]._offset + 1
             appendinst(_jge(rev, endaddr))
         # copy instruction from a1
         a1instpc = programlen()
         appendinst(a1inst)
         # if a1inst isn't a jump or EOF, then we need to add an unconditional
         # jump back into the program here.
         if not isinstance(a1inst, (_jump, _eof)):
             appendinst(_jump(0, a1info._offset + 1))
         # Patch instruction at a1, which makes our patch live.
         self._program[a1info._offset] = _jump(0, oldproglen)
 
         # Update self._lastannotate in place. This serves as a cache to avoid
         # expensive "self.annotate" in this function, when "replacelines" is
         # used continuously.
         if len(self._lastannotate.lines) > a1:
             self._lastannotate.lines[a1]._offset = a1instpc
         else:
             assert isinstance(a1inst, _eof)
             self._lastannotate._eof = a1instpc
         self._lastannotate.lines[a1:a2] = blineinfos
         self._lastannotate.rev = max(self._lastannotate.rev, rev)
 
         if rev > self._maxrev:
             self._maxrev = rev
 
     def annotate(self, rev):
         pc = 1
         lines = []
         executed = 0
         # Sanity check: if instructions executed exceeds len(program), we
         # hit an infinite loop in the linelog program somehow and we
         # should stop.
         while pc is not None and executed < len(self._program):
             inst = self._program[pc]
             lastpc = pc
             pc = inst.execute(rev, pc, lines.append)
             executed += 1
         if pc is not None:
             raise LineLogError(
                 r'Probably hit an infinite loop in linelog. Program:\n'
                 + self.debugstr()
             )
         ar = annotateresult(rev, lines, lastpc)
         self._lastannotate = ar
         return ar
 
     @property
     def maxrev(self):
         return self._maxrev
 
     # Stateful methods which depend on the value of the last
     # annotation run. This API is for compatiblity with the original
     # linelog, and we should probably consider refactoring it.
     @property
     def annotateresult(self):
         """Return the last annotation result. C linelog code exposed this."""
         return [(l.rev, l.linenum) for l in self._lastannotate.lines]
 
     def getoffset(self, line):
         return self._lastannotate.lines[line]._offset
 
     def getalllines(self, start=0, end=0):
         """Get all lines that ever occurred in [start, end).
 
         Passing start == end == 0 means "all lines ever".
 
         This works in terms of *internal* program offsets, not line numbers.
         """
         pc = start or 1
         lines = []
         # only take as many steps as there are instructions in the
         # program - if we don't find an EOF or our stop-line before
         # then, something is badly broken.
         for step in pycompat.xrange(len(self._program)):
             inst = self._program[pc]
             nextpc = pc + 1
             if isinstance(inst, _jump):
                 nextpc = inst._target
             elif isinstance(inst, _eof):
                 return lines
             elif isinstance(inst, (_jl, _jge)):
                 pass
             elif isinstance(inst, _line):
                 lines.append((inst._rev, inst._origlineno))
             else:
                 raise LineLogError(b"Illegal instruction %r" % inst)
             if nextpc == end:
                 return lines
             pc = nextpc
         raise LineLogError(b"Failed to perform getalllines")