diff --git a/lisp/versions b/lisp/versions index 3ef4391a..c6a6e2ec 100644 --- a/lisp/versions +++ b/lisp/versions @@ -68,6 +68,7 @@ | org-cliplink | [[https://melpa.org/#/org-cliplink][melpa]] | 0.2 | 20201126.1020 | | 20190608.2134 | | | org-drill | [[https://melpa.org/#/org-drill][melpa]] | 2.7.0 | 20210427.2003 | 2.7.0 | 20200412.1812 | (alternatives anki-mode, anki-editor) | | org-fancy-priorities.el | [[https://melpa.org/#/org-fancy-priorities][melpa]] | 1.1 | 20210830.1657 | 1.1 | 20180328.2331 | | +| org-fragtog | [[https://github.com/io12/org-fragtog][melpa]] | 0.4.0 | 20220106.758 | | | | | org-ref | [[https://melpa.org/#/org-ref][mepla]] | 3.0 | 20220101.1941 | 1.1.1 | 20210108.1415 | uses ivy key-chord | | org-sticky-header.el | [[https://melpa.org/#/org-sticky-header][melpa]] | 1.1 | 20201223.143 | 1.1-pre | 20191117.549 | instead of org-bullets.el (last version used 20200317.1740) | | org-superstar.el | [[https://melpa.org/#/org-superstar][melpa]] | 1.5.1 | 20210915.1934 | 1.4.0 | 20200818.2257 | | @@ -107,6 +108,7 @@ | use-package | [[https://melpa.org/#/use-package][melpa]] | 2.4.1 | 20210207.1926 | 2.4.1 | 20210106.2145 | | | virtual-auto-fill | [[https://melpa.org/#/virtual-auto-fill][melpa]] | 0.1 | 20200906.2038 | 0.1 | 20200217.2333 | requires visual-line-mode (builtin) adaptive-wrap visual-fill-column | | visual-fill-column | [[https://melpa.org/#/visual-fill-column][melpa]] | 2.4 | 20211118.33 | 2.2 | 20201229.2303 | best with visual-line-mode, required by virtual-auto-fill | +| vterm | [[https://melpa.org/#/vterm][melpa]] | 0.0.1 | 20211226.817 | | | | | web-completion-data | [[https://melpa.org/#/web-completion-data][melpa]] | 0.2 | 20160318.848 | | | required by company-web | | web-mode.el | [[https://melpa.org/#/web-mode][melpa]] | 17.0.4 | 20220104.1504 | 17.0.4 | 20201227.1048 | | | which-key.el | [[https://melpa.org/#/which-key][melpa]] | 3.5.1 | 20220102.1433 | 3.5.0 | 20201216.1720 | | diff --git a/lisp/vterm/.gitmodules b/lisp/vterm/.gitmodules new file mode 100644 index 00000000..e69de29b diff --git a/lisp/vterm/CMakeLists.txt b/lisp/vterm/CMakeLists.txt new file mode 100644 index 00000000..e766884d --- /dev/null +++ b/lisp/vterm/CMakeLists.txt @@ -0,0 +1,95 @@ +cmake_minimum_required(VERSION 3.11) +include(ExternalProject) + +project(emacs-libvterm C) + +if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR CMAKE_SYSTEM_NAME STREQUAL "NetBSD") + set(LIBVTERM_BUILD_COMMAND "gmake") +else() + set(LIBVTERM_BUILD_COMMAND "make") +endif() + +add_library(vterm-module MODULE vterm-module.c utf8.c elisp.c) +set_target_properties(vterm-module PROPERTIES + C_STANDARD 99 + C_VISIBILITY_PRESET "hidden" + POSITION_INDEPENDENT_CODE ON + PREFIX "" + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR} + ) + +# Set RelWithDebInfo as default build type +if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + message(STATUS "No build type selected, defaulting to RelWithDebInfo") + set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Build type (default RelWithDebInfo)" FORCE) +endif() + +# Look for the header file. +option(USE_SYSTEM_LIBVTERM "Use system libvterm instead of the vendored version." ON) + +# Try to find the libvterm in system. +if (USE_SYSTEM_LIBVTERM) + # try to find the vterm.h header file. + find_path(LIBVTERM_INCLUDE_DIR + NAMES vterm.h + ) + + # vterm.h is found. + if (LIBVTERM_INCLUDE_DIR) + message(STATUS "System libvterm detected") + execute_process(COMMAND grep -c "VTermStringFragment" "${LIBVTERM_INCLUDE_DIR}/vterm.h" OUTPUT_VARIABLE VTermStringFragmentExists) + if (${VTermStringFragmentExists} EQUAL "0") +# add_compile_definitions(VTermStringFragmentNotExists) + add_definitions(-DVTermStringFragmentNotExists) + endif() + else() + message(STATUS "System libvterm not found: libvterm will be downloaded and compiled as part of the build process") + endif() +endif() + +if (LIBVTERM_INCLUDE_DIR) + find_library(LIBVTERM_LIBRARY NAMES + vterm + libvterm + ) + + if(NOT LIBVTERM_LIBRARY) + message(FATAL_ERROR "libvterm not found") + endif() +else() + find_program(LIBTOOL NAMES libtool glibtool) + if(NOT LIBTOOL) + message(FATAL_ERROR "libtool not found. Please install libtool") + endif() + + ExternalProject_add(libvterm + GIT_REPOSITORY https://github.com/neovim/libvterm.git + GIT_TAG 54c03b21f763fa775a4c0643a9d8326342873179 + CONFIGURE_COMMAND "" + BUILD_COMMAND ${LIBVTERM_BUILD_COMMAND} "CFLAGS='-fPIC'" + BUILD_IN_SOURCE ON + INSTALL_COMMAND "") + + ExternalProject_Get_property(libvterm SOURCE_DIR) + + set(LIBVTERM_INCLUDE_DIR ${SOURCE_DIR}/include) + set(LIBVTERM_LIBRARY ${SOURCE_DIR}/.libs/libvterm.a) + + add_dependencies(vterm-module libvterm) + + # Workaround for https://gitlab.kitware.com/cmake/cmake/issues/15052 + file(MAKE_DIRECTORY ${LIBVTERM_INCLUDE_DIR}) +endif() + +add_library(vterm STATIC IMPORTED) +set_target_properties(vterm PROPERTIES IMPORTED_LOCATION ${LIBVTERM_LIBRARY}) +target_include_directories(vterm INTERFACE ${LIBVTERM_INCLUDE_DIR}) + +# Link with libvterm +target_link_libraries(vterm-module PUBLIC vterm) + +# Custom run command for testing +add_custom_target(run + COMMAND emacs -Q -L ${CMAKE_SOURCE_DIR} -L ${CMAKE_BINARY_DIR} --eval "\\(require \\'vterm\\)" --eval "\\(vterm\\)" + DEPENDS vterm-module + ) diff --git a/lisp/vterm/LICENSE b/lisp/vterm/LICENSE new file mode 100644 index 00000000..94a9ed02 --- /dev/null +++ b/lisp/vterm/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/lisp/vterm/README.md b/lisp/vterm/README.md new file mode 100644 index 00000000..10093b12 --- /dev/null +++ b/lisp/vterm/README.md @@ -0,0 +1,854 @@ +[![MELPA](https://melpa.org/packages/vterm-badge.svg)](https://melpa.org/#/vterm) + +# Introduction + +Emacs-libvterm (_vterm_) is fully-fledged terminal emulator inside GNU Emacs +based on [libvterm](https://github.com/neovim/libvterm), a C library. As a +result of using compiled code (instead of elisp), emacs-libvterm is fully +capable, fast, and it can seamlessly handle large outputs. + +## Warning + +This package is in active development and, while being stable enough to be used +as a daily-driver, it is currently in **alpha** stage. This means that +occasionally the public interface will change (for example names of options or +functions). A list of recent breaking changes is in +[appendix](#breaking-changes). Moreover, emacs-libvterm deals directly with some +low-level operations, hence, bugs can lead to segmentation faults and crashes. +If that happens, please [report the +problem](https://github.com/akermu/emacs-libvterm/issues/new). + +## Given that eshell, shell, and (ansi-)term are Emacs built-in, why should I use vterm? + +The short answer is: unparalleled performance and compatibility with standard +command-line tools. + +For the long answer, let us discuss the differences between `eshell`, `shell`, +`term` and `vterm`: +- `eshell`: it is a shell completely implemented in Emacs Lisp. It is + well-integrated in Emacs and it runs on Windows. It does not support command line + tools that require terminal manipulation capabilities (e.g., `ncdu`, `nmtui`, + ...). +- `shell`: it interfaces with a standard shell (e.g., `bash`). It reads an input + from Emacs, sends it to the shell, and reports back the output from the shell. + As such, like `eshell`, it does not support interactive commands, especially + those that directly handle how the output should be displayed (e.g., `htop`). +- `term`: it is a terminal emulator written in elisp. `term` runs a shell + (similarly to other terminal emulators like Gnome Terminal) and programs can + directly manipulate the output using escape codes. Hence, many interactive + applications (like the one aforementioned) work with `term`. However, `term` + and `ansi-term` do not implement all the escapes codes needed, so some + programs do not work properly. Moreover, `term` has inferior performance + compared to standalone terminals, especially with large bursts of output. +- `vterm`: like `term` it is a terminal emulator. Unlike `term`, the core of + `vterm` is an external library written in C, `libvterm`. For this reason, + `vterm` outperforms `term` and has a nearly universal compatibility with + terminal applications. + +Vterm is not for you if you are using Windows, or if you cannot set up Emacs +with support for modules. Otherwise, you should try vterm, as it provides a +superior terminal experience in Emacs. + +Using `vterm` is like using Gnome Terminal inside Emacs: Vterm is fully-featured +and fast, but is not as well integrated in Emacs as `eshell` (yet), so some of +the editing keybinding you are used to using may not work. For example, +`evil-mode` is currently not supported (though, users can enable VI emulation in +their shells). This is because keys are sent directly to the shell. We are +constantly working to improve this. + +# Installation + +## Requirements + +Before installing emacs-libvterm, you need to make sure you have installed + 1. GNU Emacs (>= 25.1) with [module + support](https://www.gnu.org/software/emacs/manual/html_node/elisp/Dynamic-Modules.html). + You can check that, by verifying that `module-file-suffix` is not `nil`. + 2. cmake (>= 3.11) + 3. libtool-bin (related issues: + [#66](https://github.com/akermu/emacs-libvterm/issues/66) + [#85](https://github.com/akermu/emacs-libvterm/issues/85#issuecomment-491845136)) + 4. OPTIONAL: [libvterm](https://github.com/neovim/libvterm) (>= 0.1). This + library can be found in the official repositories of most distributions + (e.g., Arch, Debian, Fedora, Gentoo, openSUSE, Ubuntu). Typical names are + `libvterm` (Arch, Fedora, Gentoo, openSUSE), or `libvterm-dev` (Debian, + Ubuntu). If not available, `libvterm` will be downloaded during the + compilation process. Some distributions (e.g. Ubuntu < 20.04, Debian < 11) + have versions of `libvterm` that are too old. If you find compilation errors + related to `VTERM_COLOR`, you should not use your system libvterm. See + [FAQ](#frequently-asked-questions-and-problems) for more details. + +## From MELPA + +`vterm` is available on [MELPA](https://melpa.org/), and it can be installed as +a normal package. If the requirements are satisfied (mainly, Emacs was built +with support for modules), `vterm` will compile the module the first time it is +run. This is the recommended way to install `vterm`. + +`vterm` can be install from MELPA with `use-package` by adding the following +lines to your `init.el`: + +```elisp +(use-package vterm + :ensure t) +``` + +To take full advantage of the capabilities of `vterm`, you should configure your +shell too. Read about this in the section [shell-side +configuration](#shell-side-configuration). + +## Manual installation + +Clone the repository: + +```sh +git clone https://github.com/akermu/emacs-libvterm.git +``` + +By default, vterm will try to find if libvterm is installed. If it is not found, +emacs-libvterm will download the latest version available of libvterm (from +[here](https://github.com/neovim/libvterm)), compile it, and use it. If you +always want to use the vendored version as opposed to the one on you system, set +`USE_SYSTEM_LIBVTERM` to `no`. To do this, change `cmake ..` with `cmake +-DUSE_SYSTEM_LIBVTERM=no ..` in the following instructions. + +Build the module with: + +``` sh +cd emacs-libvterm +mkdir -p build +cd build +cmake .. +make +``` + +And add this to your `init.el`: + +``` elisp +(add-to-list 'load-path "path/to/emacs-libvterm") +(require 'vterm) +``` + +Or, with `use-package`: + +```elisp +(use-package vterm + :load-path "path/to/emacs-libvterm/") +``` + +## vterm and Ubuntu +### 20.04 +Using `vterm` on Ubuntu requires additional steps. The latest LTS version +(20.04) ships without CMake installed and Emacs27 is not yet available from Ubuntu's package repository. + +The basic steps for getting vterm to work on Ubuntu 20.04 are: +* Ensure Emacs27 is installed +* Install cmake, libtool, and libtool-bin + +There are a few options for installing Emacs27 on Ubuntu 20.04: +* Compile Emacs27 from source +* Install Emacs27 from Snap +* Install Emacs27 from Kevin Kelley's PPA + +In any case, if you have an older Emacs version you will need to purge it before proceeding: + +#### Purge Emacs +```sh +sudo apt --purge remove emacs +sudo apt autoremove +``` + +#### Installing Emacs27 from Kevin Kelley PPA +```sh +sudo add-apt-repository ppa:kelleyk/emacs +sudo apt install emacs27 +``` + +##### If you get an error about emacs27_common during the install process: +```sh +Errors were encountered while processing: + /tmp/apt-dpkg-install-RVK8CA/064-emacs27-common_27.1~1.git86d8d76aa3-kk2+20.04_all.deb +``` +run +```sh +sudo apt --purge remove emacs-common +sudo apt --fix-broken install +``` + +#### Installing Emacs27 from Snap +I hesitate to include SNAP here, because I ran into a number of GTK Theme parsing errors, and Fontconfig errors when I tested it, and reverted to installing from Kevin Kelley's PPA. YMMV +```sh +sudo snap install emacs --classic +``` + +#### Install CMake and Libtool +In Ubuntu 20.04 CMake (v3.16.3-1ubuntu1) and Libtool can be installed with +```sh +sudo apt install cmake +sudo apt install libtool +sudo apt install libtool-bin +``` + +### 18.04 + +Using `vterm` on Ubuntu 18.04 requires additional steps. +18.04 ships with a version of CMake that is too old for `vterm` and GNU +Emacs is not compiled with support for dynamical module loading. + +It is possible to install GNU Emacs with module support from Kevin Kelley's PPA. +The binary in Ubuntu Emacs Lisp PPA is currently broken and leads to segmentation faults +(see [#185](https://github.com/akermu/emacs-libvterm/issues/185#issuecomment-562237077)). +In case Emacs is already on the system, you need to purge it before proceeding +with the following commands. +```sh +sudo add-apt-repository ppa:kelleyk/emacs +sudo apt update +sudo apt-get install emacs26 +``` + +A way to install a recent version of CMake (>= 3.11) is with linuxbrew. +```sh +brew install cmake +``` + + +In some cases, `/bin/sh` needs to be relinked to `/bin/bash` for the compilation +to work (see, +[#216](https://github.com/akermu/emacs-libvterm/issues/216#issuecomment-575934593)). + +Pull requests to improve support for Ubuntu are welcome (e.g., simplifying the +installation). + +Some releases of Ubuntu (e.g., 18.04) ship with a old version of libvterm that +can lead to compilation errors. If you have this problem, see the +[FAQ](#frequently-asked-questions-and-problems) for a solution. + +## GNU Guix + +`vterm` and its dependencies are available in GNU Guix as +[emacs-vterm](https://guix.gnu.org/packages/emacs-vterm-0-1.7d7381f/). +The package can be installed with `guix package -i emacs-vterm`. + +## Shell-side configuration + +Some of the most useful features in `vterm` (e.g., [directory-tracking and +prompt-tracking](#directory-tracking-and-prompt-tracking) or [message +passing](#message-passing)) require shell-side configurations. The main goal of +these additional functions is to enable the shell to send information to `vterm` +via properly escaped sequences. A function that helps in this task, +`vterm_printf`, is defined below. This function is widely used throughout this +readme. + +For `bash` or `zsh`, put this in your `.zshrc` or `.bashrc` +```bash +vterm_printf(){ + if [ -n "$TMUX" ] && ([ "${TERM%%-*}" = "tmux" ] || [ "${TERM%%-*}" = "screen" ] ); then + # Tell tmux to pass the escape sequences through + printf "\ePtmux;\e\e]%s\007\e\\" "$1" + elif [ "${TERM%%-*}" = "screen" ]; then + # GNU screen (screen, screen-256color, screen-256color-bce) + printf "\eP\e]%s\007\e\\" "$1" + else + printf "\e]%s\e\\" "$1" + fi +} +``` +This works also for `dash`. + +For `fish` put this in your `~/.config/fish/config.fish`: +```bash +function vterm_printf; + if begin; [ -n "$TMUX" ] ; and string match -q -r "screen|tmux" "$TERM"; end + # tell tmux to pass the escape sequences through + printf "\ePtmux;\e\e]%s\007\e\\" "$argv" + else if string match -q -- "screen*" "$TERM" + # GNU screen (screen, screen-256color, screen-256color-bce) + printf "\eP\e]%s\007\e\\" "$argv" + else + printf "\e]%s\e\\" "$argv" + end +end +``` + +# Debugging and testing + +If you have successfully built the module, you can test it by executing the +following command in the `build` directory: + +```sh +make run +``` + +# Usage + +## `vterm` + +Open a terminal in the current window. + +## `vterm-other-window` + +Open a terminal in another window. + +## `vterm-copy-mode` + +When you enable `vterm-copy-mode`, the terminal buffer behaves like a normal +`read-only` text buffer: you can search, copy text, etc. The default keybinding +to toggle `vterm-copy-mode` is `C-c C-t`. When a region is selected, it is +possible to copy the text and leave `vterm-copy-mode` with the enter key. + +If no region is selected when the enter key is pressed it will copy the current +line from start to end. If `vterm-copy-exclude-prompt` is true it will skip +the prompt and not include it in the copy. + +## `vterm-clear-scrollback` + +`vterm-clear-scrollback` does exactly what the name suggests: it clears the +current buffer from the data that it is not currently visible. +`vterm-clear-scrollback` is bound to `C-c C-l`. This function is typically used +with the `clear` function provided by the shell to clear both screen and +scrollback. In order to achieve this behavior, you need to add a new shell alias. + +For `zsh`, put this in your `.zshrc`: +```zsh + +if [[ "$INSIDE_EMACS" = 'vterm' ]]; then + alias clear='vterm_printf "51;Evterm-clear-scrollback";tput clear' +fi +``` +For `bash`, put this in your `.bashrc`: +```bash +if [[ "$INSIDE_EMACS" = 'vterm' ]]; then + function clear(){ + vterm_printf "51;Evterm-clear-scrollback"; + tput clear; + } +fi +``` +For `fish`: +``` +if [ "$INSIDE_EMACS" = 'vterm' ] + function clear + vterm_printf "51;Evterm-clear-scrollback"; + tput clear; + end +end +``` +These aliases take advantage of the fact that `vterm` can execute `elisp` +commands, as explained below. + +If it possible to automatically clear the scrollback when the screen is cleared +by setting the variable `vterm-clear-scrollback-when-clearing`: When +`vterm-clear-scrollback-when-clearing` is non nil, `C-l` clears both the screen +and the scrollback. When is nil, `C-l` only clears the screen. The opposite +behavior can be achieved by using the universal prefix (i.e., calling `C-u C-l`). + +# Customization + +## `vterm-shell` + +Shell to run in a new vterm. It defaults to `$SHELL`. + +## `vterm-environment` + +to add more environment variables there is the custom vterm-environment which has +a similar format than the internal Emacs variable process-environment. +You can check the documentation with C-h v process-environment for more details. + +## `vterm-term-environment-variable` + +Value for the `TERM` environment variable. It defaults to `xterm-256color`. If +[eterm-256color](https://github.com/dieggsy/eterm-256color) is installed, +setting `vterm-term-environment-variable` to `eterm-color` improves the +rendering of colors in some systems. + +## `vterm-kill-buffer-on-exit` + +If set to `t`, buffers are killed when the associated process is terminated (for +example, by logging out the shell). Keeping buffers around it is useful if you +need to copy or manipulate the content. + +## `vterm-module-cmake-args` + +Compilation flags and arguments to be given to CMake when compiling the module. +This string is directly passed to CMake, so it uses the same syntax. At the +moment, it main use is for compiling vterm using the system libvterm instead of +the one downloaded from GitHub. You can find all the arguments and flags +available with `cmake -LA` in the build directory. + +## `vterm-copy-exclude-prompt` + +Controls whether or not to exclude the prompt when copying a line in +`vterm-copy-mode`. Using the universal prefix before calling +`vterm-copy-mode-done` will invert the value for that call, allowing you to +temporarily override the setting. When a prompt is not found, the whole line is +copied. + +## `vterm-use-vterm-prompt-detection-method` + +The variable `vterm-use-vterm-prompt-detection-method` determines whether to use +the vterm prompt tracking, if false it use the regexp in +`vterm-copy-prompt-regexp` to search for the prompt. + +## `vterm-enable-manipulate-selection-data-by-osc52` + +Vterm support copy text to Emacs kill ring and system clipboard by using OSC 52. +See https://invisible-island.net/xterm/ctlseqs/ctlseqs.html for more info about OSC 52. +For example: send 'blabla' to kill ring: printf "\033]52;c;$(printf "%s" "blabla" | base64)\a" + +tmux can share its copy buffer to terminals by supporting osc52(like iterm2 xterm), +you can enable this feature for tmux by : +set -g set-clipboard on #osc 52 copy paste share with iterm +set -ga terminal-overrides ',xterm*:XT:Ms=\E]52;%p1%s;%p2%s\007' +set -ga terminal-overrides ',screen*:XT:Ms=\E]52;%p1%s;%p2%s\007' + +The clipboard querying/clearing functionality offered by OSC 52 is not implemented here, +And for security reason, this feature is disabled by default." + +This feature need the new way of handling strings with a struct `VTermStringFragment` +in libvterm. You'd better compile emacs-libvterm with `cmake -DUSE_SYSTEM_LIBVTERM=no ..`. +If you don't do that, when the content you want to copied is too long, it would be truncated +by bug of libvterm. + +## `vterm-buffer-name-string` + +When `vterm-buffer-name-string` is not nil, vterm renames automatically its own +buffers with `vterm-buffer-name-string`. This string can contain the character +`%s`, which is substituted with the _title_ (as defined by the shell, see +below). A possible value for `vterm-buffer-name-string` is `vterm %s`, according +to which all the vterm buffers will be named "vterm TITLE". + +This requires some shell-side configuration to print the title. For example to +set the name "HOSTNAME:PWD", use can you the following: + +For `zsh` +```zsh +autoload -U add-zsh-hook +add-zsh-hook -Uz chpwd (){ print -Pn "\e]2;%m:%2~\a" } +``` +For `bash`, +```bash +PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND; }"'echo -ne "\033]0;${HOSTNAME}:${PWD}\007"' +``` +For `fish`, +```fish +function fish_title + hostname + echo ":" + pwd +end +``` +See [zsh and bash](http://tldp.org/HOWTO/Xterm-Title-4.html) and [fish +documentations](https://fishshell.com/docs/current/#programmable-title). + +## `vterm-always-compile-module` + +Vterm needs `vterm-module` to work. This can be compiled externally, or `vterm` +will ask the user whether to build the module when `vterm` is first called. To +avoid this question and always compile the module, set +`vterm-always-compile-module` to `t`. + +## Keybindings + +If you want a key to be sent to the terminal, bind it to `vterm--self-insert`, +or remove it from `vterm-mode-map`. By default, `vterm.el` binds most of the +`C-` and `M-` keys, `` through `` and some special keys +like `` and ``. Sending a keyboard interrupt is bound to `C-c +C-c`. + +## Fonts + +You can change the font (the _face_) used in a vterm with the following code: + +``` emacs +(add-hook 'vterm-mode-hook + (lambda () + (set (make-local-variable 'buffer-face-mode-face) 'fixed-pitch) + (buffer-face-mode t))) +``` + +Where instead of `'fixed-pitch` you specify the face you want to use. The +example reported here can be used to force vterm to use a mono-spaced font (the +`fixed-pitch` face). This is useful when your default font in Emacs is a +proportional font. + +In addition to that, you can disable some text properties (bold, underline, +reverse video) setting the relative option to `t` (`vterm-disable-bold`, +`vterm-disable-underline`, or `vterm-disable-inverse-video`). + +## Blink cursor + +When `vterm-ignore-blink-cursor` is `t`, vterm will ignore request from application to turn on or off cursor blink. + +If `nil`, cursor in any window may begin to blink or not blink because `blink-cursor-mode` +is a global minor mode in Emacs, you can use `M-x blink-cursor-mode` to toggle. + +## Colors + +Set the `:foreground` and `:background` attributes of the following faces to a +color you like. The `:foreground` is ansi color 0-7, the `:background` attribute +is ansi color 8-15. + +- vterm-color-black +- vterm-color-red +- vterm-color-green +- vterm-color-yellow +- vterm-color-blue +- vterm-color-magenta +- vterm-color-cyan +- vterm-color-white + +## Directory tracking and Prompt tracking + +`vterm` supports _directory tracking_. If this feature is enabled, the default +directory in Emacs and the current working directory in `vterm` are synced. As a +result, interactive functions that ask for a path or a file (e.g., `dired` or +`find-file`) will do so starting from the current location. + +And `vterm` supports _prompt tracking_. If this feature is enabled, Emacs knows +where the prompt ends, you needn't customize `term-prompt-regexp` any more. +Then you can use `vterm-next-prompt` and `vterm-previous-prompt` +moving to end of next/previous prompt. The default keybinding is `C-c C-n` and `C-c C-p`. + +And `vterm-beginning-of-line` would move the point to the first character after the +shell prompt on this line. If the point is already there, move to the beginning of the line. +The default keybinding is `C-a` in `vterm-copy-mode`. + +And `vterm--at-prompt-p` would check whether the cursor is at the point just after +the shell prompt. + +Directory tracking and Prompt tracking requires some configuration, as the shell has to be +instructed to share the relevant information with Emacs. The following pieces of +code assume that you have the function `vterm_printf` as defined in section +[shell-side configuration](#shell-side-configuration). + +For `zsh`, put this at the end of your `.zshrc`: + +```zsh +vterm_prompt_end() { + vterm_printf "51;A$(whoami)@$(hostname):$(pwd)"; +} +setopt PROMPT_SUBST +PROMPT=$PROMPT'%{$(vterm_prompt_end)%}' +``` + +For `bash`, put this at the end of your `.bashrc`: + +```bash +vterm_prompt_end(){ + vterm_printf "51;A$(whoami)@$(hostname):$(pwd)" +} +PS1=$PS1'\[$(vterm_prompt_end)\]' +``` + +For `fish`, put this in your `~/.config/fish/config.fish`: + +```fish +function vterm_prompt_end; + vterm_printf '51;A'(whoami)'@'(hostname)':'(pwd) +end +functions --copy fish_prompt vterm_old_fish_prompt +function fish_prompt --description 'Write out the prompt; do not replace this. Instead, put this at end of your file.' + # Remove the trailing newline from the original prompt. This is done + # using the string builtin from fish, but to make sure any escape codes + # are correctly interpreted, use %b for printf. + printf "%b" (string join "\n" (vterm_old_fish_prompt)) + vterm_prompt_end +end +``` +Here we are using the function `vterm_printf` that we have discussed above, so make +sure that this function is defined in your configuration file. + + +Directory tracking works on remote servers too. In case the hostname of your +remote machine does not match the actual hostname needed to connect to that +server, change `$(hostname)` with the correct one. For example, if the correct +hostname is `foo` and the username is `bar`, you should have something like +```bash +HOSTNAME=foo +USER=baz +vterm_printf "51;A$USER@$HOSTNAME:$(pwd)" +``` + +## Message passing + +`vterm` can read and execute commands. At the moment, a command is +passed by providing a specific escape sequence. For example, to evaluate +``` elisp +(message "Hello!") +``` +use +``` sh +printf "\e]51;Emessage \"Hello\!\"\e\\" +# or +vterm_printf "51;Emessage \"Hello\!\"" +``` + +The commands that are understood are defined in the setting `vterm-eval-cmds`. + +As `split-string-and-unquote` is used the parse the passed string, double quotes +and backslashes need to be escaped via backslash. A convenient shell function to +automate the substitution is + +`bash` or `zsh`: +```sh +vterm_cmd() { + local vterm_elisp + vterm_elisp="" + while [ $# -gt 0 ]; do + vterm_elisp="$vterm_elisp""$(printf '"%s" ' "$(printf "%s" "$1" | sed -e 's|\\|\\\\|g' -e 's|"|\\"|g')")" + shift + done + vterm_printf "51;E$vterm_elisp" +} +``` +`fish`: +```sh +function vterm_cmd --description 'Run an Emacs command among the ones been defined in vterm-eval-cmds.' + set -l vterm_elisp () + for arg in $argv + set -a vterm_elisp (printf '"%s" ' (string replace -a -r '([\\\\"])' '\\\\\\\\$1' $arg)) + end + vterm_printf '51;E'(string join '' $vterm_elisp) +end +``` + +Now we can write shell functions to call the ones defined in `vterm-eval-cmds`. + +```sh +find_file() { + vterm_cmd find-file "$(realpath "${@:-.}")" +} + +say() { + vterm_cmd message "%s" "$*" +} +``` + +Or for `fish`: +```fish +function find_file + set -q argv[1]; or set argv[1] "." + vterm_cmd find-file (realpath "$argv") +end + +function say + vterm_cmd message "%s" "$argv" +end +``` + +This newly defined `find_file` function can now be used inside `vterm` as + +```sh +find_file name_of_file_in_local_directory +``` +If you call `find_file` without specifying any file (you just execute `find_file` in your shell), +`dired` will open with the current directory. + +As an example, say you like having files opened below the current window. You +could add the command to do it on the lisp side like so: + +``` elisp +(push (list "find-file-below" + (lambda (path) + (if-let* ((buf (find-file-noselect path)) + (window (display-buffer-below-selected buf nil))) + (select-window window) + (message "Failed to open file: %s" path)))) + vterm-eval-cmds) +``` + +Then add the command in your `.bashrc` file. + +```sh +open_file_below() { + vterm_cmd find-file-below "$(realpath "${@:-.}")" +} +``` + +Then you can open any file from inside your shell. + +```sh +open_file_below ~/Documents +``` + +## Shell-side configuration files + +The configurations described in earlier sections are combined in +[`etc/`](./etc/). These can be appended to or loaded into your user +configuration file. Alternatively, they can be installed system-wide, for +example in `/etc/bash/bashrc.d/`, `/etc/profile.d/` (for `zsh`), or +`/etc/fish/conf.d/` for `fish`. + +When using vterm Emacs sets the environment variable INSIDE_EMACS in the subshell to ‘vterm’. +Usually the programs check this variable to determine whether they are running inside Emacs. + +Vterm also sets an extra variable EMACS_VTERM_PATH to the place where the vterm library is installed. +This is very useful because when vterm is installed from melpa the Shell-side configuration files are +in the EMACS_VTERM_PATH inside the /etc sub-directory. After a package update, the directory name changes, +so, a code like this in your bashrc could be enough to load always the latest version of the file +from the right location without coping any file manually. + +``` +if [[ "$INSIDE_EMACS" = 'vterm' ]] \ + && [[ -n ${EMACS_VTERM_PATH} ]] \ + && [[ -f ${EMACS_VTERM_PATH}/etc/emacs-vterm-bash.sh ]]; then + source ${EMACS_VTERM_PATH}/etc/emacs-vterm-bash.sh +fi +``` + +## Frequently Asked Questions and Problems + +### How can I increase the size of the scrollback? + +By default, the scrollback can contain up to 1000 lines per each vterm buffer. +You can increase this up to 100000 by changing the variable +`vterm-max-scrollback`. If you want to increase it further, you have to edit the +file `vterm-module.h`, change the variable `SB_MAX`, and set the new value for +`vterm-max-scrollback`. The potential maximum memory consumption of vterm +buffers increases with `vterm-max-scrollback`, so setting `SB_MAX` to extreme +values may lead to system instabilities and crashes. + +### How can I automatically close vterm buffers when the process is terminated? + +There is an option for that: set `vterm-kill-buffer-on-exit` to `t`. + +### The package does not compile, I have errors related to `VTERM_COLOR`. + +The version of `libvterm` installed on your system is too old. You should let +`emacs-libvterm` download `libvterm` for you. You can either uninstall your +libvterm, or instruct Emacs to ignore the system libvterm. If you are compiling +from Emacs, you can do this by setting: +```emacs-lisp +(setq vterm-module-cmake-args "-DUSE_SYSTEM_LIBVTERM=no") +``` +and compile again. If you are compiling with CMake, use the flag +`-DUSE_SYSTEM_LIBVTERM=no`. + +### `` doesn't kill previous word. + +This can be fixed by rebinding the key to what `C-w` does: +```emacs-lisp +(define-key vterm-mode-map (kbd "") + (lambda () (interactive) (vterm-send-key (kbd "C-w")))) +``` + +### `counsel-yank-pop` doesn't work. + +Add this piece of code to your configuration file to make `counsel` use +the correct function to yank in vterm buffers. +```emacs-lisp +(defun vterm-counsel-yank-pop-action (orig-fun &rest args) + (if (equal major-mode 'vterm-mode) + (let ((inhibit-read-only t) + (yank-undo-function (lambda (_start _end) (vterm-undo)))) + (cl-letf (((symbol-function 'insert-for-yank) + (lambda (str) (vterm-send-string str t)))) + (apply orig-fun args))) + (apply orig-fun args))) + +(advice-add 'counsel-yank-pop-action :around #'vterm-counsel-yank-pop-action) +``` + +### How can I get the local directory without shell-side configuration? + +We recommend that you set up shell-side configuration for reliable directory +tracking. If you cannot do it, a possible workaround is the following. + +On most GNU/Linux systems, you can read current directory from `/proc`: +```emacs-lisp +(defun vterm-directory-sync () + "Synchronize current working directory." + (interactive) + (when vterm--process + (let* ((pid (process-id vterm--process)) + (dir (file-truename (format "/proc/%d/cwd/" pid)))) + (setq default-directory dir)))) +``` +A possible application of this function is in combination with `find-file`: +```emacs-lisp +(advice-add #'find-file :before #'vterm-directory-sync) +``` +This method does not work on remote machines. + +### How can I get the directory tracking in a more understandable way? + +If you looked at the recommended way to set-up directory tracking, you will have +noticed that it requires printing obscure code like `\e]2;%m:%2~\a` (unless you +are using `fish`). + +There is another way to achieve this behavior. Define a shell function, on a +local host you can simply use + +``` sh +vterm_set_directory() { + vterm_cmd update-pwd "$PWD/" +} +``` +On a remote one, use instead +``` sh +vterm_set_directory() { + vterm_cmd update-pwd "/-:""$USER""@""$HOSTNAME"":""$PWD/" +} +``` +Then, for `zsh`, add this function to the `chpwd` hook: + +``` sh +autoload -U add-zsh-hook +add-zsh-hook -Uz chpwd (){ vterm_set_directory } +``` +For `bash`, append it to the prompt: + +``` sh +PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND; }vterm_set_directory" +``` +Finally, add `update-pwd` to the list of commands that Emacs +is allowed to execute from vterm: + +``` emacs-lisp +(add-to-list 'vterm-eval-cmds '("update-pwd" (lambda (path) (setq default-directory path)))) +``` + +### When evil-mode is enabled, the cursor moves back in normal state, and this messes directory tracking + +`evil-collection` provides a solution for this problem. If you do not want to +use `evil-collection`, you can add the following code: + +```emacs-lisp +(defun evil-collection-vterm-escape-stay () +"Go back to normal state but don't move +cursor backwards. Moving cursor backwards is the default vim behavior but it is +not appropriate in some cases like terminals." +(setq-local evil-move-cursor-back nil)) + +(add-hook 'vterm-mode-hook #'evil-collection-vterm-escape-stay) +``` + + +## Related packages + +- [vterm-toggle](https://github.com/jixiuf/vterm-toggle): Toggles between a + vterm and the current buffer +- [multi-libvterm](https://github.com/suonlight/multi-libvterm): Multiterm for emacs-libvterm + +## Appendix + +### Breaking changes + +Obsolete variables will be removed in version 0.1. + +#### October 2020 + +* `vterm-disable-bold-font` was renamed to `vterm-disable-bold` to uniform it + with the other similar options. + +#### July 2020 + +* `vterm-use-vterm-prompt` was renamed to `vterm-use-vterm-prompt-detection-method`. +* `vterm-kill-buffer-on-exit` is set to `t` by default. + +#### April 2020 + +* `vterm-clear-scrollback` was renamed to `vterm-clear-scrollback-when-clearning`. +* `vterm-set-title-functions` was removed. In its place, there is a new custom + option `vterm-buffer-name-string`. See + [vterm-buffer-name-string](vterm-buffer-name-string) for documentation. diff --git a/lisp/vterm/elisp.c b/lisp/vterm/elisp.c new file mode 100644 index 00000000..24c76012 --- /dev/null +++ b/lisp/vterm/elisp.c @@ -0,0 +1,209 @@ +#include "elisp.h" +#include + +// Emacs symbols +emacs_value Qt; +emacs_value Qnil; +emacs_value Qnormal; +emacs_value Qbold; +emacs_value Qitalic; +emacs_value Qforeground; +emacs_value Qbackground; +emacs_value Qweight; +emacs_value Qunderline; +emacs_value Qslant; +emacs_value Qreverse; +emacs_value Qstrike; +emacs_value Qextend; +emacs_value Qface; +emacs_value Qbox; +emacs_value Qbar; +emacs_value Qhbar; +emacs_value Qcursor_type; +emacs_value Qemacs_major_version; +emacs_value Qvterm_line_wrap; +emacs_value Qrear_nonsticky; +emacs_value Qvterm_prompt; + +// Emacs functions +emacs_value Fblink_cursor_mode; +emacs_value Fsymbol_value; +emacs_value Flength; +emacs_value Flist; +emacs_value Fnth; +emacs_value Ferase_buffer; +emacs_value Finsert; +emacs_value Fgoto_char; +emacs_value Fforward_char; +emacs_value Fforward_line; +emacs_value Fgoto_line; +emacs_value Fdelete_lines; +emacs_value Frecenter; +emacs_value Fset_window_point; +emacs_value Fwindow_body_height; +emacs_value Fpoint; + +emacs_value Fput_text_property; +emacs_value Fadd_text_properties; +emacs_value Fset; +emacs_value Fvterm_flush_output; +emacs_value Fget_buffer_window_list; +emacs_value Fselected_window; +emacs_value Fvterm_set_title; +emacs_value Fvterm_set_directory; +emacs_value Fvterm_invalidate; +emacs_value Feq; +emacs_value Fvterm_get_color; +emacs_value Fvterm_eval; +emacs_value Fvterm_selection; + +/* Set the function cell of the symbol named NAME to SFUN using + the 'fset' function. */ +void bind_function(emacs_env *env, const char *name, emacs_value Sfun) { + emacs_value Qfset = env->intern(env, "fset"); + emacs_value Qsym = env->intern(env, name); + + env->funcall(env, Qfset, 2, (emacs_value[]){Qsym, Sfun}); +} + +/* Provide FEATURE to Emacs. */ +void provide(emacs_env *env, const char *feature) { + emacs_value Qfeat = env->intern(env, feature); + emacs_value Qprovide = env->intern(env, "provide"); + + env->funcall(env, Qprovide, 1, (emacs_value[]){Qfeat}); +} + +emacs_value symbol_value(emacs_env *env, emacs_value symbol) { + return env->funcall(env, Fsymbol_value, 1, (emacs_value[]){symbol}); +} + +int string_bytes(emacs_env *env, emacs_value string) { + ptrdiff_t size = 0; + env->copy_string_contents(env, string, NULL, &size); + return size; +} + +emacs_value length(emacs_env *env, emacs_value string) { + return env->funcall(env, Flength, 1, (emacs_value[]){string}); +} + +emacs_value list(emacs_env *env, emacs_value elements[], ptrdiff_t len) { + return env->funcall(env, Flist, len, elements); +} +emacs_value nth(emacs_env *env, int idx, emacs_value list) { + emacs_value eidx = env->make_integer(env, idx); + return env->funcall(env, Fnth, 2, (emacs_value[]){eidx, list}); +} + +void put_text_property(emacs_env *env, emacs_value string, emacs_value property, + emacs_value value) { + emacs_value start = env->make_integer(env, 0); + emacs_value end = length(env, string); + + env->funcall(env, Fput_text_property, 5, + (emacs_value[]){start, end, property, value, string}); +} + +void add_text_properties(emacs_env *env, emacs_value string, + emacs_value property) { + emacs_value start = env->make_integer(env, 0); + emacs_value end = length(env, string); + + env->funcall(env, Fadd_text_properties, 4, + (emacs_value[]){start, end, property, string}); +} + +void erase_buffer(emacs_env *env) { env->funcall(env, Ferase_buffer, 0, NULL); } + +void insert(emacs_env *env, emacs_value string) { + env->funcall(env, Finsert, 1, (emacs_value[]){string}); +} + +void goto_char(emacs_env *env, int pos) { + emacs_value point = env->make_integer(env, pos); + env->funcall(env, Fgoto_char, 1, (emacs_value[]){point}); +} + +void forward_line(emacs_env *env, int n) { + emacs_value nline = env->make_integer(env, n); + env->funcall(env, Fforward_line, 1, (emacs_value[]){nline}); +} +void goto_line(emacs_env *env, int n) { + emacs_value nline = env->make_integer(env, n); + env->funcall(env, Fgoto_line, 1, (emacs_value[]){nline}); +} +void delete_lines(emacs_env *env, int linenum, int count, bool del_whole_line) { + emacs_value Qlinenum = env->make_integer(env, linenum); + emacs_value Qcount = env->make_integer(env, count); + if (del_whole_line) { + env->funcall(env, Fdelete_lines, 3, (emacs_value[]){Qlinenum, Qcount, Qt}); + } else { + env->funcall(env, Fdelete_lines, 3, + (emacs_value[]){Qlinenum, Qcount, Qnil}); + } +} +void recenter(emacs_env *env, emacs_value pos) { + env->funcall(env, Frecenter, 1, (emacs_value[]){pos}); +} +emacs_value point(emacs_env *env) { return env->funcall(env, Fpoint, 0, NULL); } + +void set_window_point(emacs_env *env, emacs_value win, emacs_value point) { + env->funcall(env, Fset_window_point, 2, (emacs_value[]){win, point}); +} +emacs_value window_body_height(emacs_env *env, emacs_value win) { + return env->funcall(env, Fwindow_body_height, 1, (emacs_value[]){win}); +} + +bool eq(emacs_env *env, emacs_value e1, emacs_value e2) { + emacs_value Qeq = env->funcall(env, Feq, 2, (emacs_value[]){e1, e2}); + return env->is_not_nil(env, Qeq); +} + +void forward_char(emacs_env *env, emacs_value n) { + env->funcall(env, Fforward_char, 1, (emacs_value[]){n}); +} + +emacs_value get_buffer_window_list(emacs_env *env) { + return env->funcall(env, Fget_buffer_window_list, 3, + (emacs_value[]){Qnil, Qnil, Qt}); +} + +emacs_value selected_window(emacs_env *env) { + return env->funcall(env, Fselected_window, 0, (emacs_value[]){}); +} + +void set_cursor_type(emacs_env *env, emacs_value cursor_type) { + env->funcall(env, Fset, 2, (emacs_value[]){Qcursor_type, cursor_type}); +} + +void set_cursor_blink(emacs_env *env, bool blink) { + env->funcall(env, Fblink_cursor_mode, 1, + (emacs_value[]){env->make_integer(env, blink)}); +} + +emacs_value vterm_get_color(emacs_env *env, int index) { + emacs_value idx = env->make_integer(env, index); + return env->funcall(env, Fvterm_get_color, 1, (emacs_value[]){idx}); +} + +void set_title(emacs_env *env, emacs_value string) { + env->funcall(env, Fvterm_set_title, 1, (emacs_value[]){string}); +} + +void set_directory(emacs_env *env, emacs_value string) { + env->funcall(env, Fvterm_set_directory, 1, (emacs_value[]){string}); +} + +void vterm_invalidate(emacs_env *env) { + env->funcall(env, Fvterm_invalidate, 0, NULL); +} +emacs_value vterm_eval(emacs_env *env, emacs_value string) { + return env->funcall(env, Fvterm_eval, 1, (emacs_value[]){string}); +} + +emacs_value vterm_selection(emacs_env *env, emacs_value selection_target, + emacs_value selection_data) { + return env->funcall(env, Fvterm_selection, 2, + (emacs_value[]){selection_target, selection_data}); +} diff --git a/lisp/vterm/elisp.h b/lisp/vterm/elisp.h new file mode 100644 index 00000000..39be7104 --- /dev/null +++ b/lisp/vterm/elisp.h @@ -0,0 +1,99 @@ +#ifndef ELISP_H +#define ELISP_H + +#include "emacs-module.h" +#include "vterm.h" + +// Emacs symbols +extern emacs_value Qt; +extern emacs_value Qnil; +extern emacs_value Qnormal; +extern emacs_value Qbold; +extern emacs_value Qitalic; +extern emacs_value Qforeground; +extern emacs_value Qbackground; +extern emacs_value Qweight; +extern emacs_value Qunderline; +extern emacs_value Qslant; +extern emacs_value Qreverse; +extern emacs_value Qstrike; +extern emacs_value Qextend; +extern emacs_value Qface; +extern emacs_value Qbox; +extern emacs_value Qbar; +extern emacs_value Qhbar; +extern emacs_value Qcursor_type; +extern emacs_value Qemacs_major_version; +extern emacs_value Qvterm_line_wrap; +extern emacs_value Qrear_nonsticky; +extern emacs_value Qvterm_prompt; + +// Emacs functions +extern emacs_value Fblink_cursor_mode; +extern emacs_value Fsymbol_value; +extern emacs_value Flength; +extern emacs_value Flist; +extern emacs_value Fnth; +extern emacs_value Ferase_buffer; +extern emacs_value Finsert; +extern emacs_value Fgoto_char; +extern emacs_value Fforward_char; +extern emacs_value Fforward_line; +extern emacs_value Fgoto_line; +extern emacs_value Fdelete_lines; +extern emacs_value Frecenter; +extern emacs_value Fset_window_point; +extern emacs_value Fwindow_body_height; +extern emacs_value Fpoint; + +extern emacs_value Fput_text_property; +extern emacs_value Fadd_text_properties; +extern emacs_value Fset; +extern emacs_value Fvterm_flush_output; +extern emacs_value Fget_buffer_window_list; +extern emacs_value Fselected_window; +extern emacs_value Fvterm_set_title; +extern emacs_value Fvterm_set_directory; +extern emacs_value Fvterm_invalidate; +extern emacs_value Feq; +extern emacs_value Fvterm_get_color; +extern emacs_value Fvterm_eval; +extern emacs_value Fvterm_selection; + +// Utils +void bind_function(emacs_env *env, const char *name, emacs_value Sfun); +void provide(emacs_env *env, const char *feature); +emacs_value symbol_value(emacs_env *env, emacs_value symbol); +int string_bytes(emacs_env *env, emacs_value string); +emacs_value length(emacs_env *env, emacs_value string); +emacs_value list(emacs_env *env, emacs_value elements[], ptrdiff_t len); +emacs_value nth(emacs_env *env, int idx, emacs_value list); +void put_text_property(emacs_env *env, emacs_value string, emacs_value property, + emacs_value value); +void add_text_properties(emacs_env *env, emacs_value string, + emacs_value property); +void erase_buffer(emacs_env *env); +void insert(emacs_env *env, emacs_value string); +void goto_char(emacs_env *env, int pos); +void forward_line(emacs_env *env, int n); +void goto_line(emacs_env *env, int n); +void set_cursor_type(emacs_env *env, emacs_value cursor_type); +void set_cursor_blink(emacs_env *env, bool blink); +void delete_lines(emacs_env *env, int linenum, int count, bool del_whole_line); +void recenter(emacs_env *env, emacs_value pos); +void set_window_point(emacs_env *env, emacs_value win, emacs_value point); +emacs_value window_body_height(emacs_env *env, emacs_value win); +emacs_value point(emacs_env *env); +bool eq(emacs_env *env, emacs_value e1, emacs_value e2); +void forward_char(emacs_env *env, emacs_value n); +emacs_value get_buffer_window_list(emacs_env *env); +emacs_value selected_window(emacs_env *env); +void set_title(emacs_env *env, emacs_value string); +void set_directory(emacs_env *env, emacs_value string); +void vterm_invalidate(emacs_env *env); +emacs_value vterm_get_color(emacs_env *env, int index); +emacs_value vterm_eval(emacs_env *env, emacs_value string); +emacs_value vterm_selection(emacs_env *env, emacs_value selection_target, + emacs_value selection_data); + +#endif /* ELISP_H */ diff --git a/lisp/vterm/emacs-module.h b/lisp/vterm/emacs-module.h new file mode 100644 index 00000000..5a7d603c --- /dev/null +++ b/lisp/vterm/emacs-module.h @@ -0,0 +1,334 @@ +/* emacs-module.h - GNU Emacs module API. + +Copyright (C) 2015-2018 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or (at +your option) any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs. If not, see . */ + +#ifndef EMACS_MODULE_H +#define EMACS_MODULE_H + +#include +#include + +#ifndef __cplusplus +#include +#endif + +#if defined __cplusplus && __cplusplus >= 201103L +#define EMACS_NOEXCEPT noexcept +#else +#define EMACS_NOEXCEPT +#endif + +#ifdef __has_attribute +#if __has_attribute(__nonnull__) +#define EMACS_ATTRIBUTE_NONNULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#endif +#endif +#ifndef EMACS_ATTRIBUTE_NONNULL +#define EMACS_ATTRIBUTE_NONNULL(...) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* Current environment. */ +typedef struct emacs_env_25 emacs_env; + +/* Opaque pointer representing an Emacs Lisp value. + BEWARE: Do not assume NULL is a valid value! */ +typedef struct emacs_value_tag *emacs_value; + +enum { emacs_variadic_function = -2 }; + +/* Struct passed to a module init function (emacs_module_init). */ +struct emacs_runtime { + /* Structure size (for version checking). */ + ptrdiff_t size; + + /* Private data; users should not touch this. */ + struct emacs_runtime_private *private_members; + + /* Return an environment pointer. */ + emacs_env *(*get_environment)(struct emacs_runtime *ert) + EMACS_ATTRIBUTE_NONNULL(1); +}; + +/* Possible Emacs function call outcomes. */ +enum emacs_funcall_exit { + /* Function has returned normally. */ + emacs_funcall_exit_return = 0, + + /* Function has signaled an error using `signal'. */ + emacs_funcall_exit_signal = 1, + + /* Function has exit using `throw'. */ + emacs_funcall_exit_throw = 2 +}; + +struct emacs_env_25 { + /* Structure size (for version checking). */ + ptrdiff_t size; + + /* Private data; users should not touch this. */ + struct emacs_env_private *private_members; + + /* Memory management. */ + + emacs_value (*make_global_ref)(emacs_env *env, emacs_value any_reference) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*free_global_ref)(emacs_env *env, emacs_value global_reference) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Non-local exit handling. */ + + enum emacs_funcall_exit (*non_local_exit_check)(emacs_env *env) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*non_local_exit_clear)(emacs_env *env) EMACS_ATTRIBUTE_NONNULL(1); + + enum emacs_funcall_exit (*non_local_exit_get)( + emacs_env *env, emacs_value *non_local_exit_symbol_out, + emacs_value *non_local_exit_data_out) EMACS_ATTRIBUTE_NONNULL(1, 2, 3); + + void (*non_local_exit_signal)(emacs_env *env, + emacs_value non_local_exit_symbol, + emacs_value non_local_exit_data) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*non_local_exit_throw)(emacs_env *env, emacs_value tag, + emacs_value value) EMACS_ATTRIBUTE_NONNULL(1); + + /* Function registration. */ + + emacs_value (*make_function)( + emacs_env *env, ptrdiff_t min_arity, ptrdiff_t max_arity, + emacs_value (*function)(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *) + EMACS_NOEXCEPT EMACS_ATTRIBUTE_NONNULL(1), + const char *documentation, void *data) EMACS_ATTRIBUTE_NONNULL(1, 4); + + emacs_value (*funcall)(emacs_env *env, emacs_value function, ptrdiff_t nargs, + emacs_value args[]) EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*intern)(emacs_env *env, const char *symbol_name) + EMACS_ATTRIBUTE_NONNULL(1, 2); + + /* Type conversion. */ + + emacs_value (*type_of)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + bool (*is_not_nil)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + bool (*eq)(emacs_env *env, emacs_value a, emacs_value b) + EMACS_ATTRIBUTE_NONNULL(1); + + intmax_t (*extract_integer)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*make_integer)(emacs_env *env, intmax_t value) + EMACS_ATTRIBUTE_NONNULL(1); + + double (*extract_float)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*make_float)(emacs_env *env, double value) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Copy the content of the Lisp string VALUE to BUFFER as an utf8 + null-terminated string. + + SIZE must point to the total size of the buffer. If BUFFER is + NULL or if SIZE is not big enough, write the required buffer size + to SIZE and return true. + + Note that SIZE must include the last null byte (e.g. "abc" needs + a buffer of size 4). + + Return true if the string was successfully copied. */ + + bool (*copy_string_contents)(emacs_env *env, emacs_value value, char *buffer, + ptrdiff_t *size_inout) + EMACS_ATTRIBUTE_NONNULL(1, 4); + + /* Create a Lisp string from a utf8 encoded string. */ + emacs_value (*make_string)(emacs_env *env, const char *contents, + ptrdiff_t length) EMACS_ATTRIBUTE_NONNULL(1, 2); + + /* Embedded pointer type. */ + emacs_value (*make_user_ptr)(emacs_env *env, + void (*fin)(void *) EMACS_NOEXCEPT, void *ptr) + EMACS_ATTRIBUTE_NONNULL(1); + + void *(*get_user_ptr)(emacs_env *env, + emacs_value uptr)EMACS_ATTRIBUTE_NONNULL(1); + void (*set_user_ptr)(emacs_env *env, emacs_value uptr, void *ptr) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*(*get_user_finalizer)(emacs_env *env, + emacs_value uptr))(void *) EMACS_NOEXCEPT + EMACS_ATTRIBUTE_NONNULL(1); + void (*set_user_finalizer)(emacs_env *env, emacs_value uptr, + void (*fin)(void *) EMACS_NOEXCEPT) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Vector functions. */ + emacs_value (*vec_get)(emacs_env *env, emacs_value vec, ptrdiff_t i) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*vec_set)(emacs_env *env, emacs_value vec, ptrdiff_t i, emacs_value val) + EMACS_ATTRIBUTE_NONNULL(1); + + ptrdiff_t (*vec_size)(emacs_env *env, emacs_value vec) + EMACS_ATTRIBUTE_NONNULL(1); +}; + +struct emacs_env_26 { + /* Structure size (for version checking). */ + ptrdiff_t size; + + /* Private data; users should not touch this. */ + struct emacs_env_private *private_members; + + /* Memory management. */ + + emacs_value (*make_global_ref)(emacs_env *env, emacs_value any_reference) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*free_global_ref)(emacs_env *env, emacs_value global_reference) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Non-local exit handling. */ + + enum emacs_funcall_exit (*non_local_exit_check)(emacs_env *env) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*non_local_exit_clear)(emacs_env *env) EMACS_ATTRIBUTE_NONNULL(1); + + enum emacs_funcall_exit (*non_local_exit_get)( + emacs_env *env, emacs_value *non_local_exit_symbol_out, + emacs_value *non_local_exit_data_out) EMACS_ATTRIBUTE_NONNULL(1, 2, 3); + + void (*non_local_exit_signal)(emacs_env *env, + emacs_value non_local_exit_symbol, + emacs_value non_local_exit_data) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*non_local_exit_throw)(emacs_env *env, emacs_value tag, + emacs_value value) EMACS_ATTRIBUTE_NONNULL(1); + + /* Function registration. */ + + emacs_value (*make_function)( + emacs_env *env, ptrdiff_t min_arity, ptrdiff_t max_arity, + emacs_value (*function)(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *) + EMACS_NOEXCEPT EMACS_ATTRIBUTE_NONNULL(1), + const char *documentation, void *data) EMACS_ATTRIBUTE_NONNULL(1, 4); + + emacs_value (*funcall)(emacs_env *env, emacs_value function, ptrdiff_t nargs, + emacs_value args[]) EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*intern)(emacs_env *env, const char *symbol_name) + EMACS_ATTRIBUTE_NONNULL(1, 2); + + /* Type conversion. */ + + emacs_value (*type_of)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + bool (*is_not_nil)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + bool (*eq)(emacs_env *env, emacs_value a, emacs_value b) + EMACS_ATTRIBUTE_NONNULL(1); + + intmax_t (*extract_integer)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*make_integer)(emacs_env *env, intmax_t value) + EMACS_ATTRIBUTE_NONNULL(1); + + double (*extract_float)(emacs_env *env, emacs_value value) + EMACS_ATTRIBUTE_NONNULL(1); + + emacs_value (*make_float)(emacs_env *env, double value) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Copy the content of the Lisp string VALUE to BUFFER as an utf8 + null-terminated string. + + SIZE must point to the total size of the buffer. If BUFFER is + NULL or if SIZE is not big enough, write the required buffer size + to SIZE and return true. + + Note that SIZE must include the last null byte (e.g. "abc" needs + a buffer of size 4). + + Return true if the string was successfully copied. */ + + bool (*copy_string_contents)(emacs_env *env, emacs_value value, char *buffer, + ptrdiff_t *size_inout) + EMACS_ATTRIBUTE_NONNULL(1, 4); + + /* Create a Lisp string from a utf8 encoded string. */ + emacs_value (*make_string)(emacs_env *env, const char *contents, + ptrdiff_t length) EMACS_ATTRIBUTE_NONNULL(1, 2); + + /* Embedded pointer type. */ + emacs_value (*make_user_ptr)(emacs_env *env, + void (*fin)(void *) EMACS_NOEXCEPT, void *ptr) + EMACS_ATTRIBUTE_NONNULL(1); + + void *(*get_user_ptr)(emacs_env *env, + emacs_value uptr)EMACS_ATTRIBUTE_NONNULL(1); + void (*set_user_ptr)(emacs_env *env, emacs_value uptr, void *ptr) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*(*get_user_finalizer)(emacs_env *env, + emacs_value uptr))(void *) EMACS_NOEXCEPT + EMACS_ATTRIBUTE_NONNULL(1); + void (*set_user_finalizer)(emacs_env *env, emacs_value uptr, + void (*fin)(void *) EMACS_NOEXCEPT) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Vector functions. */ + emacs_value (*vec_get)(emacs_env *env, emacs_value vec, ptrdiff_t i) + EMACS_ATTRIBUTE_NONNULL(1); + + void (*vec_set)(emacs_env *env, emacs_value vec, ptrdiff_t i, emacs_value val) + EMACS_ATTRIBUTE_NONNULL(1); + + ptrdiff_t (*vec_size)(emacs_env *env, emacs_value vec) + EMACS_ATTRIBUTE_NONNULL(1); + + /* Returns whether a quit is pending. */ + bool (*should_quit)(emacs_env *env) EMACS_ATTRIBUTE_NONNULL(1); +}; + +/* Every module should define a function as follows. */ +extern int emacs_module_init(struct emacs_runtime *ert) EMACS_NOEXCEPT + EMACS_ATTRIBUTE_NONNULL(1); + +#ifdef __cplusplus +} +#endif + +#endif /* EMACS_MODULE_H */ diff --git a/lisp/vterm/etc/emacs-vterm-bash.sh b/lisp/vterm/etc/emacs-vterm-bash.sh new file mode 100644 index 00000000..94b012c1 --- /dev/null +++ b/lisp/vterm/etc/emacs-vterm-bash.sh @@ -0,0 +1,55 @@ +# Some of the most useful features in emacs-libvterm require shell-side +# configurations. The main goal of these additional functions is to enable the +# shell to send information to `vterm` via properly escaped sequences. A +# function that helps in this task, `vterm_printf`, is defined below. + +function vterm_printf(){ + if [ -n "$TMUX" ] && ([ "${TERM%%-*}" = "tmux" ] || [ "${TERM%%-*}" = "screen" ] ); then + # Tell tmux to pass the escape sequences through + printf "\ePtmux;\e\e]%s\007\e\\" "$1" + elif [ "${TERM%%-*}" = "screen" ]; then + # GNU screen (screen, screen-256color, screen-256color-bce) + printf "\eP\e]%s\007\e\\" "$1" + else + printf "\e]%s\e\\" "$1" + fi +} + +# Completely clear the buffer. With this, everything that is not on screen +# is erased. +if [[ "$INSIDE_EMACS" = 'vterm' ]]; then + function clear(){ + vterm_printf "51;Evterm-clear-scrollback"; + tput clear; + } +fi + +# With vterm_cmd you can execute Emacs commands directly from the shell. +# For example, vterm_cmd message "HI" will print "HI". +# To enable new commands, you have to customize Emacs's variable +# vterm-eval-cmds. +vterm_cmd() { + local vterm_elisp + vterm_elisp="" + while [ $# -gt 0 ]; do + vterm_elisp="$vterm_elisp""$(printf '"%s" ' "$(printf "%s" "$1" | sed -e 's|\\|\\\\|g' -e 's|"|\\"|g')")" + shift + done + vterm_printf "51;E$vterm_elisp" +} + +# This is to change the title of the buffer based on information provided by the +# shell. See, http://tldp.org/HOWTO/Xterm-Title-4.html, for the meaning of the +# various symbols. +PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND; }"'echo -ne "\033]0;${HOSTNAME}:${PWD}\007"' + +# Sync directory and host in the shell with Emacs's current directory. +# You may need to manually specify the hostname instead of $(hostname) in case +# $(hostname) does not return the correct string to connect to the server. +# +# The escape sequence "51;A" has also the role of identifying the end of the +# prompt +vterm_prompt_end(){ + vterm_printf "51;A$(whoami)@$(hostname):$(pwd)" +} +PS1=$PS1'\[$(vterm_prompt_end)\]' diff --git a/lisp/vterm/etc/emacs-vterm-zsh.sh b/lisp/vterm/etc/emacs-vterm-zsh.sh new file mode 100644 index 00000000..9006c5e8 --- /dev/null +++ b/lisp/vterm/etc/emacs-vterm-zsh.sh @@ -0,0 +1,54 @@ +# Some of the most useful features in emacs-libvterm require shell-side +# configurations. The main goal of these additional functions is to enable the +# shell to send information to `vterm` via properly escaped sequences. A +# function that helps in this task, `vterm_printf`, is defined below. + +function vterm_printf(){ + if [ -n "$TMUX" ] && ([ "${TERM%%-*}" = "tmux" ] || [ "${TERM%%-*}" = "screen" ] ); then + # Tell tmux to pass the escape sequences through + printf "\ePtmux;\e\e]%s\007\e\\" "$1" + elif [ "${TERM%%-*}" = "screen" ]; then + # GNU screen (screen, screen-256color, screen-256color-bce) + printf "\eP\e]%s\007\e\\" "$1" + else + printf "\e]%s\e\\" "$1" + fi +} + +# Completely clear the buffer. With this, everything that is not on screen +# is erased. +if [[ "$INSIDE_EMACS" = 'vterm' ]]; then + alias clear='vterm_printf "51;Evterm-clear-scrollback";tput clear' +fi + +# With vterm_cmd you can execute Emacs commands directly from the shell. +# For example, vterm_cmd message "HI" will print "HI". +# To enable new commands, you have to customize Emacs's variable +# vterm-eval-cmds. +vterm_cmd() { + local vterm_elisp + vterm_elisp="" + while [ $# -gt 0 ]; do + vterm_elisp="$vterm_elisp""$(printf '"%s" ' "$(printf "%s" "$1" | sed -e 's|\\|\\\\|g' -e 's|"|\\"|g')")" + shift + done + vterm_printf "51;E$vterm_elisp" +} + +# This is to change the title of the buffer based on information provided by the +# shell. See, http://tldp.org/HOWTO/Xterm-Title-4.html, for the meaning of the +# various symbols. +autoload -U add-zsh-hook +add-zsh-hook -Uz chpwd (){ print -Pn "\e]2;%m:%2~\a" } + +# Sync directory and host in the shell with Emacs's current directory. +# You may need to manually specify the hostname instead of $(hostname) in case +# $(hostname) does not return the correct string to connect to the server. +# +# The escape sequence "51;A" has also the role of identifying the end of the +# prompt +vterm_prompt_end() { + vterm_printf "51;A$(whoami)@$(hostname):$(pwd)"; +} +setopt PROMPT_SUBST +PROMPT=$PROMPT'%{$(vterm_prompt_end)%}' diff --git a/lisp/vterm/etc/emacs-vterm.fish b/lisp/vterm/etc/emacs-vterm.fish new file mode 100644 index 00000000..4f3248a6 --- /dev/null +++ b/lisp/vterm/etc/emacs-vterm.fish @@ -0,0 +1,67 @@ +# Some of the most useful features in emacs-libvterm require shell-side +# configurations. The main goal of these additional functions is to enable the +# shell to send information to `vterm` via properly escaped sequences. A +# function that helps in this task, `vterm_printf`, is defined below. + +function vterm_printf; + if begin; [ -n "$TMUX" ] ; and string match -q -r "screen|tmux" "$TERM"; end + # tell tmux to pass the escape sequences through + printf "\ePtmux;\e\e]%s\007\e\\" "$argv" + else if string match -q -- "screen*" "$TERM" + # GNU screen (screen, screen-256color, screen-256color-bce) + printf "\eP\e]%s\007\e\\" "$argv" + else + printf "\e]%s\e\\" "$argv" + end +end + +# Completely clear the buffer. With this, everything that is not on screen +# is erased. +if [ "$INSIDE_EMACS" = 'vterm' ] + function clear + vterm_printf "51;Evterm-clear-scrollback"; + tput clear; + end +end + +# This is to change the title of the buffer based on information provided by the +# shell. See, http://tldp.org/HOWTO/Xterm-Title-4.html, for the meaning of the +# various symbols. +function fish_title + hostname + echo ":" + pwd +end + +# With vterm_cmd you can execute Emacs commands directly from the shell. +# For example, vterm_cmd message "HI" will print "HI". +# To enable new commands, you have to customize Emacs's variable +# vterm-eval-cmds. +function vterm_cmd --description 'Run an Emacs command among the ones defined in vterm-eval-cmds.' + set -l vterm_elisp () + for arg in $argv + set -a vterm_elisp (printf '"%s" ' (string replace -a -r '([\\\\"])' '\\\\\\\\$1' $arg)) + end + vterm_printf '51;E'(string join '' $vterm_elisp) +end + +# Sync directory and host in the shell with Emacs's current directory. +# You may need to manually specify the hostname instead of $(hostname) in case +# $(hostname) does not return the correct string to connect to the server. +# +# The escape sequence "51;A" has also the role of identifying the end of the +# prompt +function vterm_prompt_end; + vterm_printf '51;A'(whoami)'@'(hostname)':'(pwd) +end + +# We are going to add a portion to the prompt, so we copy the old one +functions --copy fish_prompt vterm_old_fish_prompt + +function fish_prompt --description 'Write out the prompt; do not replace this. Instead, put this at end of your file.' + # Remove the trailing newline from the original prompt. This is done + # using the string builtin from fish, but to make sure any escape codes + # are correctly interpreted, use %b for printf. + printf "%b" (string join "\n" (vterm_old_fish_prompt)) + vterm_prompt_end +end diff --git a/lisp/vterm/utf8.c b/lisp/vterm/utf8.c new file mode 100644 index 00000000..49e1477a --- /dev/null +++ b/lisp/vterm/utf8.c @@ -0,0 +1,69 @@ +#include "utf8.h" + +size_t codepoint_to_utf8(const uint32_t codepoint, unsigned char buffer[4]) { + if (codepoint <= 0x7F) { + buffer[0] = codepoint; + return 1; + } + if (codepoint >= 0x80 && codepoint <= 0x07FF) { + buffer[0] = 0xC0 | (codepoint >> 6); + buffer[1] = 0x80 | (codepoint & 0x3F); + return 2; + } + if (codepoint >= 0x0800 && codepoint <= 0xFFFF) { + buffer[0] = 0xE0 | (codepoint >> 12); + buffer[1] = 0x80 | ((codepoint >> 6) & 0x3F); + buffer[2] = 0x80 | (codepoint & 0x3F); + return 3; + } + + if (codepoint >= 0x10000 && codepoint <= 0x10FFFF) { + buffer[0] = 0xF0 | (codepoint >> 18); + buffer[1] = 0x80 | ((codepoint >> 12) & 0x3F); + buffer[2] = 0x80 | ((codepoint >> 6) & 0x3F); + buffer[3] = 0x80 | (codepoint & 0x3F); + return 4; + } + return 0; +} + +bool utf8_to_codepoint(const unsigned char buffer[4], const size_t len, + uint32_t *codepoint) { + *codepoint = 0; + if (len == 1 && buffer[0] <= 0x7F) { + *codepoint = buffer[0]; + return true; + } + if (len == 2 && (buffer[0] >= 0xC0 && buffer[0] <= 0xDF) && + (buffer[1] >= 0x80 && buffer[1] <= 0xBF)) { + *codepoint = buffer[0] & 0x1F; + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[1] & 0x3F); + return true; + } + if (len == 3 && (buffer[0] >= 0xE0 && buffer[0] <= 0xEF) && + (buffer[1] >= 0x80 && buffer[1] <= 0xBF) && + (buffer[2] >= 0x80 && buffer[2] <= 0xBF)) { + *codepoint = buffer[0] & 0xF; + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[1] & 0x3F); + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[2] & 0x3F); + return true; + } + if (len == 4 && (buffer[0] >= 0xF0 && buffer[0] <= 0xF7) && + (buffer[1] >= 0x80 && buffer[1] <= 0xBF) && + (buffer[2] >= 0x80 && buffer[2] <= 0xBF) && + (buffer[3] >= 0x80 && buffer[3] <= 0xBF)) { + *codepoint = buffer[0] & 7; + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[1] & 0x3F); + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[2] & 0x3F); + *codepoint = *codepoint << 6; + *codepoint = *codepoint | (buffer[3] & 0x3F); + return true; + } + + return false; +} diff --git a/lisp/vterm/utf8.h b/lisp/vterm/utf8.h new file mode 100644 index 00000000..8ec5f3e0 --- /dev/null +++ b/lisp/vterm/utf8.h @@ -0,0 +1,12 @@ +#ifndef UTF8_H +#define UTF8_H + +#include +#include +#include + +size_t codepoint_to_utf8(const uint32_t codepoint, unsigned char buffer[4]); +bool utf8_to_codepoint(const unsigned char buffer[4], const size_t len, + uint32_t *codepoint); + +#endif /* UTF8_H */ diff --git a/lisp/vterm/vterm-module.c b/lisp/vterm/vterm-module.c new file mode 100644 index 00000000..72a1e210 --- /dev/null +++ b/lisp/vterm/vterm-module.c @@ -0,0 +1,1517 @@ +#include "vterm-module.h" +#include "elisp.h" +#include "utf8.h" +#include +#include +#include +#include +#include +#include +#include +#include + +static LineInfo *alloc_lineinfo() { + LineInfo *info = malloc(sizeof(LineInfo)); + info->directory = NULL; + info->prompt_col = -1; + return info; +} +void free_lineinfo(LineInfo *line) { + if (line == NULL) { + return; + } + if (line->directory != NULL) { + free(line->directory); + line->directory = NULL; + } + free(line); +} +static int term_sb_push(int cols, const VTermScreenCell *cells, void *data) { + Term *term = (Term *)data; + + if (!term->sb_size) { + return 0; + } + + // copy vterm cells into sb_buffer + size_t c = (size_t)cols; + ScrollbackLine *sbrow = NULL; + if (term->sb_current == term->sb_size) { + if (term->sb_buffer[term->sb_current - 1]->cols == c) { + // Recycle old row if it's the right size + sbrow = term->sb_buffer[term->sb_current - 1]; + } else { + if (term->sb_buffer[term->sb_current - 1]->info != NULL) { + free_lineinfo(term->sb_buffer[term->sb_current - 1]->info); + term->sb_buffer[term->sb_current - 1]->info = NULL; + } + free(term->sb_buffer[term->sb_current - 1]); + } + + // Make room at the start by shifting to the right. + memmove(term->sb_buffer + 1, term->sb_buffer, + sizeof(term->sb_buffer[0]) * (term->sb_current - 1)); + + } else if (term->sb_current > 0) { + // Make room at the start by shifting to the right. + memmove(term->sb_buffer + 1, term->sb_buffer, + sizeof(term->sb_buffer[0]) * term->sb_current); + } + + if (!sbrow) { + sbrow = malloc(sizeof(ScrollbackLine) + c * sizeof(sbrow->cells[0])); + sbrow->cols = c; + sbrow->info = NULL; + } + if (sbrow->info != NULL) { + free_lineinfo(sbrow->info); + } + sbrow->info = term->lines[0]; + memmove(term->lines, term->lines + 1, + sizeof(term->lines[0]) * (term->lines_len - 1)); + if (term->resizing) { + /* pushed by window height decr */ + if (term->lines[term->lines_len - 1] != NULL) { + /* do not need free here ,it is reused ,we just need set null */ + term->lines[term->lines_len - 1] = NULL; + } + term->lines_len--; + } else { + LineInfo *lastline = term->lines[term->lines_len - 1]; + if (lastline != NULL) { + LineInfo *line = alloc_lineinfo(); + if (lastline->directory != NULL) { + line->directory = malloc(1 + strlen(lastline->directory)); + strcpy(line->directory, lastline->directory); + } + term->lines[term->lines_len - 1] = line; + } + } + + // New row is added at the start of the storage buffer. + term->sb_buffer[0] = sbrow; + if (term->sb_current < term->sb_size) { + term->sb_current++; + } + + if (term->sb_pending < term->sb_size) { + term->sb_pending++; + /* when window height decreased */ + if (term->height_resize < 0 && + term->sb_pending_by_height_decr < -term->height_resize) { + term->sb_pending_by_height_decr++; + } + } + + memcpy(sbrow->cells, cells, c * sizeof(cells[0])); + + return 1; +} +/// Scrollback pop handler (from pangoterm). +/// +/// @param cols +/// @param cells VTerm state to update. +/// @param data Term +static int term_sb_pop(int cols, VTermScreenCell *cells, void *data) { + Term *term = (Term *)data; + + if (!term->sb_current) { + return 0; + } + + if (term->sb_pending) { + term->sb_pending--; + } + + ScrollbackLine *sbrow = term->sb_buffer[0]; + term->sb_current--; + // Forget the "popped" row by shifting the rest onto it. + memmove(term->sb_buffer, term->sb_buffer + 1, + sizeof(term->sb_buffer[0]) * (term->sb_current)); + + size_t cols_to_copy = (size_t)cols; + if (cols_to_copy > sbrow->cols) { + cols_to_copy = sbrow->cols; + } + + // copy to vterm state + memcpy(cells, sbrow->cells, sizeof(cells[0]) * cols_to_copy); + size_t col; + for (col = cols_to_copy; col < (size_t)cols; col++) { + cells[col].chars[0] = 0; + cells[col].width = 1; + } + + LineInfo **lines = malloc(sizeof(LineInfo *) * (term->lines_len + 1)); + + memmove(lines + 1, term->lines, sizeof(term->lines[0]) * term->lines_len); + lines[0] = sbrow->info; + free(sbrow); + term->lines_len += 1; + free(term->lines); + term->lines = lines; + + return 1; +} + +static int row_to_linenr(Term *term, int row) { + return row != INT_MAX ? row + (int)term->sb_current + 1 : INT_MAX; +} + +static int linenr_to_row(Term *term, int linenr) { + return linenr - (int)term->sb_current - 1; +} + +static void fetch_cell(Term *term, int row, int col, VTermScreenCell *cell) { + if (row < 0) { + ScrollbackLine *sbrow = term->sb_buffer[-row - 1]; + if ((size_t)col < sbrow->cols) { + *cell = sbrow->cells[col]; + } else { + // fill the pointer with an empty cell + VTermColor fg, bg; + VTermState *state = vterm_obtain_state(term->vt); + vterm_state_get_default_colors(state, &fg, &bg); + + *cell = (VTermScreenCell){.chars = {0}, .width = 1, .bg = bg}; + } + } else { + vterm_screen_get_cell(term->vts, (VTermPos){.row = row, .col = col}, cell); + } +} + +static char *get_row_directory(Term *term, int row) { + if (row < 0) { + ScrollbackLine *sbrow = term->sb_buffer[-row - 1]; + return sbrow->info->directory; + /* return term->dirs[0]; */ + } else { + LineInfo *line = term->lines[row]; + return line ? line->directory : NULL; + } +} +static LineInfo *get_lineinfo(Term *term, int row) { + if (row < 0) { + ScrollbackLine *sbrow = term->sb_buffer[-row - 1]; + return sbrow->info; + /* return term->dirs[0]; */ + } else { + return term->lines[row]; + } +} +static bool is_eol(Term *term, int end_col, int row, int col) { + /* This cell is EOL if this and every cell to the right is black */ + if (row >= 0) { + VTermPos pos = {.row = row, .col = col}; + return vterm_screen_is_eol(term->vts, pos); + } + + ScrollbackLine *sbrow = term->sb_buffer[-row - 1]; + int c; + for (c = col; c < end_col && c < sbrow->cols;) { + if (sbrow->cells[c].chars[0]) { + return 0; + } + c += sbrow->cells[c].width; + } + return 1; +} +static int is_end_of_prompt(Term *term, int end_col, int row, int col) { + LineInfo *info = get_lineinfo(term, row); + if (info == NULL) { + return 0; + } + if (info->prompt_col < 0) { + return 0; + } + if (info->prompt_col == col) { + return 1; + } + if (is_eol(term, end_col, row, col) && info->prompt_col >= col) { + return 1; + } + return 0; +} + +static void goto_col(Term *term, emacs_env *env, int row, int end_col) { + int col = 0; + size_t offset = 0; + size_t beyond_eol = 0; + + int height; + int width; + vterm_get_size(term->vt, &height, &width); + + while (col < end_col) { + VTermScreenCell cell; + fetch_cell(term, row, col, &cell); + if (cell.chars[0]) { + if (cell.width > 1) { + offset += cell.width - 1; + } + } else { + if (is_eol(term, term->width, row, col)) { + offset += cell.width; + beyond_eol += cell.width; + } + } + col += cell.width; + } + + forward_char(env, env->make_integer(env, end_col - offset)); + emacs_value space = env->make_string(env, " ", 1); + for (int i = 0; i < beyond_eol; i += 1) + insert(env, space); +} + +static void refresh_lines(Term *term, emacs_env *env, int start_row, + int end_row, int end_col) { + if (end_row < start_row) { + return; + } + int i, j; + +#define PUSH_BUFFER(c) \ + do { \ + if (length == capacity) { \ + capacity += end_col * 4; \ + buffer = realloc(buffer, capacity * sizeof(char)); \ + } \ + buffer[length] = (c); \ + length++; \ + } while (0) + + int capacity = ((end_row - start_row + 1) * end_col) * 4; + int length = 0; + char *buffer = malloc(capacity * sizeof(char)); + VTermScreenCell cell; + VTermScreenCell lastCell; + fetch_cell(term, start_row, 0, &lastCell); + + for (i = start_row; i < end_row; i++) { + + int newline = 0; + int isprompt = 0; + for (j = 0; j < end_col; j++) { + fetch_cell(term, i, j, &cell); + if (isprompt && length > 0) { + emacs_value text = render_text(env, term, buffer, length, &lastCell); + insert(env, render_prompt(env, text)); + length = 0; + } + + isprompt = is_end_of_prompt(term, end_col, i, j); + if (isprompt && length > 0) { + insert(env, render_text(env, term, buffer, length, &lastCell)); + length = 0; + } + + if (!compare_cells(&cell, &lastCell)) { + emacs_value text = render_text(env, term, buffer, length, &lastCell); + insert(env, text); + length = 0; + } + + lastCell = cell; + if (cell.chars[0] == 0) { + if (is_eol(term, end_col, i, j)) { + /* This cell is EOL if this and every cell to the right is black */ + PUSH_BUFFER('\n'); + newline = 1; + break; + } + PUSH_BUFFER(' '); + } else { + for (int k = 0; k < VTERM_MAX_CHARS_PER_CELL && cell.chars[k]; ++k) { + unsigned char bytes[4]; + size_t count = codepoint_to_utf8(cell.chars[k], bytes); + for (int l = 0; l < count; l++) { + PUSH_BUFFER(bytes[l]); + } + } + } + + if (cell.width > 1) { + int w = cell.width - 1; + j = j + w; + } + } + if (isprompt && length > 0) { + emacs_value text = render_text(env, term, buffer, length, &lastCell); + insert(env, render_prompt(env, text)); + length = 0; + isprompt = 0; + } + + if (!newline) { + emacs_value text = render_text(env, term, buffer, length, &lastCell); + insert(env, text); + length = 0; + text = render_fake_newline(env, term); + insert(env, text); + } + } + emacs_value text = render_text(env, term, buffer, length, &lastCell); + insert(env, text); + +#undef PUSH_BUFFER + free(buffer); + + return; +} +// Refresh the screen (visible part of the buffer when the terminal is +// focused) of a invalidated terminal +static void refresh_screen(Term *term, emacs_env *env) { + // Term height may have decreased before `invalid_end` reflects it. + term->invalid_end = MIN(term->invalid_end, term->height); + + if (term->invalid_end >= term->invalid_start) { + int startrow = -(term->height - term->invalid_start - term->linenum_added); + /* startrow is negative,so we backward -startrow lines from end of buffer + then delete lines there. + */ + goto_line(env, startrow); + delete_lines(env, startrow, term->invalid_end - term->invalid_start, true); + refresh_lines(term, env, term->invalid_start, term->invalid_end, + term->width); + + /* term->linenum_added is lines added by window height increased */ + term->linenum += term->linenum_added; + term->linenum_added = 0; + } + + term->invalid_start = INT_MAX; + term->invalid_end = -1; +} + +static int term_resize(int rows, int cols, void *user_data) { + /* can not use invalidate_terminal here */ + /* when the window height decreased, */ + /* the value of term->invalid_end can't bigger than window height */ + Term *term = (Term *)user_data; + term->invalid_start = 0; + term->invalid_end = rows; + + /* if rows=term->lines_len, that means term_sb_pop already resize term->lines + */ + /* if rowslines_len, term_sb_push would resize term->lines there */ + /* we noly need to take care of rows>term->height */ + + if (rows > term->height) { + if (rows > term->lines_len) { + LineInfo **infos = term->lines; + term->lines = malloc(sizeof(LineInfo *) * rows); + memmove(term->lines, infos, sizeof(infos[0]) * term->lines_len); + + LineInfo *lastline = term->lines[term->lines_len - 1]; + for (int i = term->lines_len; i < rows; i++) { + if (lastline != NULL) { + LineInfo *line = alloc_lineinfo(); + if (lastline->directory != NULL) { + line->directory = + malloc(1 + strlen(term->lines[term->lines_len - 1]->directory)); + strcpy(line->directory, + term->lines[term->lines_len - 1]->directory); + } + term->lines[i] = line; + } else { + term->lines[i] = NULL; + } + } + term->lines_len = rows; + free(infos); + } + } + + term->width = cols; + term->height = rows; + + invalidate_terminal(term, -1, -1); + term->resizing = false; + + return 1; +} + +// Refresh the scrollback of an invalidated terminal. +static void refresh_scrollback(Term *term, emacs_env *env) { + int max_line_count = (int)term->sb_current + term->height; + int del_cnt = 0; + if (term->sb_pending > 0) { + // This means that either the window height has decreased or the screen + // became full and libvterm had to push all rows up. Convert the first + // pending scrollback row into a string and append it just above the visible + // section of the buffer + + del_cnt = term->linenum - term->height - (int)term->sb_size + + term->sb_pending - term->sb_pending_by_height_decr; + if (del_cnt > 0) { + delete_lines(env, 1, del_cnt, true); + term->linenum -= del_cnt; + } + + term->linenum += term->sb_pending; + del_cnt = term->linenum - max_line_count; /* extra lines at the bottom */ + /* buf_index is negative,so we move to end of buffer,then backward + -buf_index lines. goto lines backward is effectively when + vterm-max-scrollback is a large number. + */ + int buf_index = -(term->height + del_cnt); + goto_line(env, buf_index); + refresh_lines(term, env, -term->sb_pending, 0, term->width); + + term->sb_pending = 0; + } + + // Remove extra lines at the bottom + del_cnt = term->linenum - max_line_count; + if (del_cnt > 0) { + term->linenum -= del_cnt; + /* -del_cnt is negative,so we delete_lines from end of buffer. + this line means: delete del_cnt count of lines at end of buffer. + */ + delete_lines(env, -del_cnt, del_cnt, true); + } + + term->sb_pending_by_height_decr = 0; + term->height_resize = 0; +} + +static void adjust_topline(Term *term, emacs_env *env) { + VTermState *state = vterm_obtain_state(term->vt); + VTermPos pos; + vterm_state_get_cursorpos(state, &pos); + + /* pos.row-term->height is negative,so we backward term->height-pos.row + * lines from end of buffer + */ + + goto_line(env, pos.row - term->height); + goto_col(term, env, pos.row, pos.col); + + emacs_value windows = get_buffer_window_list(env); + emacs_value swindow = selected_window(env); + int winnum = env->extract_integer(env, length(env, windows)); + for (int i = 0; i < winnum; i++) { + emacs_value window = nth(env, i, windows); + if (eq(env, window, swindow)) { + int win_body_height = + env->extract_integer(env, window_body_height(env, window)); + + /* recenter:If ARG is negative, it counts up from the bottom of the + * window. (ARG should be less than the height of the window ) */ + if (term->height - pos.row <= win_body_height) { + recenter(env, env->make_integer(env, pos.row - term->height)); + } else { + recenter(env, env->make_integer(env, pos.row)); + } + } else { + if (env->is_not_nil(env, window)) { + set_window_point(env, window, point(env)); + } + } + } +} + +static void invalidate_terminal(Term *term, int start_row, int end_row) { + if (start_row != -1 && end_row != -1) { + term->invalid_start = MIN(term->invalid_start, start_row); + term->invalid_end = MAX(term->invalid_end, end_row); + } + term->is_invalidated = true; +} + +static int term_damage(VTermRect rect, void *data) { + invalidate_terminal(data, rect.start_row, rect.end_row); + return 1; +} + +static int term_moverect(VTermRect dest, VTermRect src, void *data) { + invalidate_terminal(data, MIN(dest.start_row, src.start_row), + MAX(dest.end_row, src.end_row)); + return 1; +} + +static int term_movecursor(VTermPos new, VTermPos old, int visible, + void *data) { + Term *term = data; + term->cursor.row = new.row; + term->cursor.col = new.col; + invalidate_terminal(term, old.row, old.row + 1); + invalidate_terminal(term, new.row, new.row + 1); + + return 1; +} + +static void term_redraw_cursor(Term *term, emacs_env *env) { + if (term->cursor.cursor_blink_changed) { + term->cursor.cursor_blink_changed = false; + set_cursor_blink(env, term->cursor.cursor_blink); + } + + if (term->cursor.cursor_type_changed) { + term->cursor.cursor_type_changed = false; + + if (!term->cursor.cursor_visible) { + set_cursor_type(env, Qnil); + return; + } + + switch (term->cursor.cursor_type) { + case VTERM_PROP_CURSORSHAPE_BLOCK: + set_cursor_type(env, Qbox); + break; + case VTERM_PROP_CURSORSHAPE_UNDERLINE: + set_cursor_type(env, Qhbar); + break; + case VTERM_PROP_CURSORSHAPE_BAR_LEFT: + set_cursor_type(env, Qbar); + break; + default: + set_cursor_type(env, Qt); + break; + } + } +} + +static void term_redraw(Term *term, emacs_env *env) { + term_redraw_cursor(term, env); + + if (term->is_invalidated) { + int oldlinenum = term->linenum; + refresh_scrollback(term, env); + refresh_screen(term, env); + term->linenum_added = term->linenum - oldlinenum; + adjust_topline(term, env); + term->linenum_added = 0; + } + + if (term->title_changed) { + set_title(env, env->make_string(env, term->title, strlen(term->title))); + term->title_changed = false; + } + + if (term->directory_changed) { + set_directory( + env, env->make_string(env, term->directory, strlen(term->directory))); + term->directory_changed = false; + } + + while (term->elisp_code_first) { + ElispCodeListNode *node = term->elisp_code_first; + term->elisp_code_first = node->next; + emacs_value elisp_code = env->make_string(env, node->code, node->code_len); + vterm_eval(env, elisp_code); + + free(node->code); + free(node); + } + term->elisp_code_p_insert = &term->elisp_code_first; + + if (term->selection_data) { + emacs_value selection_target = env->make_string( + env, &term->selection_target[0], strlen(&term->selection_target[0])); + emacs_value selection_data = env->make_string(env, term->selection_data, + strlen(term->selection_data)); + vterm_selection(env, selection_target, selection_data); + free(term->selection_data); + term->selection_data = NULL; + } + + term->is_invalidated = false; +} + +static VTermScreenCallbacks vterm_screen_callbacks = { + .damage = term_damage, + .moverect = term_moverect, + .movecursor = term_movecursor, + .settermprop = term_settermprop, + .resize = term_resize, + .sb_pushline = term_sb_push, + .sb_popline = term_sb_pop, +}; + +static bool compare_cells(VTermScreenCell *a, VTermScreenCell *b) { + bool equal = true; + equal = equal && vterm_color_is_equal(&a->fg, &b->fg); + equal = equal && vterm_color_is_equal(&a->bg, &b->bg); + equal = equal && (a->attrs.bold == b->attrs.bold); + equal = equal && (a->attrs.underline == b->attrs.underline); + equal = equal && (a->attrs.italic == b->attrs.italic); + equal = equal && (a->attrs.reverse == b->attrs.reverse); + equal = equal && (a->attrs.strike == b->attrs.strike); + return equal; +} + +static bool is_key(unsigned char *key, size_t len, char *key_description) { + return (len == strlen(key_description) && + memcmp(key, key_description, len) == 0); +} + +/* str1=concat(str1,str2,str2_len,true); */ +/* str1 can be NULL */ +static char *concat(char *str1, const char *str2, size_t str2_len, + bool free_str1) { + if (str1 == NULL) { + str1 = malloc(str2_len + 1); + memcpy(str1, str2, str2_len); + str1[str2_len] = '\0'; + return str1; + } + size_t str1_len = strlen(str1); + char *buf = malloc(str1_len + str2_len + 1); + memcpy(buf, str1, str1_len); + memcpy(&buf[str1_len], str2, str2_len); + buf[str1_len + str2_len] = '\0'; + if (free_str1) { + free(str1); + } + return buf; +} +static void term_set_title(Term *term, const char *title, size_t len, + bool initial, bool final) { + if (term->title && initial) { + free(term->title); + term->title = NULL; + term->title_changed = false; + } + term->title = concat(term->title, title, len, true); + if (final) { + term->title_changed = true; + } + return; +} + +static int term_settermprop(VTermProp prop, VTermValue *val, void *user_data) { + Term *term = (Term *)user_data; + switch (prop) { + case VTERM_PROP_CURSORVISIBLE: + invalidate_terminal(term, term->cursor.row, term->cursor.row + 1); + term->cursor.cursor_visible = val->boolean; + term->cursor.cursor_type_changed = true; + break; + case VTERM_PROP_CURSORBLINK: + if (term->ignore_blink_cursor) + break; + invalidate_terminal(term, term->cursor.row, term->cursor.row + 1); + term->cursor.cursor_blink = val->boolean; + term->cursor.cursor_blink_changed = true; + break; + case VTERM_PROP_CURSORSHAPE: + invalidate_terminal(term, term->cursor.row, term->cursor.row + 1); + term->cursor.cursor_type = val->number; + term->cursor.cursor_type_changed = true; + break; + case VTERM_PROP_TITLE: +#ifdef VTermStringFragmentNotExists + term_set_title(term, val->string, strlen(val->string), true, true); +#else + term_set_title(term, val->string.str, val->string.len, val->string.initial, + val->string.final); +#endif + break; + case VTERM_PROP_ALTSCREEN: + invalidate_terminal(term, 0, term->height); + break; + default: + return 0; + } + + return 1; +} + +static emacs_value render_text(emacs_env *env, Term *term, char *buffer, + int len, VTermScreenCell *cell) { + emacs_value text; + if (len == 0) { + text = env->make_string(env, "", 0); + return text; + } else { + text = env->make_string(env, buffer, len); + } + + emacs_value fg = cell_rgb_color(env, term, cell, true); + emacs_value bg = cell_rgb_color(env, term, cell, false); + /* With vterm-disable-bold-font, vterm-disable-underline, + * vterm-disable-inverse-video, users can disable some text properties. + * Here, we check whether the text would require adding such properties. + * In case it does, and the user does not disable the attribute, we later + * append the property to the list props. If the text does not require + * such property, or the user disable it, we set the variable to nil. + * Properties that are marked as nil are not added to the text. */ + emacs_value bold = + cell->attrs.bold && !term->disable_bold_font ? Qbold : Qnil; + emacs_value underline = + cell->attrs.underline && !term->disable_underline ? Qt : Qnil; + emacs_value italic = cell->attrs.italic ? Qitalic : Qnil; + emacs_value reverse = + cell->attrs.reverse && !term->disable_inverse_video ? Qt : Qnil; + emacs_value strike = cell->attrs.strike ? Qt : Qnil; + + // TODO: Blink, font, dwl, dhl is missing + int emacs_major_version = + env->extract_integer(env, symbol_value(env, Qemacs_major_version)); + emacs_value properties; + emacs_value props[64]; + int props_len = 0; + if (env->is_not_nil(env, fg)) + props[props_len++] = Qforeground, props[props_len++] = fg; + if (env->is_not_nil(env, bg)) + props[props_len++] = Qbackground, props[props_len++] = bg; + if (bold != Qnil) + props[props_len++] = Qweight, props[props_len++] = bold; + if (underline != Qnil) + props[props_len++] = Qunderline, props[props_len++] = underline; + if (italic != Qnil) + props[props_len++] = Qslant, props[props_len++] = italic; + if (reverse != Qnil) + props[props_len++] = Qreverse, props[props_len++] = reverse; + if (strike != Qnil) + props[props_len++] = Qstrike, props[props_len++] = strike; + if (emacs_major_version >= 27) + props[props_len++] = Qextend, props[props_len++] = Qt; + + properties = list(env, props, props_len); + + if (props_len) + put_text_property(env, text, Qface, properties); + + return text; +} +static emacs_value render_prompt(emacs_env *env, emacs_value text) { + + emacs_value properties; + + properties = + list(env, (emacs_value[]){Qvterm_prompt, Qt, Qrear_nonsticky, Qt}, 4); + + add_text_properties(env, text, properties); + + return text; +} + +static emacs_value render_fake_newline(emacs_env *env, Term *term) { + + emacs_value text; + text = env->make_string(env, "\n", 1); + + emacs_value properties; + + properties = + list(env, (emacs_value[]){Qvterm_line_wrap, Qt, Qrear_nonsticky, Qt}, 4); + + add_text_properties(env, text, properties); + + return text; +} + +static emacs_value cell_rgb_color(emacs_env *env, Term *term, + VTermScreenCell *cell, bool is_foreground) { + VTermColor *color = is_foreground ? &cell->fg : &cell->bg; + + /** NOTE: -10 is used as index offset for special indexes, + * see C-h f vterm--get-color RET + */ + if (VTERM_COLOR_IS_DEFAULT_FG(color)) { + return vterm_get_color(env, -1 + (cell->attrs.underline ? -10 : 0)); + } + if (VTERM_COLOR_IS_DEFAULT_BG(color)) { + return vterm_get_color(env, -2 + (cell->attrs.reverse ? -10 : 0)); + } + if (VTERM_COLOR_IS_INDEXED(color)) { + if (color->indexed.idx < 16) { + return vterm_get_color(env, color->indexed.idx); + } else { + VTermState *state = vterm_obtain_state(term->vt); + vterm_state_get_palette_color(state, color->indexed.idx, color); + } + } else if (VTERM_COLOR_IS_RGB(color)) { + /* do nothing just use the argument color directly */ + } + + char buffer[8]; + snprintf(buffer, 8, "#%02X%02X%02X", color->rgb.red, color->rgb.green, + color->rgb.blue); + return env->make_string(env, buffer, 7); +} + +static void term_flush_output(Term *term, emacs_env *env) { + size_t len = vterm_output_get_buffer_current(term->vt); + if (len) { + char buffer[len]; + len = vterm_output_read(term->vt, buffer, len); + + emacs_value output = env->make_string(env, buffer, len); + env->funcall(env, Fvterm_flush_output, 1, (emacs_value[]){output}); + } +} + +static void term_clear_scrollback(Term *term, emacs_env *env) { + vterm_screen_flush_damage(term->vts); + term_redraw(term, env); + if (term->sb_pending > 0) { // Pending rows must be processed first. + return; + } + for (int i = 0; i < term->sb_current; i++) { + if (term->sb_buffer[i]->info != NULL) { + free_lineinfo(term->sb_buffer[i]->info); + term->sb_buffer[i]->info = NULL; + } + free(term->sb_buffer[i]); + } + free(term->sb_buffer); + term->sb_buffer = malloc(sizeof(ScrollbackLine *) * term->sb_size); + delete_lines(env, 1, term->sb_current, true); + term->linenum -= term->sb_current; + term->sb_current = 0; +} +static void term_process_key(Term *term, emacs_env *env, unsigned char *key, + size_t len, VTermModifier modifier) { + if (is_key(key, len, "")) { + term_clear_scrollback(term, env); + } else if (is_key(key, len, "")) { + tcflow(term->pty_fd, TCOON); + } else if (is_key(key, len, "")) { + tcflow(term->pty_fd, TCOOFF); + } else if (is_key(key, len, "")) { + vterm_keyboard_start_paste(term->vt); + } else if (is_key(key, len, "")) { + vterm_keyboard_end_paste(term->vt); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_TAB, modifier); + } else if (is_key(key, len, "") || + is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_TAB, VTERM_MOD_SHIFT); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_BACKSPACE, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_ESCAPE, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_UP, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_DOWN, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_LEFT, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_RIGHT, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_INS, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_DEL, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_HOME, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_END, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_PAGEUP, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_PAGEDOWN, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(0), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(1), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(2), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(3), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(4), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(5), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(6), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(7), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(8), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(9), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(10), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(11), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_FUNCTION(12), modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_0, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_1, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_2, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_3, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_4, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_5, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_6, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_7, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_8, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_9, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_PLUS, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_MINUS, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_MULT, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_DIVIDE, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_EQUAL, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_PERIOD, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_COMMA, modifier); + } else if (is_key(key, len, "")) { + vterm_keyboard_key(term->vt, VTERM_KEY_KP_ENTER, modifier); + } else if (is_key(key, len, "j") && (modifier == VTERM_MOD_CTRL)) { + vterm_keyboard_unichar(term->vt, '\n', 0); + } else if (is_key(key, len, "SPC")) { + vterm_keyboard_unichar(term->vt, ' ', modifier); + } else if (len <= 4) { + uint32_t codepoint; + if (utf8_to_codepoint(key, len, &codepoint)) { + vterm_keyboard_unichar(term->vt, codepoint, modifier); + } + } +} + +void term_finalize(void *object) { + Term *term = (Term *)object; + for (int i = 0; i < term->sb_current; i++) { + if (term->sb_buffer[i]->info != NULL) { + free_lineinfo(term->sb_buffer[i]->info); + term->sb_buffer[i]->info = NULL; + } + free(term->sb_buffer[i]); + } + if (term->title) { + free(term->title); + term->title = NULL; + } + + if (term->directory) { + free(term->directory); + term->directory = NULL; + } + + while (term->elisp_code_first) { + ElispCodeListNode *node = term->elisp_code_first; + term->elisp_code_first = node->next; + free(node->code); + free(node); + } + term->elisp_code_p_insert = &term->elisp_code_first; + + if (term->cmd_buffer) { + free(term->cmd_buffer); + term->cmd_buffer = NULL; + } + if (term->selection_data) { + free(term->selection_data); + term->selection_data = NULL; + } + + for (int i = 0; i < term->lines_len; i++) { + if (term->lines[i] != NULL) { + free_lineinfo(term->lines[i]); + term->lines[i] = NULL; + } + } + + if (term->pty_fd > 0) { + close(term->pty_fd); + } + + free(term->sb_buffer); + free(term->lines); + vterm_free(term->vt); + free(term); +} + +static int handle_osc_cmd_51(Term *term, char subCmd, char *buffer) { + if (subCmd == 'A') { + /* "51;A" sets the current directory */ + /* "51;A" has also the role of identifying the end of the prompt */ + if (term->directory != NULL) { + free(term->directory); + term->directory = NULL; + } + term->directory = malloc(strlen(buffer) + 1); + strcpy(term->directory, buffer); + term->directory_changed = true; + + for (int i = term->cursor.row; i < term->lines_len; i++) { + if (term->lines[i] == NULL) { + term->lines[i] = alloc_lineinfo(); + } + + if (term->lines[i]->directory != NULL) { + free(term->lines[i]->directory); + } + term->lines[i]->directory = malloc(strlen(buffer) + 1); + strcpy(term->lines[i]->directory, buffer); + if (i == term->cursor.row) { + term->lines[i]->prompt_col = term->cursor.col; + } else { + term->lines[i]->prompt_col = -1; + } + } + return 1; + } else if (subCmd == 'E') { + /* "51;E" executes elisp code */ + /* The elisp code is executed in term_redraw */ + ElispCodeListNode *node = malloc(sizeof(ElispCodeListNode)); + node->code_len = strlen(buffer); + node->code = malloc(node->code_len + 1); + strcpy(node->code, buffer); + node->next = NULL; + + *(term->elisp_code_p_insert) = node; + term->elisp_code_p_insert = &(node->next); + return 1; + } + return 0; +} +static int handle_osc_cmd_52(Term *term, char *buffer) { + /* OSC 52 ; Pc ; Pd BEL */ + /* Manipulate Selection Data */ + /* https://invisible-island.net/xterm/ctlseqs/ctlseqs.html */ + /* test by printf "\033]52;c;$(printf "%s" "blabla" | base64)\a" */ + + for (int i = 0; i < SELECTION_TARGET_MAX; i++) { /* reset Pc */ + term->selection_target[i] = 0; + } + int selection_target_idx = 0; + size_t cmdlen = strlen(buffer); + + for (int i = 0; i < cmdlen; i++) { + /* OSC 52 ; Pc ; Pd BEL */ + if (buffer[i] == ';') { /* find the second ";" */ + term->selection_data = malloc(cmdlen - i); + strcpy(term->selection_data, &buffer[i + 1]); + break; + } + if (selection_target_idx < SELECTION_TARGET_MAX) { + /* c , p , q , s , 0 , 1 , 2 , 3 , 4 , 5 , 6 , and 7 */ + /* for clipboard, primary, secondary, select, or cut buffers 0 through 7 + * respectively */ + term->selection_target[selection_target_idx] = buffer[i]; + selection_target_idx++; + } else { /* len of Pc should not >12 just ignore this cmd,am I wrong? */ + return 0; + } + } + return 1; +} +static int handle_osc_cmd(Term *term, int cmd, char *buffer) { + if (cmd == 51) { + char subCmd = '0'; + if (strlen(buffer) == 0) { + return 0; + } + subCmd = buffer[0]; + /* ++ skip the subcmd char */ + return handle_osc_cmd_51(term, subCmd, ++buffer); + } else if (cmd == 52) { + return handle_osc_cmd_52(term, buffer); + } + return 0; +} +#ifdef VTermStringFragmentNotExists +static int osc_callback(const char *command, size_t cmdlen, void *user) { + Term *term = (Term *)user; + char buffer[cmdlen + 1]; + buffer[cmdlen] = '\0'; + memcpy(buffer, command, cmdlen); + + if (cmdlen > 4 && buffer[0] == '5' && buffer[1] == '1' && buffer[2] == ';' && + buffer[3] == 'A') { + return handle_osc_cmd_51(term, 'A', &buffer[4]); + } else if (cmdlen > 4 && buffer[0] == '5' && buffer[1] == '1' && + buffer[2] == ';' && buffer[3] == 'E') { + return handle_osc_cmd_51(term, 'E', &buffer[4]); + } else if (cmdlen > 4 && buffer[0] == '5' && buffer[1] == '2' && + buffer[2] == ';') { + /* OSC 52 ; Pc ; Pd BEL */ + return handle_osc_cmd_52(term, &buffer[3]); + } + return 0; +} +static VTermParserCallbacks parser_callbacks = { + .text = NULL, + .control = NULL, + .escape = NULL, + .csi = NULL, + .osc = &osc_callback, + .dcs = NULL, +}; +#else + +static int osc_callback(int cmd, VTermStringFragment frag, void *user) { + /* osc_callback (OSC = Operating System Command) */ + + /* We interpret escape codes that start with "51;" */ + /* "51;A" sets the current directory */ + /* "51;A" has also the role of identifying the end of the prompt */ + /* "51;E" executes elisp code */ + /* The elisp code is executed in term_redraw */ + + /* "52;[cpqs01234567];data" Manipulate Selection Data */ + /* I think libvterm has bug ,sometimes when the data is long enough ,the final + * fragment is missed */ + /* printf "\033]52;c;$(printf "%s" $(ruby -e 'print "x"*999999')|base64)\a" + */ + + Term *term = (Term *)user; + + if (frag.initial) { + /* drop old fragment,because this is a initial fragment */ + if (term->cmd_buffer) { + free(term->cmd_buffer); + term->cmd_buffer = NULL; + } + } + + if (!frag.initial && !frag.final && frag.len == 0) { + return 0; + } + + term->cmd_buffer = concat(term->cmd_buffer, frag.str, frag.len, true); + if (frag.final) { + handle_osc_cmd(term, cmd, term->cmd_buffer); + free(term->cmd_buffer); + term->cmd_buffer = NULL; + } + return 0; +} +static VTermStateFallbacks parser_callbacks = { + .control = NULL, + .csi = NULL, + .osc = &osc_callback, + .dcs = NULL, +}; + +#endif + +emacs_value Fvterm_new(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) { + Term *term = malloc(sizeof(Term)); + + int rows = env->extract_integer(env, args[0]); + int cols = env->extract_integer(env, args[1]); + int sb_size = env->extract_integer(env, args[2]); + int disable_bold_font = env->is_not_nil(env, args[3]); + int disable_underline = env->is_not_nil(env, args[4]); + int disable_inverse_video = env->is_not_nil(env, args[5]); + int ignore_blink_cursor = env->is_not_nil(env, args[6]); + int set_bold_hightbright = env->is_not_nil(env, args[7]); + + term->vt = vterm_new(rows, cols); + vterm_set_utf8(term->vt, 1); + + term->vts = vterm_obtain_screen(term->vt); + + VTermState *state = vterm_obtain_state(term->vt); + vterm_state_set_unrecognised_fallbacks(state, &parser_callbacks, term); + vterm_state_set_bold_highbright(state, set_bold_hightbright); + + vterm_screen_reset(term->vts, 1); + vterm_screen_set_callbacks(term->vts, &vterm_screen_callbacks, term); + vterm_screen_set_damage_merge(term->vts, VTERM_DAMAGE_SCROLL); + vterm_screen_enable_altscreen(term->vts, true); + term->sb_size = MIN(SB_MAX, sb_size); + term->sb_current = 0; + term->sb_pending = 0; + term->sb_pending_by_height_decr = 0; + term->sb_buffer = malloc(sizeof(ScrollbackLine *) * term->sb_size); + term->invalid_start = 0; + term->invalid_end = rows; + term->width = cols; + term->height = rows; + term->height_resize = 0; + term->disable_bold_font = disable_bold_font; + term->disable_underline = disable_underline; + term->disable_inverse_video = disable_inverse_video; + term->ignore_blink_cursor = ignore_blink_cursor; + emacs_value newline = env->make_string(env, "\n", 1); + for (int i = 0; i < term->height; i++) { + insert(env, newline); + } + term->linenum = term->height; + term->linenum_added = 0; + term->resizing = false; + + term->pty_fd = -1; + + term->title = NULL; + term->title_changed = false; + + term->cursor.row = 0; + term->cursor.col = 0; + term->cursor.cursor_type = -1; + term->cursor.cursor_visible = true; + term->cursor.cursor_type_changed = false; + term->cursor.cursor_blink = false; + term->cursor.cursor_blink_changed = false; + term->directory = NULL; + term->directory_changed = false; + term->elisp_code_first = NULL; + term->elisp_code_p_insert = &term->elisp_code_first; + term->selection_data = NULL; + + term->cmd_buffer = NULL; + + term->lines = malloc(sizeof(LineInfo *) * rows); + term->lines_len = rows; + for (int i = 0; i < rows; i++) { + term->lines[i] = NULL; + } + + return env->make_user_ptr(env, term_finalize, term); +} + +emacs_value Fvterm_update(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) { + Term *term = env->get_user_ptr(env, args[0]); + + // Process keys + if (nargs > 1) { + ptrdiff_t len = string_bytes(env, args[1]); + unsigned char key[len]; + env->copy_string_contents(env, args[1], (char *)key, &len); + VTermModifier modifier = VTERM_MOD_NONE; + if (nargs > 2 && env->is_not_nil(env, args[2])) + modifier = modifier | VTERM_MOD_SHIFT; + if (nargs > 3 && env->is_not_nil(env, args[3])) + modifier = modifier | VTERM_MOD_ALT; + if (nargs > 4 && env->is_not_nil(env, args[4])) + modifier = modifier | VTERM_MOD_CTRL; + + // Ignore the final zero byte + term_process_key(term, env, key, len - 1, modifier); + } + + // Flush output + term_flush_output(term, env); + if (term->is_invalidated) { + vterm_invalidate(env); + } + + return env->make_integer(env, 0); +} + +emacs_value Fvterm_redraw(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) { + Term *term = env->get_user_ptr(env, args[0]); + term_redraw(term, env); + return env->make_integer(env, 0); +} + +emacs_value Fvterm_write_input(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data) { + Term *term = env->get_user_ptr(env, args[0]); + ptrdiff_t len = string_bytes(env, args[1]); + char bytes[len]; + + env->copy_string_contents(env, args[1], bytes, &len); + + vterm_input_write(term->vt, bytes, len); + vterm_screen_flush_damage(term->vts); + + return env->make_integer(env, 0); +} + +emacs_value Fvterm_set_size(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) { + Term *term = env->get_user_ptr(env, args[0]); + int rows = env->extract_integer(env, args[1]); + int cols = env->extract_integer(env, args[2]); + + if (cols != term->width || rows != term->height) { + term->height_resize = rows - term->height; + if (rows > term->height) { + if (rows - term->height > term->sb_current) { + term->linenum_added = rows - term->height - term->sb_current; + } + } + term->resizing = true; + vterm_set_size(term->vt, rows, cols); + vterm_screen_flush_damage(term->vts); + + term_redraw(term, env); + } + + return Qnil; +} + +emacs_value Fvterm_set_pty_name(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data) { + Term *term = env->get_user_ptr(env, args[0]); + + if (nargs > 1) { + ptrdiff_t len = string_bytes(env, args[1]); + char filename[len]; + + env->copy_string_contents(env, args[1], filename, &len); + + term->pty_fd = open(filename, O_RDONLY); + } + return Qnil; +} +emacs_value Fvterm_get_pwd(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) { + Term *term = env->get_user_ptr(env, args[0]); + int linenum = env->extract_integer(env, args[1]); + int row = linenr_to_row(term, linenum); + char *dir = get_row_directory(term, row); + + return dir ? env->make_string(env, dir, strlen(dir)) : Qnil; +} + +emacs_value Fvterm_get_icrnl(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data) { + Term *term = env->get_user_ptr(env, args[0]); + + if (term->pty_fd > 0) { + struct termios keys; + tcgetattr(term->pty_fd, &keys); + + if (keys.c_iflag & ICRNL) + return Qt; + else + return Qnil; + } + return Qnil; +} + +emacs_value Fvterm_reset_cursor_point(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data) { + Term *term = env->get_user_ptr(env, args[0]); + int line = row_to_linenr(term, term->cursor.row); + goto_line(env, line); + goto_col(term, env, term->cursor.row, term->cursor.col); + return point(env); +} + +int emacs_module_init(struct emacs_runtime *ert) { + emacs_env *env = ert->get_environment(ert); + + // Symbols; + Qt = env->make_global_ref(env, env->intern(env, "t")); + Qnil = env->make_global_ref(env, env->intern(env, "nil")); + Qnormal = env->make_global_ref(env, env->intern(env, "normal")); + Qbold = env->make_global_ref(env, env->intern(env, "bold")); + Qitalic = env->make_global_ref(env, env->intern(env, "italic")); + Qforeground = env->make_global_ref(env, env->intern(env, ":foreground")); + Qbackground = env->make_global_ref(env, env->intern(env, ":background")); + Qweight = env->make_global_ref(env, env->intern(env, ":weight")); + Qunderline = env->make_global_ref(env, env->intern(env, ":underline")); + Qslant = env->make_global_ref(env, env->intern(env, ":slant")); + Qreverse = env->make_global_ref(env, env->intern(env, ":inverse-video")); + Qstrike = env->make_global_ref(env, env->intern(env, ":strike-through")); + Qextend = env->make_global_ref(env, env->intern(env, ":extend")); + Qemacs_major_version = + env->make_global_ref(env, env->intern(env, "emacs-major-version")); + Qvterm_line_wrap = + env->make_global_ref(env, env->intern(env, "vterm-line-wrap")); + Qrear_nonsticky = + env->make_global_ref(env, env->intern(env, "rear-nonsticky")); + Qvterm_prompt = env->make_global_ref(env, env->intern(env, "vterm-prompt")); + + Qface = env->make_global_ref(env, env->intern(env, "font-lock-face")); + Qbox = env->make_global_ref(env, env->intern(env, "box")); + Qbar = env->make_global_ref(env, env->intern(env, "bar")); + Qhbar = env->make_global_ref(env, env->intern(env, "hbar")); + Qcursor_type = env->make_global_ref(env, env->intern(env, "cursor-type")); + + // Functions + Fblink_cursor_mode = + env->make_global_ref(env, env->intern(env, "blink-cursor-mode")); + Fsymbol_value = env->make_global_ref(env, env->intern(env, "symbol-value")); + Flength = env->make_global_ref(env, env->intern(env, "length")); + Flist = env->make_global_ref(env, env->intern(env, "list")); + Fnth = env->make_global_ref(env, env->intern(env, "nth")); + Ferase_buffer = env->make_global_ref(env, env->intern(env, "erase-buffer")); + Finsert = env->make_global_ref(env, env->intern(env, "vterm--insert")); + Fgoto_char = env->make_global_ref(env, env->intern(env, "goto-char")); + Fput_text_property = + env->make_global_ref(env, env->intern(env, "put-text-property")); + Fadd_text_properties = + env->make_global_ref(env, env->intern(env, "add-text-properties")); + Fset = env->make_global_ref(env, env->intern(env, "set")); + Fvterm_flush_output = + env->make_global_ref(env, env->intern(env, "vterm--flush-output")); + Fforward_line = env->make_global_ref(env, env->intern(env, "forward-line")); + Fgoto_line = env->make_global_ref(env, env->intern(env, "vterm--goto-line")); + Fdelete_lines = + env->make_global_ref(env, env->intern(env, "vterm--delete-lines")); + Frecenter = env->make_global_ref(env, env->intern(env, "recenter")); + Fset_window_point = + env->make_global_ref(env, env->intern(env, "set-window-point")); + Fwindow_body_height = + env->make_global_ref(env, env->intern(env, "window-body-height")); + + Fpoint = env->make_global_ref(env, env->intern(env, "point")); + Fforward_char = env->make_global_ref(env, env->intern(env, "forward-char")); + Fget_buffer_window_list = + env->make_global_ref(env, env->intern(env, "get-buffer-window-list")); + Fselected_window = + env->make_global_ref(env, env->intern(env, "selected-window")); + + Fvterm_set_title = + env->make_global_ref(env, env->intern(env, "vterm--set-title")); + Fvterm_set_directory = + env->make_global_ref(env, env->intern(env, "vterm--set-directory")); + Fvterm_invalidate = + env->make_global_ref(env, env->intern(env, "vterm--invalidate")); + Feq = env->make_global_ref(env, env->intern(env, "eq")); + Fvterm_get_color = + env->make_global_ref(env, env->intern(env, "vterm--get-color")); + Fvterm_eval = env->make_global_ref(env, env->intern(env, "vterm--eval")); + Fvterm_selection = + env->make_global_ref(env, env->intern(env, "vterm--selection")); + + // Exported functions + emacs_value fun; + fun = + env->make_function(env, 4, 8, Fvterm_new, "Allocate a new vterm.", NULL); + bind_function(env, "vterm--new", fun); + + fun = env->make_function(env, 1, 5, Fvterm_update, + "Process io and update the screen.", NULL); + bind_function(env, "vterm--update", fun); + + fun = + env->make_function(env, 1, 1, Fvterm_redraw, "Redraw the screen.", NULL); + bind_function(env, "vterm--redraw", fun); + + fun = env->make_function(env, 2, 2, Fvterm_write_input, + "Write input to vterm.", NULL); + bind_function(env, "vterm--write-input", fun); + + fun = env->make_function(env, 3, 3, Fvterm_set_size, + "Set the size of the terminal.", NULL); + bind_function(env, "vterm--set-size", fun); + + fun = env->make_function(env, 2, 2, Fvterm_set_pty_name, + "Set the name of the pty.", NULL); + bind_function(env, "vterm--set-pty-name", fun); + fun = env->make_function(env, 2, 2, Fvterm_get_pwd, + "Get the working directory of at line n.", NULL); + bind_function(env, "vterm--get-pwd-raw", fun); + fun = env->make_function(env, 1, 1, Fvterm_reset_cursor_point, + "Reset cursor postion.", NULL); + bind_function(env, "vterm--reset-point", fun); + + fun = env->make_function(env, 1, 1, Fvterm_get_icrnl, + "Get the icrnl state of the pty", NULL); + bind_function(env, "vterm--get-icrnl", fun); + + provide(env, "vterm-module"); + + return 0; +} diff --git a/lisp/vterm/vterm-module.h b/lisp/vterm/vterm-module.h new file mode 100644 index 00000000..96f538f6 --- /dev/null +++ b/lisp/vterm/vterm-module.h @@ -0,0 +1,167 @@ +#ifndef VTERM_MODULE_H +#define VTERM_MODULE_H + +#include "emacs-module.h" +#include +#include +#include + +// https://gcc.gnu.org/wiki/Visibility +#if defined _WIN32 || defined __CYGWIN__ + #ifdef __GNUC__ + #define VTERM_EXPORT __attribute__ ((dllexport)) + #else + #define VTERM_EXPORT __declspec(dllexport) + #endif +#else + #if __GNUC__ >= 4 + #define VTERM_EXPORT __attribute__ ((visibility ("default"))) + #else + #define VTERM_EXPORT + #endif +#endif + +VTERM_EXPORT int plugin_is_GPL_compatible; + +#define SB_MAX 100000 // Maximum 'scrollback' value. + +#ifndef MIN +#define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) +#endif +#ifndef MAX +#define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) +#endif + +typedef struct LineInfo { + char *directory; /* working directory */ + + int prompt_col; /* end column of the prompt, if the current line contains the + * prompt */ +} LineInfo; + +typedef struct ScrollbackLine { + size_t cols; + LineInfo *info; + VTermScreenCell cells[]; +} ScrollbackLine; + +typedef struct ElispCodeListNode { + char *code; + size_t code_len; + struct ElispCodeListNode *next; +} ElispCodeListNode; + +/* c , p , q , s , 0 , 1 , 2 , 3 , 4 , 5 , 6 , and 7 */ +/* clipboard, primary, secondary, select, or cut buffers 0 through 7 */ +#define SELECTION_TARGET_MAX 12 + +typedef struct Cursor { + int row, col; + int cursor_type; + bool cursor_visible; + bool cursor_blink; + bool cursor_type_changed; + bool cursor_blink_changed; +} Cursor; + +typedef struct Term { + VTerm *vt; + VTermScreen *vts; + // buffer used to: + // - convert VTermScreen cell arrays into utf8 strings + // - receive data from libvterm as a result of key presses. + ScrollbackLine **sb_buffer; // Scrollback buffer storage for libvterm + size_t sb_current; // number of rows pushed to sb_buffer + size_t sb_size; // sb_buffer size + // "virtual index" that points to the first sb_buffer row that we need to + // push to the terminal buffer when refreshing the scrollback. When negative, + // it actually points to entries that are no longer in sb_buffer (because the + // window height has increased) and must be deleted from the terminal buffer + int sb_pending; + int sb_pending_by_height_decr; + long linenum; + long linenum_added; + + int invalid_start, invalid_end; // invalid rows in libvterm screen + bool is_invalidated; + + Cursor cursor; + char *title; + bool title_changed; + + char *directory; + bool directory_changed; + + // Single-linked list of elisp_code. + // Newer commands are added at the tail. + ElispCodeListNode *elisp_code_first; + ElispCodeListNode **elisp_code_p_insert; // pointer to the position where new + // node should be inserted + + /* c , p , q , s , 0 , 1 , 2 , 3 , 4 , 5 , 6 , and 7 */ + /* clipboard, primary, secondary, select, or cut buffers 0 through 7 */ + char selection_target[SELECTION_TARGET_MAX]; + char *selection_data; + + /* the size of dirs almost = window height, value = directory of that line */ + LineInfo **lines; + int lines_len; + + int width, height; + int height_resize; + bool resizing; + bool disable_bold_font; + bool disable_underline; + bool disable_inverse_video; + bool ignore_blink_cursor; + + char *cmd_buffer; + + int pty_fd; +} Term; + +static bool compare_cells(VTermScreenCell *a, VTermScreenCell *b); +static bool is_key(unsigned char *key, size_t len, char *key_description); +static emacs_value render_text(emacs_env *env, Term *term, char *string, + int len, VTermScreenCell *cell); +static emacs_value render_fake_newline(emacs_env *env, Term *term); +static emacs_value render_prompt(emacs_env *env, emacs_value text); +static emacs_value cell_rgb_color(emacs_env *env, Term *term, + VTermScreenCell *cell, bool is_foreground); + +static int term_settermprop(VTermProp prop, VTermValue *val, void *user_data); + +static void term_redraw(Term *term, emacs_env *env); +static void term_flush_output(Term *term, emacs_env *env); +static void term_process_key(Term *term, emacs_env *env, unsigned char *key, + size_t len, VTermModifier modifier); +static void invalidate_terminal(Term *term, int start_row, int end_row); + +void term_finalize(void *object); + +emacs_value Fvterm_new(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data); +emacs_value Fvterm_update(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data); +emacs_value Fvterm_redraw(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data); +emacs_value Fvterm_write_input(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data); +emacs_value Fvterm_set_size(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data); +emacs_value Fvterm_set_pty_name(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data); +emacs_value Fvterm_get_icrnl(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data); + +emacs_value Fvterm_get_pwd(emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data); + +emacs_value Fvterm_get_prompt_point(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data); +emacs_value Fvterm_reset_cursor_point(emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data); + +VTERM_EXPORT int emacs_module_init(struct emacs_runtime *ert); + +#endif /* VTERM_MODULE_H */ diff --git a/lisp/vterm/vterm-pkg.el b/lisp/vterm/vterm-pkg.el new file mode 100644 index 00000000..b8beea03 --- /dev/null +++ b/lisp/vterm/vterm-pkg.el @@ -0,0 +1,12 @@ +(define-package "vterm" "20211226.817" "Fully-featured terminal emulator" + '((emacs "25.1")) + :commit "a940dd2ee8a82684860e320c0f6d5e15d31d916f" :authors + '(("Lukas Fürmetz" . "fuermetz@mailbox.org")) + :maintainer + '("Lukas Fürmetz" . "fuermetz@mailbox.org") + :keywords + '("terminals") + :url "https://github.com/akermu/emacs-libvterm") +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/lisp/vterm/vterm.el b/lisp/vterm/vterm.el new file mode 100644 index 00000000..27d81097 --- /dev/null +++ b/lisp/vterm/vterm.el @@ -0,0 +1,1689 @@ +;;; vterm.el --- Fully-featured terminal emulator -*- lexical-binding: t; -*- + +;; Copyright (C) 2017-2020 by Lukas Fürmetz & Contributors +;; +;; Author: Lukas Fürmetz +;; Version: 0.0.1 +;; URL: https://github.com/akermu/emacs-libvterm +;; Keywords: terminals +;; Package-Requires: ((emacs "25.1")) + + +;; This file is not part of GNU Emacs. + +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; This file is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + + +;;; Commentary: +;; +;; Emacs-libvterm (vterm) is fully-fledged terminal emulator based on an +;; external library (libvterm) loaded as a dynamic module. As a result of using +;; compiled code (instead of elisp), emacs-libvterm is fully capable, fast, and +;; it can seamlessly handle large outputs. + +;;; Installation + +;; Emacs-libvterm requires support for loading modules. You can check if your +;; Emacs supports modules by inspecting the variable module-file-suffix. If it +;; nil, than, you need to recompile Emacs or obtain a copy of Emacs with this +;; option enabled. + +;; Emacs-libvterm requires CMake and libvterm. If libvterm is not available, +;; emacs-libvterm will downloaded and compiled. In this case, libtool is +;; needed. + +;; The reccomended way to install emacs-libvterm is from MELPA. + +;;; Usage + +;; To open a terminal, simply use the command M-x vterm. + +;;; Tips and tricks + +;; Adding some shell-side configuration enables a large set of additional +;; features, including, directory tracking, prompt recognition, message passing. + +;;; Code: + +(require 'term/xterm) + +(unless module-file-suffix + (error "VTerm needs module support. Please compile Emacs with + the --with-modules option!")) + +;;; Compilation of the module + +(defcustom vterm-module-cmake-args "" + "Arguments given to CMake to compile vterm-module. + +Currently, vterm defines the following flags (in addition to the +ones already available in CMake): + +`USE_SYSTEM_LIBVTERM'. Set it to `Off' to use the vendored version of +libvterm instead of the one installed on your system. + +This string is given verbatim to CMake, so it has to have the +correct syntax. An example of meaningful value for this variable +is `-DUSE_SYSTEM_LIBVTERM=Off'." + :type 'string + :group 'vterm) + +(defcustom vterm-always-compile-module nil + "If not nil, if `vterm-module' is not found, compile it without asking. + +When `vterm-always-compile-module' is nil, vterm will ask for +confirmation before compiling." + :type 'boolean + :group 'vterm) + +(defvar vterm-install-buffer-name " *Install vterm* " + "Name of the buffer used for compiling vterm-module.") + +(defun vterm-module--cmake-is-available () + "Return t if cmake is available. +CMake is needed to build vterm, here we check that we can find +the executable." + + (unless (executable-find "cmake") + (error "Vterm needs CMake to be compiled. Please, install CMake")) + t) + +;;;###autoload +(defun vterm-module-compile () + "Compile vterm-module." + (interactive) + (when (vterm-module--cmake-is-available) + (let* ((vterm-directory + (shell-quote-argument + ;; NOTE: This is a workaround to fix an issue with how the Emacs + ;; feature/native-comp branch changes the result of + ;; `(locate-library "vterm")'. See emacs-devel thread + ;; https://lists.gnu.org/archive/html/emacs-devel/2020-07/msg00306.html + ;; for a discussion. + (file-name-directory (locate-library "vterm.el" t)))) + (make-commands + (concat + "cd " vterm-directory "; \ + mkdir -p build; \ + cd build; \ + cmake -G 'Unix Makefiles' " + vterm-module-cmake-args + " ..; \ + make; \ + cd -")) + (buffer (get-buffer-create vterm-install-buffer-name))) + (pop-to-buffer buffer) + (compilation-mode) + (if (zerop (let ((inhibit-read-only t)) + (call-process "sh" nil buffer t "-c" make-commands))) + (message "Compilation of `emacs-libvterm' module succeeded") + (error "Compilation of `emacs-libvterm' module failed!"))))) + +;; If the vterm-module is not compiled yet, compile it +(unless (require 'vterm-module nil t) + (if (or vterm-always-compile-module + (y-or-n-p "Vterm needs `vterm-module' to work. Compile it now? ")) + (progn + (vterm-module-compile) + (require 'vterm-module)) + (error "Vterm will not work until `vterm-module' is compiled!"))) + +;;; Dependencies + +;; Generate this list with: +;; awk -F\" '/bind_function*/ {print "(declare-function", $2, "\"vterm-module\")"}' vterm-module.c +(declare-function vterm--new "vterm-module") +(declare-function vterm--update "vterm-module") +(declare-function vterm--redraw "vterm-module") +(declare-function vterm--write-input "vterm-module") +(declare-function vterm--set-size "vterm-module") +(declare-function vterm--set-pty-name "vterm-module") +(declare-function vterm--get-pwd-raw "vterm-module") +(declare-function vterm--reset-point "vterm-module") +(declare-function vterm--get-icrnl "vterm-module") + +(require 'subr-x) +(require 'find-func) +(require 'cl-lib) +(require 'term) +(require 'color) +(require 'compile) +(require 'face-remap) +(require 'tramp) +(require 'bookmark) + +;;; Options + +(defcustom vterm-shell shell-file-name + "The shell that gets run in the vterm." + :type 'string + :group 'vterm) + +(defcustom vterm-tramp-shells '(("docker" "/bin/sh")) + "The shell that gets run in the vterm for tramp. + +`vterm-tramp-shells' has to be a list of pairs of the format: +\(TRAMP-METHOD SHELL)" + :type '(alist :key-type string :value-type string) + :group 'vterm) + +(defcustom vterm-buffer-name "*vterm*" + "The basename used for vterm buffers. +This is the default name used when running `vterm' or +`vterm-other-window'. + +With a numeric prefix argument to `vterm', the buffer name will +be the value of this variable followed by the number. For +example, with the numeric prefix argument 2, the buffer would be +named \"*vterm*<2>\"." + :type 'string + :group 'vterm) + +(defcustom vterm-max-scrollback 1000 + "Maximum 'scrollback' value. + +The maximum allowed is 100000. This value can modified by +changing the SB_MAX variable in vterm-module.h and recompiling +the module." + :type 'number + :group 'vterm) + +(defcustom vterm-min-window-width 80 + "Minimum window width." + :type 'number + :group 'vterm) + +(defcustom vterm-kill-buffer-on-exit t + "If not nil vterm buffers are killed when the attached process is terminated. + +If `vterm-kill-buffer-on-exit' is set to t, when the process +associated to a vterm buffer quits, the buffer is killed. When +nil, the buffer will still be available as if it were in +`fundamental-mode'." + :type 'boolean + :group 'vterm) + +(define-obsolete-variable-alias 'vterm-clear-scrollback + 'vterm-clear-scrollback-when-clearing "0.0.1") + +(define-obsolete-variable-alias 'vterm-use-vterm-prompt + 'vterm-use-vterm-prompt-detection-method "0.0.1") + +(defcustom vterm-clear-scrollback-when-clearing nil + "If not nil `vterm-clear' clears both screen and scrollback. + +The scrollback is everything that is not current visible on +screen in vterm buffers. + +If `vterm-clear-scrollback-when-clearing' is nil, `vterm-clear' +clears only the screen, so the scrollback is accessible moving +the point up." + :type 'number + :group 'vterm) + +(defcustom vterm-keymap-exceptions + '("C-c" "C-x" "C-u" "C-g" "C-h" "C-l" "M-x" "M-o" "C-y" "M-y") + "Exceptions for `vterm-keymap'. + +If you use a keybinding with a prefix-key, add that prefix-key to +this list. Note that after doing so that prefix-key cannot be sent +to the terminal anymore. + +The mapping is done by the macro `vterm-define-key', and the +function `vterm--exclude-keys' removes the keybindings defined in +`vterm-keymap-exceptions'." + :type '(repeat string) + :set (lambda (sym val) + (set sym val) + (when (and (fboundp 'vterm--exclude-keys) + (boundp 'vterm-mode-map)) + (vterm--exclude-keys vterm-mode-map val))) + :group 'vterm) + +(defcustom vterm-exit-functions nil + "List of functions called when a vterm process exits. + +Each function is called with two arguments: the vterm buffer of +the process if any, and a string describing the event passed from +the sentinel. + +This hook applies only to new vterms, created after setting this +value with `add-hook'. + +Note that this hook will not work if another package like +`shell-pop' sets its own sentinel to the `vterm' process." + :type 'hook + :group 'vterm) + +(make-obsolete-variable 'vterm-set-title-functions + "This variable was substituted by `vterm-buffer-name-string'." + "0.0.1") + +(defcustom vterm-buffer-name-string nil + "Format string for the title of vterm buffers. + +If `vterm-buffer-name-string' is nil, vterm will not set the +title of its buffers. If not nil, `vterm-buffer-name-string' has +to be a format control string (see `format') containing one +instance of %s which will be substituted with the string TITLE. +The argument TITLE is provided by the shell. This requires shell +side configuration. + +For example, if `vterm-buffer-name-string' is set to \"vterm %s\", +and the shell properly configured to set TITLE=$(pwd), than vterm +buffers will be named \"vterm\" followed by the current path. + +See URL http://tldp.org/HOWTO/Xterm-Title-4.html for additional +information on the how to configure the shell." + :type 'string + :group 'vterm) + +(defcustom vterm-term-environment-variable "xterm-256color" + "TERM value for terminal." + :type 'string + :group 'vterm) + +(defcustom vterm-environment nil + "List of extra environment variables to the vterm shell processes only. + +demo: '(\"env1=v1\" \"env2=v2\")" + :type '(repeat string) + :group 'vterm) + + +(defcustom vterm-enable-manipulate-selection-data-by-osc52 nil + "Support OSC 52 MANIPULATE SELECTION DATA. + +Support copy text to emacs kill ring and system clipboard by using OSC 52. +For example: send base64 encoded 'foo' to kill ring: echo -en '\e]52;c;Zm9v\a', +tmux can share its copy buffer to terminals by supporting osc52(like iterm2 + xterm) you can enable this feature for tmux by : +set -g set-clipboard on #osc 52 copy paste share with iterm +set -ga terminal-overrides ',xterm*:XT:Ms=\E]52;%p1%s;%p2%s\007' +set -ga terminal-overrides ',screen*:XT:Ms=\E]52;%p1%s;%p2%s\007' + +The clipboard querying/clearing functionality offered by OSC 52 is not +implemented here,And for security reason, this feature is disabled +by default." + :type 'boolean + :group 'vterm) + +;; TODO: Improve doc string, it should not point to the readme but it should +;; be self-contained. +(defcustom vterm-eval-cmds '(("find-file" find-file) + ("message" message) + ("vterm-clear-scrollback" vterm-clear-scrollback)) + "Whitelisted Emacs functions that can be executed from vterm. + +You can execute Emacs functions directly from vterm buffers. To do this, +you have to escape the name of the function and its arguments with \e]51;E. + +See Message passing in README. + +The function you want to execute has to be in `vterm-eval-cmds'. + +`vterm-eval-cmds' has to be a list of pairs of the format: +\(NAME-OF-COMMAND-IN-SHELL EMACS-FUNCTION) + +The need for an explicit map is to avoid arbitrary code execution." + :type '(alist :key-type string) + :group 'vterm) + +(defcustom vterm-disable-underline nil + "When not-nil, underline text properties are ignored. + +This means that vterm will render underlined text as if it was not +underlined." + :type 'boolean + :group 'vterm) + +(defcustom vterm-disable-inverse-video nil + "When not-nil, inverse video text properties are ignored. + +This means that vterm will render reversed video text as if it was not +such." + :type 'boolean + :group 'vterm) + +(define-obsolete-variable-alias 'vterm-disable-bold-font + 'vterm-disable-bold "0.0.1") + +(defcustom vterm-disable-bold-font nil + "When not-nil, bold text properties are ignored. + +This means that vterm will render bold with the default face weight." + :type 'boolean + :group 'vterm) + +(defcustom vterm-set-bold-hightbright nil + "When not-nil, using hightbright colors for bolded text, see #549." + :type 'boolean + :group 'vterm) + +(defcustom vterm-ignore-blink-cursor t + "When t,vterm will ignore request from application to turn on/off cursor blink. + +If nil, cursor in any window may begin to blink or not blink because +`blink-cursor-mode`is a global minor mode in Emacs, +you can use `M-x blink-cursor-mode` to toggle." + :type 'boolean + :group 'vterm) + +(defcustom vterm-copy-exclude-prompt t + "When not-nil, the prompt is not included by `vterm-copy-mode-done'." + :type 'boolean + :group 'vterm) + +(defcustom vterm-use-vterm-prompt-detection-method t + "When not-nil, the prompt is detected through the shell. + +Vterm needs to know where the shell prompt is to enable all the +available features. There are two supported ways to do this. +First, the shell can inform vterm on the location of the prompt. +This requires shell-side configuration: the escape code 51;A is +used to set the current directory and prompt location. This +detection method is the most-reliable. To use it, you have +to change your shell prompt to print 51;A. + +The second method is using a regular expression. This method does +not require any shell-side configuration. See +`term-prompt-regexp', for more information." + :type 'boolean + :group 'vterm) + +(defcustom vterm-bookmark-check-dir t + "When set to non-nil, also restore directory when restoring a vterm bookmark." + :type 'boolean + :group 'vterm) + +;;; Faces + +(defface vterm-color-black + `((t :inherit term-color-black)) + "Face used to render black color code. +The foreground color is used as ANSI color 0 and the background +color is used as ANSI color 8." + :group 'vterm) + +(defface vterm-color-red + `((t :inherit term-color-red)) + "Face used to render red color code. +The foreground color is used as ANSI color 1 and the background +color is used as ANSI color 9." + :group 'vterm) + +(defface vterm-color-green + `((t :inherit term-color-green)) + "Face used to render green color code. +The foreground color is used as ANSI color 2 and the background +color is used as ANSI color 10." + :group 'vterm) + +(defface vterm-color-yellow + `((t :inherit term-color-yellow)) + "Face used to render yellow color code. +The foreground color is used as ANSI color 3 and the background +color is used as ANSI color 11." + :group 'vterm) + +(defface vterm-color-blue + `((t :inherit term-color-blue)) + "Face used to render blue color code. +The foreground color is used as ANSI color 4 and the background +color is used as ANSI color 12." + :group 'vterm) + +(defface vterm-color-magenta + `((t :inherit term-color-magenta)) + "Face used to render magenta color code. +The foreground color is used as ansi color 5 and the background +color is used as ansi color 13." + :group 'vterm) + +(defface vterm-color-cyan + `((t :inherit term-color-cyan)) + "Face used to render cyan color code. +The foreground color is used as ansi color 6 and the background +color is used as ansi color 14." + :group 'vterm) + +(defface vterm-color-white + `((t :inherit term-color-white)) + "Face used to render white color code. +The foreground color is used as ansi color 7 and the background +color is used as ansi color 15." + :group 'vterm) + +(defface vterm-color-underline + `((t :inherit default)) + "Face used to render cells with underline attribute. +Only foreground is used." + :group 'vterm) + +(defface vterm-color-inverse-video + `((t :inherit default)) + "Face used to render cells with inverse video attribute. +Only background is used." + :group 'vterm) + +;;; Variables + +(defvar vterm-color-palette + [vterm-color-black + vterm-color-red + vterm-color-green + vterm-color-yellow + vterm-color-blue + vterm-color-magenta + vterm-color-cyan + vterm-color-white] + "Color palette for the foreground and background.") + +(defvar-local vterm--term nil + "Pointer to Term.") + +(defvar-local vterm--process nil + "Shell process of current term.") + +(defvar-local vterm--redraw-timer nil) +(defvar-local vterm--redraw-immididately nil) +(defvar-local vterm--linenum-remapping nil) +(defvar-local vterm--prompt-tracking-enabled-p nil) +(defvar-local vterm--insert-function (symbol-function #'insert)) +(defvar-local vterm--delete-char-function (symbol-function #'delete-char)) +(defvar-local vterm--delete-region-function (symbol-function #'delete-region)) +(defvar-local vterm--undecoded-bytes nil) + +(defvar vterm-timer-delay 0.1 + "Delay for refreshing the buffer after receiving updates from libvterm. + +A larger delary improves performance when receiving large bursts +of data. If nil, never delay. The units are seconds.") + +;;; Keybindings + +;; We have many functions defined by vterm-define-key. Later, we will bind some +;; of the functions. If the following is not evaluated during compilation, the compiler +;; will complain that some functions are not defined (eg, vterm-send-C-c) +(eval-and-compile + (defmacro vterm-define-key (key) + "Define a command that sends KEY with modifiers C and M to vterm." + (declare (indent defun) + (doc-string 3)) + `(defun ,(intern (format "vterm-send-%s" key))() + ,(format "Sends %s to the libvterm." key) + (interactive) + (vterm-send-key ,(char-to-string (get-byte (1- (length key)) key)) + ,(let ((case-fold-search nil)) + (or (string-match-p "[A-Z]$" key) + (string-match-p "S-" key))) + ,(string-match-p "M-" key) + ,(string-match-p "C-" key)))) + + (mapc (lambda (key) + (eval `(vterm-define-key ,key))) + (cl-loop for prefix in '("M-") + append (cl-loop for char from ?A to ?Z + for key = (format "%s%c" prefix char) + collect key))) + (mapc (lambda (key) + (eval `(vterm-define-key ,key))) + (cl-loop for prefix in '("C-" "M-" "C-S-") + append (cl-loop for char from ?a to ?z + for key = (format "%s%c" prefix char) + collect key)))) + +;; Function keys and most of C- and M- bindings +(defun vterm--exclude-keys (map exceptions) + "Remove EXCEPTIONS from the keys bound by `vterm-define-keys'. + +Exceptions are defined by `vterm-keymap-exceptions'." + (mapc (lambda (key) + (define-key map (kbd key) nil)) + exceptions) + (mapc (lambda (key) + (define-key map (kbd key) #'vterm--self-insert)) + (cl-loop for number from 1 to 12 + for key = (format "" number) + unless (member key exceptions) + collect key)) + (mapc (lambda (key) + (define-key map (kbd key) + (intern (format "vterm-send-%s" key)))) + (cl-loop for prefix in '("M-") + append (cl-loop for char from ?A to ?Z + for key = (format "%s%c" prefix char) + unless (member key exceptions) + collect key))) + (mapc (lambda (key) + (define-key map (kbd key) + (intern (format "vterm-send-%s" key)))) + (cl-loop for prefix in '("C-" "M-" "C-S-" ) + append (cl-loop for char from ?a to ?z + for key = (format "%s%c" prefix char) + unless (member key exceptions) + collect key))) + (mapc (lambda (key) + (define-key map (kbd key) 'ignore)) + (cl-loop for prefix in '("C-M-" "C-M-S-") + append (cl-loop for char from ?a to ?z + for key = (format "%s%c" prefix char) + unless (member key exceptions) + collect key)))) + +(defun vterm-xterm-paste (event) + "Handle xterm paste EVENT in vterm." + (interactive "e") + (with-temp-buffer + (xterm-paste event) + (kill-new (buffer-string))) + (vterm-yank)) + +(defvar vterm-mode-map + (let ((map (make-sparse-keymap))) + (vterm--exclude-keys map vterm-keymap-exceptions) + (define-key map (kbd "C-]") #'vterm--self-insert) + (define-key map (kbd "M-<") #'vterm--self-insert) + (define-key map (kbd "M->") #'vterm--self-insert) + (define-key map [tab] #'vterm-send-tab) + (define-key map (kbd "TAB") #'vterm-send-tab) + (define-key map [backtab] #'vterm--self-insert) + (define-key map [backspace] #'vterm-send-backspace) + (define-key map (kbd "DEL") #'vterm-send-backspace) + (define-key map [delete] #'vterm-send-delete) + (define-key map [M-backspace] #'vterm-send-meta-backspace) + (define-key map (kbd "M-DEL") #'vterm-send-meta-backspace) + (define-key map [C-backspace] #'vterm-send-meta-backspace) + (define-key map [return] #'vterm-send-return) + (define-key map (kbd "RET") #'vterm-send-return) + (define-key map [C-left] #'vterm-send-M-b) + (define-key map [M-left] #'vterm-send-M-b) + (define-key map [C-right] #'vterm-send-M-f) + (define-key map [M-right] #'vterm-send-M-f) + (define-key map [C-up] #'vterm-send-up) + (define-key map [C-down] #'vterm-send-down) + (define-key map [left] #'vterm-send-left) + (define-key map [right] #'vterm-send-right) + (define-key map [up] #'vterm-send-up) + (define-key map [down] #'vterm-send-down) + (define-key map [prior] #'vterm-send-prior) + (define-key map [S-prior] #'scroll-down-command) + (define-key map [next] #'vterm-send-next) + (define-key map [S-next] #'scroll-up-command) + (define-key map [home] #'vterm--self-insert) + (define-key map [end] #'vterm--self-insert) + (define-key map [C-home] #'vterm--self-insert) + (define-key map [C-end] #'vterm--self-insert) + (define-key map [escape] #'vterm--self-insert) + (define-key map [remap yank] #'vterm-yank) + (define-key map [remap xterm-paste] #'vterm-xterm-paste) + (define-key map [remap yank-pop] #'vterm-yank-pop) + (define-key map [remap mouse-yank-primary] #'vterm-yank-primary) + (define-key map (kbd "C-SPC") #'vterm--self-insert) + (define-key map (kbd "S-SPC") #'vterm-send-space) + (define-key map (kbd "C-_") #'vterm--self-insert) + (define-key map (kbd "C-/") #'vterm-undo) + (define-key map (kbd "M-.") #'vterm-send-meta-dot) + (define-key map (kbd "M-,") #'vterm-send-meta-comma) + (define-key map (kbd "C-c C-y") #'vterm--self-insert) + (define-key map (kbd "C-c C-c") #'vterm-send-C-c) + (define-key map (kbd "C-c C-l") #'vterm-clear-scrollback) + (define-key map (kbd "C-l") #'vterm-clear) + (define-key map (kbd "C-\\") #'vterm-send-ctrl-slash) + (define-key map (kbd "C-c C-g") #'vterm-send-C-g) + (define-key map (kbd "C-c C-u") #'vterm-send-C-u) + (define-key map [remap self-insert-command] #'vterm--self-insert) + (define-key map (kbd "C-c C-r") #'vterm-reset-cursor-point) + (define-key map (kbd "C-c C-n") #'vterm-next-prompt) + (define-key map (kbd "C-c C-p") #'vterm-previous-prompt) + (define-key map (kbd "C-c C-t") #'vterm-copy-mode) + map)) + +(defvar vterm-copy-mode-map + (let ((map (make-sparse-keymap))) + (define-key map (kbd "C-c C-t") #'vterm-copy-mode) + (define-key map [return] #'vterm-copy-mode-done) + (define-key map (kbd "RET") #'vterm-copy-mode-done) + (define-key map (kbd "C-c C-r") #'vterm-reset-cursor-point) + (define-key map (kbd "C-a") #'vterm-beginning-of-line) + (define-key map (kbd "C-e") #'vterm-end-of-line) + (define-key map (kbd "C-c C-n") #'vterm-next-prompt) + (define-key map (kbd "C-c C-p") #'vterm-previous-prompt) + map)) + + +;;; Mode + +(define-derived-mode vterm-mode fundamental-mode "VTerm" + "Major mode for vterm buffer." + (buffer-disable-undo) + (and (boundp 'display-line-numbers) + (let ((font-height (expt text-scale-mode-step text-scale-mode-amount))) + (setq vterm--linenum-remapping + (face-remap-add-relative 'line-number :height font-height)))) + (let ((process-environment (append vterm-environment + `(,(concat "TERM=" + vterm-term-environment-variable) + ,(concat "EMACS_VTERM_PATH=" + (file-name-directory (find-library-name "vterm"))) + "INSIDE_EMACS=vterm" + "LINES" + "COLUMNS") + process-environment)) + ;; TODO: Figure out why inhibit is needed for curses to render correctly. + (inhibit-eol-conversion nil) + (coding-system-for-read 'binary) + (process-adaptive-read-buffering nil) + (width (max (- (window-body-width) (vterm--get-margin-width)) + vterm-min-window-width))) + (setq vterm--term (vterm--new (window-body-height) + width vterm-max-scrollback + vterm-disable-bold-font + vterm-disable-underline + vterm-disable-inverse-video + vterm-ignore-blink-cursor + vterm-set-bold-hightbright)) + (setq buffer-read-only t) + (setq-local scroll-conservatively 101) + (setq-local scroll-margin 0) + (setq-local hscroll-margin 0) + (setq-local hscroll-step 1) + (setq-local truncate-lines t) + + + ;; Disable all automatic fontification + (setq-local font-lock-defaults '(nil t)) + + (add-function :filter-return + (local 'filter-buffer-substring-function) + #'vterm--filter-buffer-substring) + (setq vterm--process + (make-process + :name "vterm" + :buffer (current-buffer) + :command + `("/bin/sh" "-c" + ,(format + "stty -nl sane %s erase ^? rows %d columns %d >/dev/null && exec %s" + ;; Some stty implementations (i.e. that of *BSD) do not + ;; support the iutf8 option. to handle that, we run some + ;; heuristics to work out if the system supports that + ;; option and set the arg string accordingly. This is a + ;; gross hack but FreeBSD doesn't seem to want to fix it. + ;; + ;; See: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=220009 + (if (eq system-type 'berkeley-unix) "" "iutf8") + (window-body-height) + width (vterm--get-shell))) + ;; :coding 'no-conversion + :connection-type 'pty + :file-handler t + :filter #'vterm--filter + ;; The sentinel is needed if there are exit functions or if + ;; vterm-kill-buffer-on-exit is set to t. In this latter case, + ;; vterm--sentinel will kill the buffer + :sentinel (when (or vterm-exit-functions + vterm-kill-buffer-on-exit) + #'vterm--sentinel)))) + + ;; Change major-mode is not allowed + ;; Vterm interfaces with an underlying process. Changing the major + ;; mode can break this, leading to segmentation faults. + (add-hook 'change-major-mode-hook + (lambda () (interactive) + (user-error "You cannot change major mode in vterm buffers")) nil t) + + (vterm--set-pty-name vterm--term (process-tty-name vterm--process)) + (process-put vterm--process 'adjust-window-size-function + #'vterm--window-adjust-process-window-size) + ;; Support to compilation-shell-minor-mode + ;; Is this necessary? See vterm--compilation-setup + (setq next-error-function 'vterm-next-error-function) + (setq-local bookmark-make-record-function 'vterm--bookmark-make-record)) + +(defun vterm--get-shell () + "Get the shell that gets run in the vterm." + (if (ignore-errors (file-remote-p default-directory)) + (with-parsed-tramp-file-name default-directory nil + (or (cadr (assoc method vterm-tramp-shells)) + vterm-shell)) + vterm-shell)) + +(defun vterm--bookmark-make-record () + "Create a vterm bookmark. + +Notes down the current directory and buffer name." + `(nil + (handler . vterm--bookmark-handler) + (thisdir . ,default-directory) + (buf-name . ,(buffer-name)) + (defaults . nil))) + + +;;;###autoload +(defun vterm--bookmark-handler (bmk) + "Handler to restore a vterm bookmark BMK. + +If a vterm buffer of the same name does not exist, the function will create a +new vterm buffer of the name. It also checks the current directory and sets +it to the bookmarked directory if needed." + (let* ((thisdir (bookmark-prop-get bmk 'thisdir)) + (buf-name (bookmark-prop-get bmk 'buf-name)) + (buf (get-buffer buf-name)) + (thismode (and buf (with-current-buffer buf major-mode)))) + ;; create if no such vterm buffer exists + (when (or (not buf) (not (eq thismode 'vterm-mode))) + (setq buf (generate-new-buffer buf-name)) + (with-current-buffer buf + (when vterm-bookmark-check-dir + (setq default-directory thisdir)) + (vterm-mode))) + ;; check the current directory + (with-current-buffer buf + (when (and vterm-bookmark-check-dir + (not (string-equal default-directory thisdir))) + (when vterm-copy-mode + (vterm-copy-mode-done nil)) + (vterm-insert (concat "cd " thisdir)) + (vterm-send-return))) + ;; set to this vterm buf + (set-buffer buf))) + +(defun vterm--compilation-setup () + "Function to enable the option `compilation-shell-minor-mode' for vterm. +`'compilation-shell-minor-mode' would change the value of local +variable `next-error-function', so we should call this function in +`compilation-shell-minor-mode-hook'." + (when (eq major-mode 'vterm-mode) + (setq next-error-function 'vterm-next-error-function))) + +(add-hook 'compilation-shell-minor-mode-hook #'vterm--compilation-setup) + +;;;###autoload +(defun vterm-next-error-function (n &optional reset) + "Advance to the next error message and visit the file where the error was. +This is the value of `next-error-function' in Compilation +buffers. Prefix arg N says how many error messages to move +forwards (or backwards, if negative). + +Optional argument RESET clears all the errors." + (interactive "p") + (let* ((pt (point)) + (default-directory default-directory) + (pwd (vterm--get-pwd))) + (when pwd + (setq default-directory pwd)) + (goto-char pt) + (compilation-next-error-function n reset))) + +;;; Copy Mode + +(define-minor-mode vterm-copy-mode + "Toggle `vterm-copy-mode'. + +When `vterm-copy-mode' is enabled, the terminal will not display +additional output received from the underlying process and will +behave similarly to buffer in `fundamental-mode'. This mode is +typically used to copy text from vterm buffers. + +A conventient way to exit `vterm-copy-mode' is with +`vterm-copy-mode-done', which copies the selected text and exit +`vterm-copy-mode'." + :group 'vterm + :lighter " VTermCopy" + :keymap vterm-copy-mode-map + (if (equal major-mode 'vterm-mode) + (if vterm-copy-mode + (progn ;enable vterm-copy-mode + (use-local-map nil) + (vterm-send-stop)) + (vterm-reset-cursor-point) + (use-local-map vterm-mode-map) + (vterm-send-start)) + (user-error "You cannot enable vterm-copy-mode outside vterm buffers"))) + +(defun vterm-copy-mode-done (arg) + "Save the active region or line to the kill ring and exit `vterm-copy-mode'. + +If a region is defined then that region is killed, with no region then +current line is killed from start to end. + +The option `vterm-copy-exclude-prompt' controls if the prompt +should be included in a line copy. Using the universal prefix ARG +will invert `vterm-copy-exclude-prompt' for that call." + (interactive "P") + (unless vterm-copy-mode + (user-error "This command is effective only in vterm-copy-mode")) + (unless (use-region-p) + (goto-char (vterm--get-beginning-of-line)) + ;; Are we excluding the prompt? + (if (or (and vterm-copy-exclude-prompt (not arg)) + (and (not vterm-copy-exclude-prompt) arg)) + (goto-char (max (or (vterm--get-prompt-point) 0) + (vterm--get-beginning-of-line)))) + (set-mark (point)) + (goto-char (vterm--get-end-of-line))) + (kill-ring-save (region-beginning) (region-end)) + (vterm-copy-mode -1)) + +;;; Commands + +(defun vterm--self-insert () + "Send invoking key to libvterm." + (interactive) + (when vterm--term + (let* ((modifiers (event-modifiers last-command-event)) + (shift (memq 'shift modifiers)) + (meta (memq 'meta modifiers)) + (ctrl (memq 'control modifiers)) + (raw-key (event-basic-type last-command-event)) + (ev-keys)) + (if input-method-function + (let ((inhibit-read-only t)) + (setq ev-keys (funcall input-method-function raw-key)) + (when (listp ev-keys) + (dolist (k ev-keys) + (when-let ((key (key-description (vector k)))) + (vterm-send-key key shift meta ctrl))))) + (when-let ((key (key-description (vector raw-key)))) + (vterm-send-key key shift meta ctrl)))))) + +(defun vterm-send-key (key &optional shift meta ctrl accept-proc-output) + "Send KEY to libvterm with optional modifiers SHIFT, META and CTRL." + (deactivate-mark) + (when vterm--term + (let ((inhibit-redisplay t) + (inhibit-read-only t)) + (when (and (not (symbolp last-command-event)) shift (not meta) (not ctrl)) + (setq key (upcase key))) + (vterm--update vterm--term key shift meta ctrl) + (setq vterm--redraw-immididately t) + (when accept-proc-output + (accept-process-output vterm--process vterm-timer-delay nil t))))) + +(defun vterm-send (key) + "Send KEY to libvterm. KEY can be anything `kbd' understands." + (let* ((event (listify-key-sequence (kbd key))) + (modifiers (event-modifiers event)) + (base (event-basic-type event))) + (vterm-send-key (char-to-string base) + (memq 'shift modifiers) + (memq 'meta modifiers) + (memq 'control modifiers)))) + +(defun vterm-send-start () + "Output from the system is started when the system receives START." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-stop () + "Output from the system is stopped when the system receives STOP." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-return () + "Send `C-m' to the libvterm." + (interactive) + (deactivate-mark) + (when vterm--term + (if (vterm--get-icrnl vterm--term) + (process-send-string vterm--process "\C-j") + (process-send-string vterm--process "\C-m")))) + +(defun vterm-send-tab () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-space () + "Send `' to the libvterm." + (interactive) + (vterm-send-key " ")) + +(defun vterm-send-backspace () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-delete () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-meta-backspace () + "Send `M-' to the libvterm." + (interactive) + (vterm-send-key "" nil t)) + +(defun vterm-send-up () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-down () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-left () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-right () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-prior () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-next () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-send-meta-dot () + "Send `M-.' to the libvterm." + (interactive) + (vterm-send-key "." nil t)) + +(defun vterm-send-meta-comma () + "Send `M-,' to the libvterm." + (interactive) + (vterm-send-key "," nil t)) + +(defun vterm-send-ctrl-slash () + "Send `C-\' to the libvterm." + (interactive) + (vterm-send-key "\\" nil nil t)) + +(defun vterm-send-escape () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-clear-scrollback () + "Send `' to the libvterm." + (interactive) + (vterm-send-key "")) + +(defun vterm-clear (&optional arg) + "Send `' to the libvterm. + +`vterm-clear-scrollback' determines whether +`vterm-clear' should also clear the scrollback or not. + +This behavior can be altered by calling `vterm-clear' with a +prefix argument ARG or with \\[universal-argument]." + (interactive "P") + (if (or + (and vterm-clear-scrollback-when-clearing (not arg)) + (and arg (not vterm-clear-scrollback-when-clearing))) + (vterm-clear-scrollback)) + (vterm-send-C-l)) + +(defun vterm-undo () + "Send `C-_' to the libvterm." + (interactive) + (vterm-send-key "_" nil nil t)) + +(defun vterm-yank (&optional arg) + "Yank (paste) text in vterm. + +Argument ARG is passed to `yank'." + (interactive "P") + (deactivate-mark) + (vterm-goto-char (point)) + (let ((inhibit-read-only t)) + (cl-letf (((symbol-function 'insert-for-yank) #'vterm-insert)) + (yank arg)))) + +(defun vterm-yank-primary () + "Yank text from the primary selection in vterm." + (interactive) + (vterm-goto-char (point)) + (let ((inhibit-read-only t) + (primary (gui-get-primary-selection))) + (cl-letf (((symbol-function 'insert-for-yank) #'vterm-insert)) + (insert-for-yank primary)))) + +(defun vterm-yank-pop (&optional arg) + "Replaced text just yanked with the next entry in the kill ring. + +Argument ARG is passed to `yank'" + (interactive "p") + (vterm-goto-char (point)) + (let ((inhibit-read-only t) + (yank-undo-function #'(lambda (_start _end) (vterm-undo)))) + (cl-letf (((symbol-function 'insert-for-yank) #'vterm-insert)) + (yank-pop arg)))) + +(defun vterm-send-string (string &optional paste-p) + "Send the string STRING to vterm. +Optional argument PASTE-P paste-p." + (when vterm--term + (when paste-p + (vterm--update vterm--term "" )) + (dolist (char (string-to-list string)) + (vterm--update vterm--term (char-to-string char))) + (when paste-p + (vterm--update vterm--term ""))) + (setq vterm--redraw-immididately t) + (accept-process-output vterm--process vterm-timer-delay nil t)) + +(defun vterm-insert (&rest contents) + "Insert the arguments, either strings or characters, at point. + +Provide similar behavior as `insert' for vterm." + (when vterm--term + (vterm--update vterm--term "") + (dolist (c contents) + (if (characterp c) + (vterm--update vterm--term (char-to-string c)) + (dolist (char (string-to-list c)) + (vterm--update vterm--term (char-to-string char))))) + (vterm--update vterm--term "") + (setq vterm--redraw-immididately t) + (accept-process-output vterm--process vterm-timer-delay nil t))) + +(defun vterm-delete-region (start end) + "Delete the text between START and END for vterm. " + (when vterm--term + (if (vterm-goto-char start) + (cl-loop repeat (- end start) do + (vterm-send-key "" nil nil nil t)) + (let ((inhibit-read-only nil)) + (vterm--delete-region start end))))) + +(defun vterm-goto-char (pos) + "Set point to POSITION for vterm. + +The return value is `t' when point moved successfully. +It will reset to original position if it can't move there." + (when (and vterm--term + (vterm-cursor-in-command-buffer-p) + (vterm-cursor-in-command-buffer-p pos)) + (let ((moved t) + (origin-point (point)) + pt cursor-pos succ) + (vterm-reset-cursor-point) + (setq cursor-pos (point)) + (setq pt cursor-pos) + (while (and (> pos pt) moved) + (vterm-send-key "" nil nil nil t) + (setq moved (not (= pt (point)))) + (setq pt (point))) + (setq pt (point)) + (setq moved t) + (while (and (< pos pt) moved) + (vterm-send-key "" nil nil nil t) + (setq moved (not (= pt (point)))) + (setq pt (point))) + (setq succ (= pos (point))) + (unless succ + (vterm-goto-char cursor-pos) + (goto-char origin-point)) + succ))) + +;;; Internal + +(defun vterm--delete-region(start end) + "A wrapper for `delete-region'." + (funcall vterm--delete-region-function start end)) + +(defun vterm--insert(&rest content) + "A wrapper for `insert'." + (apply vterm--insert-function content)) + +(defun vterm--delete-char(n &optional killflag) + "A wrapper for `delete-char'." + (funcall vterm--delete-char-function n killflag)) + +(defun vterm--invalidate () + "The terminal buffer is invalidated, the buffer needs redrawing." + (if (and (not vterm--redraw-immididately) + vterm-timer-delay) + (unless vterm--redraw-timer + (setq vterm--redraw-timer + (run-with-timer vterm-timer-delay nil + #'vterm--delayed-redraw (current-buffer)))) + (vterm--delayed-redraw (current-buffer)) + (setq vterm--redraw-immididately nil))) + +(defun vterm-check-proc (&optional buffer) + "Check if there is a running process associated to the vterm buffer BUFFER. + +BUFFER can be either a buffer or the name of one." + (let* ((buffer (get-buffer (or buffer (current-buffer)))) + (proc (get-buffer-process buffer))) + (and proc + (memq (process-status proc) '(run stop open listen connect)) + (buffer-local-value 'vterm--term buffer)))) + +(defun vterm--delayed-redraw (buffer) + "Redraw the terminal buffer. +Argument BUFFER the terminal buffer." + (when (buffer-live-p buffer) + (with-current-buffer buffer + (let ((inhibit-redisplay t) + (inhibit-read-only t) + (windows (get-buffer-window-list))) + (setq vterm--redraw-timer nil) + (when vterm--term + (vterm--redraw vterm--term) + (unless (zerop (window-hscroll)) + (when (cl-member (selected-window) windows :test #'eq) + (set-window-hscroll (selected-window) 0)))))))) + +(defun vterm--selection (targets data) + "OSC 52 Manipulate Selection Data. +Search Manipulate Selection Data in + https://invisible-island.net/xterm/ctlseqs/ctlseqs.html ." + (when vterm-enable-manipulate-selection-data-by-osc52 + (unless (or (string-equal data "?") + (string-empty-p data)) + (let* ((inhibit-eol-conversion t) + (decoded-data (decode-coding-string + (base64-decode-string data) locale-coding-system)) + (select-enable-clipboard select-enable-clipboard) + (select-enable-primary select-enable-primary)) + ;; https://invisible-island.net/xterm/ctlseqs/ctlseqs.html + ;; c , p , q , s , 0 , 1 , 2 , 3 , 4 , 5 , 6 , and 7 + ;; clipboard, primary, secondary, select, or cut buffers 0 through 7 + (unless (string-empty-p targets) + (setq select-enable-clipboard nil) + (setq select-enable-primary nil)) + (when (cl-find ?c targets) + (setq select-enable-clipboard t)) + (when (cl-find ?p targets) + (setq select-enable-primary t)) + + (kill-new decoded-data) + (message "kill-ring is updated by vterm OSC 52(Manipulate Selection Data)"))))) + +;;; Entry Points + +;;;###autoload +(defun vterm (&optional arg) + "Create an interactive Vterm buffer. +Start a new Vterm session, or switch to an already active +session. Return the buffer selected (or created). + +With a nonnumeric prefix arg, create a new session. + +With a string prefix arg, create a new session with arg as buffer name. + +With a numeric prefix arg (as in `C-u 42 M-x vterm RET'), switch +to the session with that number, or create it if it doesn't +already exist. + +The buffer name used for Vterm sessions is determined by the +value of `vterm-buffer-name'." + (interactive "P") + (vterm--internal #'pop-to-buffer-same-window arg)) + +;;;###autoload +(defun vterm-other-window (&optional arg) + "Create an interactive Vterm buffer in another window. +Start a new Vterm session, or switch to an already active +session. Return the buffer selected (or created). + +With a nonnumeric prefix arg, create a new session. + +With a string prefix arg, create a new session with arg as buffer name. + +With a numeric prefix arg (as in `C-u 42 M-x vterm RET'), switch +to the session with that number, or create it if it doesn't +already exist. + +The buffer name used for Vterm sessions is determined by the +value of `vterm-buffer-name'." + (interactive "P") + (vterm--internal #'pop-to-buffer arg)) + +(defun vterm--internal (pop-to-buf-fun &optional arg) + (cl-assert vterm-buffer-name) + (let ((buf (cond ((numberp arg) + (get-buffer-create (format "%s<%d>" + vterm-buffer-name + arg))) + ((stringp arg) (generate-new-buffer arg)) + (arg (generate-new-buffer vterm-buffer-name)) + (t + (get-buffer-create vterm-buffer-name))))) + (cl-assert (and buf (buffer-live-p buf))) + (funcall pop-to-buf-fun buf) + (with-current-buffer buf + (unless (derived-mode-p 'vterm-mode) + (vterm-mode))) + buf)) + +;;; Internal + +(defun vterm--flush-output (output) + "Send the virtual terminal's OUTPUT to the shell." + (process-send-string vterm--process output)) +;; Terminal emulation +;; This is the standard process filter for term buffers. +;; It emulates (most of the features of) a VT100/ANSI-style terminal. + +;; References: +;; [ctlseqs]: http://invisible-island.net/xterm/ctlseqs/ctlseqs.html +;; [ECMA-48]: https://www.ecma-international.org/publications/standards/Ecma-048.htm +;; [vt100]: https://vt100.net/docs/vt100-ug/chapter3.html + +(defconst vterm-control-seq-regexp + (concat + ;; A control character, + "\\(?:[\r\n\000\007\t\b\016\017]\\|" + ;; a C1 escape coded character (see [ECMA-48] section 5.3 "Elements + ;; of the C1 set"), + "\e\\(?:[DM78c]\\|" + ;; another Emacs specific control sequence for term.el, + "AnSiT[^\n]+\n\\|" + ;; another Emacs specific control sequence for vterm.el + ;; printf "\e]%s\e\\" + "\\][^\e]+\e\\\\\\|" + ;; or an escape sequence (section 5.4 "Control Sequences"), + "\\[\\([\x30-\x3F]*\\)[\x20-\x2F]*[\x40-\x7E]\\)\\)") + "Regexp matching control sequences handled by term.el.") + +(defconst vterm-control-seq-prefix-regexp + "[\032\e]") + +(defun vterm--filter (process input) + "I/O Event. Feeds PROCESS's INPUT to the virtual terminal. + +Then triggers a redraw from the module." + (let ((inhibit-redisplay t) + (inhibit-eol-conversion t) + (inhibit-read-only t) + (buf (process-buffer process)) + (i 0) + (str-length (length input)) + decoded-substring + funny) + (when (buffer-live-p buf) + (with-current-buffer buf + ;; borrowed from term.el + ;; Handle non-control data. Decode the string before + ;; counting characters, to avoid garbling of certain + ;; multibyte characters (https://github.com/akermu/emacs-libvterm/issues/394). + ;; same bug of term.el https://debbugs.gnu.org/cgi/bugreport.cgi?bug=1006 + (when vterm--undecoded-bytes + (setq input (concat vterm--undecoded-bytes input)) + (setq vterm--undecoded-bytes nil) + (setq str-length (length input))) + (while (< i str-length) + (setq funny (string-match vterm-control-seq-regexp input i)) + (let ((ctl-end (if funny (match-end 0) + (setq funny (string-match vterm-control-seq-prefix-regexp input i)) + (if funny + (setq vterm--undecoded-bytes + (substring input funny)) + (setq funny str-length)) + ;; The control sequence ends somewhere + ;; past the end of this string. + (1+ str-length)))) + (when (> funny i) + ;; Handle non-control data. Decode the string before + ;; counting characters, to avoid garbling of certain + ;; multibyte characters (emacs bug#1006). + (setq decoded-substring + (decode-coding-string + (substring input i funny) + locale-coding-system t)) + ;; Check for multibyte characters that ends + ;; before end of string, and save it for + ;; next time. + (when (= funny str-length) + (let ((partial 0) + (count (length decoded-substring))) + (while (and (< partial count) + (eq (char-charset (aref decoded-substring + (- count 1 partial))) + 'eight-bit)) + (cl-incf partial)) + (when (> count partial 0) + (setq vterm--undecoded-bytes + (substring decoded-substring (- partial))) + (setq decoded-substring + (substring decoded-substring 0 (- partial))) + (cl-decf str-length partial) + (cl-decf funny partial)))) + (ignore-errors (vterm--write-input vterm--term decoded-substring)) + (setq i funny)) + (when (<= ctl-end str-length) + (ignore-errors (vterm--write-input vterm--term (substring input i ctl-end)))) + (setq i ctl-end))) + (vterm--update vterm--term))))) + +(defun vterm--sentinel (process event) + "Sentinel of vterm PROCESS. +Argument EVENT process event." + (let ((buf (process-buffer process))) + (run-hook-with-args 'vterm-exit-functions + (if (buffer-live-p buf) buf nil) + event) + (if (and vterm-kill-buffer-on-exit (buffer-live-p buf)) + (kill-buffer buf)))) + +(defun vterm--text-scale-mode (&optional _argv) + "Fix `line-number' height for scaled text." + (and text-scale-mode + (equal major-mode 'vterm-mode) + (boundp 'display-line-numbers) + (let ((height (expt text-scale-mode-step + text-scale-mode-amount))) + (when vterm--linenum-remapping + (face-remap-remove-relative vterm--linenum-remapping)) + (setq vterm--linenum-remapping + (face-remap-add-relative 'line-number :height height)))) + (window--adjust-process-windows)) + +(advice-add #'text-scale-mode :after #'vterm--text-scale-mode) + +(defun vterm--window-adjust-process-window-size (process windows) + "Adjust width of window WINDOWS associated to process PROCESS. + +`vterm-min-window-width' determines the minimum width allowed." + ;; We want `vterm-copy-mode' to resemble a fundamental buffer as much as + ;; possible. Hence, we must not call this function when the minor mode is + ;; enabled, otherwise the buffer would be redrawn, messing around with the + ;; position of the point. + (unless vterm-copy-mode + (let* ((size (funcall window-adjust-process-window-size-function + process windows)) + (width (car size)) + (height (cdr size)) + (inhibit-read-only t)) + (setq width (- width (vterm--get-margin-width))) + (setq width (max width vterm-min-window-width)) + (when (and (processp process) + (process-live-p process) + (> width 0) + (> height 0)) + (vterm--set-size vterm--term height width) + (cons width height))))) + +(defun vterm--get-margin-width () + "Get margin width of vterm buffer when `display-line-numbers-mode' is enabled." + (let ((width 0) + (max-line-num (+ (frame-height) vterm-max-scrollback))) + (when (bound-and-true-p display-line-numbers) + (setq width (+ width 4 + (string-width (number-to-string max-line-num))))) + width)) + +(defun vterm--delete-lines (line-num count &optional delete-whole-line) + "Delete COUNT lines from LINE-NUM. +If LINE-NUM is negative backward-line from end of buffer. +If option DELETE-WHOLE-LINE is non-nil, then this command kills +the whole line including its terminating newline" + (save-excursion + (when (vterm--goto-line line-num) + (vterm--delete-region (point) (point-at-eol count)) + (when (and delete-whole-line + (looking-at "\n")) + (vterm--delete-char 1))))) + +(defun vterm--goto-line (n) + "Go to line N and return true on success. +If N is negative backward-line from end of buffer." + (cond + ((> n 0) + (goto-char (point-min)) + (eq 0 (forward-line (1- n)))) + (t + (goto-char (point-max)) + (eq 0 (forward-line n))))) + +(defun vterm--set-title (title) + "Use TITLE to set the buffer name according to `vterm-buffer-name-string'." + (when vterm-buffer-name-string + (rename-buffer (format vterm-buffer-name-string title) t))) + +(defun vterm--set-directory (path) + "Set `default-directory' to PATH." + (let ((dir (vterm--get-directory path))) + (when dir (setq default-directory dir)))) + +(defun vterm--get-directory (path) + "Get normalized directory to PATH." + (when path + (let (directory) + (if (string-match "^\\(.*?\\)@\\(.*?\\):\\(.*?\\)$" path) + (progn + (let ((user (match-string 1 path)) + (host (match-string 2 path)) + (dir (match-string 3 path))) + (if (and (string-equal user user-login-name) + (string-equal host (system-name))) + (progn + (when (file-directory-p dir) + (setq directory (file-name-as-directory dir)))) + (setq directory (file-name-as-directory (concat "/-:" path)))))) + (when (file-directory-p path) + (setq directory (file-name-as-directory path)))) + directory))) + +(defun vterm--get-pwd (&optional linenum) + "Get working directory at LINENUM." + (when vterm--term + (let ((raw-pwd (vterm--get-pwd-raw + vterm--term + (or linenum (line-number-at-pos))))) + (when raw-pwd + (vterm--get-directory raw-pwd))))) + +(defun vterm--get-color (index) + "Get color by index from `vterm-color-palette'. +Argument INDEX index of the terminal color. +Special values for INDEX are: +-11 foreground for cells with underline attribute, foreground of +the `vterm-color-underline' face is used in this case. +-12 background for cells with inverse video attribute, background +of the `vterm-color-inverse-video' face is used in this case." + (cond + ((and (>= index 0) (< index 8)) + (face-foreground + (elt vterm-color-palette index) + nil 'default)) + ((and (>= index 8) (< index 16)) + (face-background + (elt vterm-color-palette (% index 8)) + nil 'default)) + ((= index -11) + (face-foreground 'vterm-color-underline nil 'default)) + ((= index -12) + (face-background 'vterm-color-inverse-video nil 'default)) + (t + nil))) + +(defun vterm--eval (str) + "Check if string STR is `vterm-eval-cmds' and execute command. + +All passed in arguments are strings and forwarded as string to +the called functions." + (let* ((parts (split-string-and-unquote str)) + (command (car parts)) + (args (cdr parts)) + (f (assoc command vterm-eval-cmds))) + (if f + (apply (cadr f) args) + (message "Failed to find command: %s" command)))) + +;; TODO: Improve doc string, it should not point to the readme but it should +;; be self-contained. +(defun vterm--prompt-tracking-enabled-p () + "Return t if tracking the prompt is enabled. + +Prompt tracking need shell side configurations. + +For zsh user, this is done by PROMPT=$PROMPT'%{$(vterm_prompt_end)%}'. + +The shell send semantic information about where the prompt ends via properly +escaped sequences to Emacs. + +More information see `Shell-side configuration' and `Directory tracking' +in README." + (or vterm--prompt-tracking-enabled-p + (save-excursion + (setq vterm--prompt-tracking-enabled-p + (next-single-property-change (point-min) 'vterm-prompt))))) + +(defun vterm-next-prompt (n) + "Move to end of Nth next prompt in the buffer." + (interactive "p") + (if (and vterm-use-vterm-prompt-detection-method + (vterm--prompt-tracking-enabled-p)) + (let ((pt (point)) + (promp-pt (vterm--get-prompt-point))) + (when promp-pt (goto-char promp-pt)) + (cl-loop repeat (or n 1) do + (setq pt (next-single-property-change (point-at-bol 2) 'vterm-prompt)) + (when pt (goto-char pt)))) + (term-next-prompt n))) + +(defun vterm-previous-prompt (n) + "Move to end of Nth previous prompt in the buffer." + (interactive "p") + (if (and vterm-use-vterm-prompt-detection-method + (vterm--prompt-tracking-enabled-p)) + (let ((pt (point)) + (prompt-pt (vterm--get-prompt-point))) + (when prompt-pt + (goto-char prompt-pt) + (when (> pt (point)) + (setq n (1- (or n 1)))) + (cl-loop repeat n do + (setq pt (previous-single-property-change (1- (point)) 'vterm-prompt)) + (when pt (goto-char (1- pt)))))) + (term-previous-prompt n))) + +(defun vterm--get-beginning-of-line () + "Find the start of the line, bypassing line wraps." + (save-excursion + (beginning-of-line) + (while (and (not (bobp)) + (get-text-property (1- (point)) 'vterm-line-wrap)) + (forward-char -1) + (beginning-of-line)) + (point))) + +(defun vterm--get-end-of-line () + "Find the start of the line, bypassing line wraps." + (save-excursion + (end-of-line) + (while (get-text-property (point) 'vterm-line-wrap) + (forward-char) + (end-of-line)) + (point))) + +;; TODO: Improve doc string, it should not point to the readme but it should +;; be self-contained. +(defun vterm--get-prompt-point () + "Get the position of the end of current prompt. +More information see `vterm--prompt-tracking-enabled-p' and +`Directory tracking and Prompt tracking'in README." + (let ((end-point (vterm--get-end-of-line)) + prompt-point) + (save-excursion + (if (and vterm-use-vterm-prompt-detection-method + (vterm--prompt-tracking-enabled-p)) + (if (get-text-property end-point 'vterm-prompt) + end-point + (setq prompt-point (previous-single-property-change end-point 'vterm-prompt)) + (when prompt-point (setq prompt-point (1- prompt-point)))) + (goto-char end-point) + (if (search-backward-regexp term-prompt-regexp nil t) + (goto-char (match-end 0)) + (vterm--get-beginning-of-line)))))) + +(defun vterm--at-prompt-p () + "Return t if the cursor position is at shell prompt." + (= (point) (or (vterm--get-prompt-point) 0))) + +(defun vterm-cursor-in-command-buffer-p (&optional pt) + "Check whether cursor in command buffer area." + (save-excursion + (vterm-reset-cursor-point) + (let ((promp-pt (vterm--get-prompt-point)) + eol) + (when promp-pt + (goto-char promp-pt) + (setq eol (vterm--get-end-of-line)) + (<= promp-pt (or pt (vterm--get-cursor-point)) eol))))) + +(defun vterm-beginning-of-line () + "Move point to the beginning of the line. + +Move the point to the first character after the shell prompt on this line. +If the point is already there, move to the beginning of the line. +Effectively toggle between the two positions." + (interactive) + (if (vterm--at-prompt-p) + (goto-char (vterm--get-beginning-of-line)) + (goto-char (max (or (vterm--get-prompt-point) 0) + (vterm--get-beginning-of-line))))) + +(defun vterm-end-of-line () + "Move point to the end of the line, bypassing line wraps." + (interactive) + (goto-char (vterm--get-end-of-line))) + +(defun vterm-reset-cursor-point () + "Make sure the cursor at the right position." + (interactive) + (when vterm--term + (let ((inhibit-read-only t)) + (vterm--reset-point vterm--term)))) + +(defun vterm--get-cursor-point () + "Get term cursor position." + (when vterm--term + (save-excursion + (vterm-reset-cursor-point)))) + +(defun vterm--remove-fake-newlines () + "Filter out injected newlines were injected when rendering the terminal. + +These newlines were tagged with 'vterm-line-wrap property so we +can find them and remove them." + (goto-char (point-min)) + (let (fake-newline) + (while (setq fake-newline (next-single-property-change (point) + 'vterm-line-wrap)) + (goto-char fake-newline) + (cl-assert (eq ?\n (char-after))) + (let ((inhibit-read-only t)) + (vterm--delete-char 1))))) + + +(defun vterm--filter-buffer-substring (content) + "Filter string CONTENT of fake/injected newlines." + (with-temp-buffer + (vterm--insert content) + (vterm--remove-fake-newlines) + (buffer-string))) + + +(provide 'vterm) +;; Local Variables: +;; indent-tabs-mode: nil +;; End: +;;; vterm.el ends here diff --git a/settings/general-settings.el b/settings/general-settings.el index 43c1beca..9ea8f5d0 100644 --- a/settings/general-settings.el +++ b/settings/general-settings.el @@ -707,6 +707,8 @@ Version 2016-07-13" :style toggle :selected rainbow-mode :help "rainbow-mode"] ["Scroll-All" scroll-all-mode :style toggle :selected scroll-all-mode :help "scroll-all-mode"] + ["Semantic" semantic-mode + :style toggle :selected semantic-mode :help "semantic-mode"] ["Sphinx Doc [Ⓢ]" sphinx-doc-mode :style toggle :selected sphinx-doc-mode :help "sphinx-doc-mode"] ["YASnippet [Ⓨ]" yas-minor-mode diff --git a/settings/org-settings.el b/settings/org-settings.el index f7a2439a..a2568bff 100644 --- a/settings/org-settings.el +++ b/settings/org-settings.el @@ -261,10 +261,10 @@ Example defines (setq org-pretty-entities-include-sub-superscripts t) ;; if `org-pretty-entities' is active include also sub-superscripts. (setq org-image-actual-width '(600)) ;; image width displayed in org (setq org-startup-with-latex-preview t) ;; #+STARTUP: latexpreview|nolatexpreview - (setq org-format-latex-options + (setq org-format-latex-options ;; `org-preview-latex-process-alist' `org-preview-latex-default-process' scale better with this variable '(:foreground default :background default - :scale 1.75 + :scale 1.75 ;; scale inside org :html-foreground "Black" :html-background "Transparent" :html-scale 1.0 diff --git a/settings/shell-settings.el b/settings/shell-settings.el index 2889c628..b43e2e49 100644 --- a/settings/shell-settings.el +++ b/settings/shell-settings.el @@ -19,5 +19,9 @@ :init (setq eshell-directory-name (concat user-cache-directory "eshell/"))) +(use-package vterm + :load-path (lambda () (list (concat config-dir "lisp/vterm"))) + :commands (vterm)) + (provide 'shell-settings) ;;; shell-settings.el ends here