--- /dev/null
+/nbproject/private/
+/bin/
+/build/
+/dist/
+
--- /dev/null
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are 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.
+
+ 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.
+
+ Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+ A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+ The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+ An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+ 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+ Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+ 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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero 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.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+ 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 AGPL, see
+<http://www.gnu.org/licenses/>.
--- /dev/null
+
+dist_VERSION=1.2.99
+dist_NAME=dez
+dist_EXTRA=README COPYING.AGPL3 junit.make \
+ build.xml \
+ nbproject/build-impl.xml \
+ nbproject/genfiles.properties \
+ nbproject/project.properties \
+ nbproject/project.xml
+
+include config.make
+
+java_MODULES=notzed.dez notzed.dez.demo
+
+notzed.dez.demo_JDEPMOD = notzed.dez
+
+include java.make
+include junit.make
--- /dev/null
+
+INTRODUCTION
+------------
+
+This is a basic binary delta generator for in-memory files.
+
+It is ostensibly based on the algorithm from Bentley & McIllroy's
+paper ``Data Compression Using Long Common Strings''. Here however
+the hashes may be performed on overlapping blocks, possibly at every
+location.
+
+It includes an encoder and decoder for a proprietary (and still not
+quite fixed) delta format 'DEZ1' but standardised formats such as
+VCDIFF are possible by implementing a simple interface.
+
+The 'matcher' is also replaceable.
+
+COMPILING
+---------
+
+A GNU makefile is provided for GNU systems. A Java JDK supporting
+modular Java is required. OpenJDK 11 was used for this version.
+
+$ make
+
+Will make the modular jar files.
+
+`bin/notzed.dez/notzed.dez.jar'
+ Main library
+`bin/notzed.dez.demo/notzed.dez.demo.jar'
+ 'dez' tool and example classes.
+
+$ make check
+
+Will compile run the tests. They use junit4 from netbeans 11. The
+make check target is still experimental, see junit.make.
+
+The netbeans 11 project files are also included.
+
+USING
+-----
+
+See dez.java in the demo module, or the tests for an example of basic
+api usage.
+
+dez.java implements a simple command line tool.
+
+Create a patch:
+
+$ java --module-path bin/modules -m notzed.dez.demo/au.notzed.dez.demo.dez \
+ -c source target > patch
+
+The patch format is binary so redirecting the output is recommended.
+
+Decode a patch:
+
+$ java --module-path bin/modules -m notzed.dez.demo/au.notzed.dez.demo.dez \
+ -d source patch > recovered
+
+Print detailed patch contents:
+
+$ java --module-path bin/modules -m notzed.dez.demo/au.notzed.dez.demo.dez \
+ -p patch
+
+STATUS
+------
+
+As of 1.3 this could be considered pre-beta. The dez file format is
+now likely fixed but still may change. At the very least it requires
+a checksum for production use.
+
+There are now performance tunables to handle some nasty worst-case
+behaviour due to implementing an exhaustive search. These trade off
+delta size against cpu and memory use in the encoder. The decoder is
+unchanged.
+
+It needs more testing.
+
+The makefile is still work in progress.
+
+LINKS
+-----
+
+* DEZ <https://www.zedzone.space/software/dez.html>
+
+LICENSE
+-------
+
+The code is covered by the GNU Affero General Public License version 3
+(or later). See COPYING.AGPL3 for full details.
+
+ Copyright (C) 2015,2019 Michael Zucchi
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero 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
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public
+ License along with this program. If not, see
+ <http://www.gnu.org/licenses/>.
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- You may freely edit this file. See commented blocks below for -->
+<!-- some examples of how to customize the build. -->
+<!-- (If you delete it and reopen the project it will be recreated.) -->
+<!-- By default, only the Clean and Build commands use this build script. -->
+<!-- Commands such as Run, Debug, and Test only use this build script if -->
+<!-- the Compile on Save feature is turned off for the project. -->
+<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
+<!-- in the project's Project Properties dialog box.-->
+<project name="notzed.dez" default="default" basedir="." xmlns:j2semodularproject="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <description>Builds, tests, and runs the project notzed.dez.</description>
+ <import file="nbproject/build-impl.xml"/>
+ <!--
+
+ There exist several targets which are by default empty and which can be
+ used for execution of your tasks. These targets are usually executed
+ before and after some main targets. They are:
+
+ -pre-init: called before initialization of project properties
+ -post-init: called after initialization of project properties
+ -pre-compile: called before javac compilation
+ -post-compile: called after javac compilation
+ -pre-compile-single: called before javac compilation of single file
+ -post-compile-single: called after javac compilation of single file
+ -pre-compile-test: called before javac compilation of JUnit tests
+ -post-compile-test: called after javac compilation of JUnit tests
+ -pre-compile-test-single: called before javac compilation of single JUnit test
+ -post-compile-test-single: called after javac compilation of single JUunit test
+ -pre-jar: called before JAR building
+ -post-jar: called after JAR building
+ -post-clean: called after cleaning build products
+
+ (Targets beginning with '-' are not intended to be called on their own.)
+
+ Example of inserting an obfuscator after compilation could look like this:
+
+ <target name="-post-compile">
+ <obfuscate>
+ <fileset dir="${build.classes.dir}"/>
+ </obfuscate>
+ </target>
+
+ For list of available properties check the imported
+ nbproject/build-impl.xml file.
+
+
+ Another way to customize the build is by overriding existing main targets.
+ The targets of interest are:
+
+ -init-macrodef-javac: defines macro for javac compilation
+ -init-macrodef-junit: defines macro for junit execution
+ -init-macrodef-debug: defines macro for class debugging
+ -init-macrodef-java: defines macro for class execution
+ -do-jar: JAR building
+ run: execution of project
+ -javadoc-build: Javadoc generation
+ test-report: JUnit report generation
+
+ Notice that the overridden target depends on the jar target and not only on
+ the compile target as the regular run target does. Again, for a list of available
+ properties which you can use, check the target you are overriding in the
+ nbproject/build-impl.xml file.
+
+ -->
+</project>
--- /dev/null
+
+TARGET ?= linux-amd64
+
+JAVA_HOME ?= /usr/local/jdk-11.0.2
+JAVAFX_HOME ?= /usr/local/javafx-sdk-11.0.2
+FFMPEG_HOME ?= /opt/ffmpeg/4.0
+
+# See also JAVACFLAGS --module-path
+NATIVEZ_HOME=../nativez/bin/notzed.nativez/$(TARGET)
+
+JAVACFLAGS += --module-path $(JAVAFX_HOME)/lib:../nativez/bin/notzed.nativez
+JAVACFLAGS += -source 11
+
+JAVAC ?= javac
+JAR ?= jar
+JMOD ?= jmod
+
+# Linux options
+# USE_SO_VERSION adds the major version to the library open name for ffmpeg libs on linux.
+linux-amd64_CPPFLAGS = \
+ -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux \
+ -DUSE_SO_VERSION=1
+linux-amd64_CFLAGS = -fPIC -Os -Wall
+linux-amd64_CC = cc
+linux-amd64_LD = ld
+
+linux-amd64_SO = .so
+linux-amd64_LIB = lib
+
+# Windows options
+windows-amd64_CPPFLAGS = \
+ -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux \
+ -DHAVE_ALIGNED_MALLOC \
+ -DWIN32
+windows-amd64_CFLAGS = -Os -Wall
+windows-amd64_CC = x86_64-w64-mingw32-gcc
+windows-amd64_LD = x86_64-w64-mingw32-ld
+windows-amd64_LDFLAGS = -Wl,--subsystem,windows
+
+windows-amd64_SO = .dll
+windows-amd64_LIB =
--- /dev/null
+#
+# Copyright (C) 2019 Michael Zucchi
+#
+# This is the copyright for java.make
+#
+# 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 <http://www.gnu.org/licenses/>.
+#
+
+# General purpose modular java makefile that supports native library
+# compilation directly. Non-recrusve implementation.
+#
+# Uses metamake programming with some file conventions to implement
+# auto-make-like features.
+
+# Define modules
+# --------------
+# java_MODULES list of java modules to compile. The sources must
+# exist in src/<module>/classes. Resource files are
+# stored in src/<module>/classes. Source-code
+# generators must exist in src/<module>/gen. Native
+# libraries must exist in src/<module>/jni.
+
+# Global variables
+
+# JAVA_HOME location of jdk.
+# JAVAC java compiler to use. Default is 'javac' on the path.
+# JAVACFLAGS javac flags applied to all invocations.
+# JAR jar command.
+# JARFLAGS jar flags
+# JMOD jmod command.
+# JMODFLAGS jmod flags.
+
+# Module specific variables
+
+# <module>_JDEPMOD Lists modules which this one depends on.
+
+# <module>_JAVACFLAGS Extra module-specific flags for each command.
+# <module>_JARFLAGS
+# <module>_JMODFLAGS
+
+# <module>_JAVA Java sources. If not set it is found from src/<module>/classes/(*.java)
+# <module>_RESOURCES .jar resources. If not set it is found from src/<module>/classes/(not *.java)
+# <module>_JAVA_GENERATED Java generated sources. These must be relative to the package name.
+
+# Variables for use in fragments
+
+# gen.make and jni.make can additionally make use of these variables
+
+# <module>_gendir Location for files used in Java generation process (per project).
+# <module>_genjavadir Location where _JAVA_GENERATED .java files will be created (per project).
+# <module>_jnidir Location for jni generated files (per target).
+# <module>_objdir Location for c objects (per target).
+# <module>_incdir Location for output includes, .jmod staging.
+# <module>_libdir Location for output libraries, .jmod staging. May point to _bindir.
+# <module>_bindir Location for output commands, .jmod staging.
+
+# Define libraries
+# ----------------
+
+# Each module can define one or more native libraries.
+
+# These are compiled after the java sources have been compiled as that
+# process also generates any native binding headers.
+
+# <module>_JNI_LIBRARIES list of libraries to build.
+# library names match System.loadLibrary().
+
+# Global variables
+
+# <target>_LDFLAGS
+# <target>_LDLIBS
+# <target>_CPPFLAGS
+# <target>_CFLAGS
+# SO shared library suffix
+# LIB shared library prefix
+
+# Utility functions
+#
+# $(call library-path,<module>,<libname>) will resolve to the library file name.
+
+# Per library variables.
+
+# <library>_SOURCES .c, .cc, .C - source files for library. Paths are relative to src/<module>/jni.
+# <library>_HEADERS header files for jmod
+# <library>_COMMANDS commands/bin/scripts for jmod
+
+# <library>_LDFLAGS link flags
+# <library>_LIBADD extra objects to add to link line
+# <library>_LDLIBS link libraries
+# <library>_CPPFLAGS c pre-processor flags. "-Isrc/<module>/jni -Ibin/include/<module>" is implicit.
+# <library>_CCFLAGS c compiler flags
+
+# <library>_DEPENDENCIES A list of other objects on which this library depends before linking.
+
+# .c files have dependencies automatically generated
+
+# Targets
+# -------
+
+# make gen only generate java sources
+# make clean rm -rf bin
+# make dist create dist tar in bin/
+# make | make jar make all jars and jmods
+# make bin make everything but jars and mods
+
+# Outputs
+# -------
+
+# All intermediate and output files are written to bin/
+
+# This layout is enforced by javac
+# bin/include/<module>/ .h files from javac -h
+# bin/modules/<module>/ .class files from javac
+
+# This layout is convenient for netbeans
+# bin/gen/<module>/gen/ .c, exe files for generator free use
+# bin/gen/<module>/classes/ .java files from generator <module>_JAVA_GENERATED
+
+# bin/status/ marker files for makefile
+
+# bin/<module>/<module>.jar .jar modular
+
+# Native code
+
+# bin/<module>/<target>/lib .so librareies for jmod <module>_LIBRARIES = libname
+# bin/<module>/<target>/obj .o, .d files for library <libname>_SOURCES
+# bin/<module>/<target>/include .h files for jmod <libname>_HEADERS
+# bin/<module>/<target>/<module>.jmod .jmod module
+
+# ######################################################################
+
+E:=
+S:=$(E) $(E)
+
+# All modules with native code
+java_JMODS=$(foreach module,$(java_MODULES),$(if $(wildcard src/$(module)/jni/jni.make),$(module)))
+# Only modules with no native code
+java_JARS=$(foreach module,$(java_MODULES),$(if $(wildcard src/$(module)/jni/jni.make),,$(module)))
+# Modules with generated java source
+java_JGEN=$(foreach module,$(java_MODULES),$(if $(wildcard src/$(module)/gen/gen.make),$(module)))
+
+# Define some useful variables before including fragments
+define java_variables=
+$(1)_gendir:=bin/gen/$(1)/gen
+$(1)_genjavadir:=bin/gen/$(1)/classes
+$(1)_jnidir:=bin/$(1)/$(TARGET)/jni
+$(1)_objdir:=bin/$(1)/$(TARGET)/obj
+$(1)_incdir:=bin/$(1)/$(TARGET)/include
+$(1)_libdir:=$$(if $$(filter windows-%,$(TARGET)),bin/$(1)/$(TARGET)/bin,bin/$(1)/$(TARGET)/lib)
+$(1)_bindir:=bin/$(1)/$(TARGET)/bin
+ifndef $(1)_JAVA
+$(1)_JAVA := $$(shell find src/$(1)/classes -type f -name '*.java')
+endif
+ifndef $(1)_RESOURCES
+$(1)_RESOURCES := $$(shell find src/$(1)/classes -type f \! -name '*.java')
+endif
+endef
+
+$(foreach module,$(java_MODULES),$(eval $(call java_variables,$(module))))
+
+# ######################################################################
+
+all: jar
+bin:
+gen:
+
+.PHONY: all clean jar bin gen
+clean:
+ rm -rf bin
+
+include $(patsubst %,src/%/gen/gen.make,$(java_JGEN))
+include $(patsubst %,src/%/jni/jni.make,$(java_JMODS))
+
+# ######################################################################
+# Java
+# ######################################################################
+
+define java_targets=
+# Rules for module $(1)
+$(1)_JAVA_generated = $$(addprefix $$($(1)_genjavadir)/,$$($(1)_JAVA_GENERATED))
+
+bin/status/$(1).data: $$($(1)_RESOURCES)
+bin/status/$(1).classes: $(patsubst %,bin/status/%.classes,$($(1)_JDEPMOD)) $$($(1)_JAVA) $$($(1)_JAVA_generated)
+jar $(1): bin/$(1)/$(1).jar $(if $(wildcard src/$(1)/jni/jni.make),bin/$(1)/$(TARGET)/$(1).jmod)
+bin: bin/status/$(1).classes bin/status/$(1).data
+sources: bin/$(1)/$(1)-sources.zip
+gen: $$($(1)_JAVA_generated)
+
+# Create modular jar
+bin/$(1)/$(1).jar: bin/status/$(1).classes bin/status/$(1).data
+ @install -d $$(@D)
+ $(JAR) cf $$@ \
+ $(JARFLAGS) $$($(1)_JARFLAGS) \
+ -C bin/modules/$(1) .
+
+# Create a jmod
+bin/$(1)/$(TARGET)/$(1).jmod: bin/status/$(1).classes bin/status/$(1).data
+ rm -f $$@
+ @install -d $$(@D)
+ $$(JMOD) create \
+ $$(JMODFLAGS) $$($(1)_JMODFLAGS) \
+ --target-platform $(TARGET) \
+ --class-path bin/modules/$(1) \
+ $$(if $$(wildcard bin/$(1)/$(TARGET)/include),--header-files bin/$(1)/$(TARGET)/include) \
+ $$(if $$(wildcard src/$(1)/legal),--legal-notices src/$(1)/legal) \
+ $$(if $$(wildcard $$($(1)_bindir)),--cmds $$($(1)_bindir)) \
+ $$(if $$(wildcard $$($(1)_libdir)),--libs $$($(1)_libdir)) \
+ $$@
+
+# Create an IDE source zip, paths have to match --module-source-path
+bin/$(1)/$(1)-sources.zip: bin/status/$(1).classes
+ @install -d $$(@D)
+ jar -c -f $$@ -M \
+ $$(patsubst src/$(1)/classes/%,-C src/$(1)/classes %,$$(filter src/$(1)/classes/%,$$($(1)_JAVA))) \
+ $$(patsubst bin/gen/$(1)/classes/%,-C bin/gen/$(1)/classes %,$$(filter bin/gen/$(1)/classes/%,$$($(1)_JAVA)))
+
+endef
+
+#$(foreach module,$(java_MODULES),$(info $(call java_targets,$(module))))
+$(foreach module,$(java_MODULES),$(eval $(call java_targets,$(module))))
+
+# ######################################################################
+# Global pattern rules
+
+# Stage resources
+bin/status/%.data:
+ @install -d $(@D)
+ for data in $(patsubst src/$*/classes/%,"%",$($*_RESOURCES)) ; do \
+ install -vDC "src/$*/classes/$$data" "bin/modules/$*/$$data" || exit 1 ; \
+ done
+ touch $@
+
+# Compile one module. This only updates (javac -h) headers if they changed.
+bin/status/%.classes:
+ @install -d $(@D)
+ $(JAVAC) \
+ --module-source-path "src/*/classes:bin/gen/*/classes" \
+ $(JAVACFLAGS) $($*_JAVACFLAGS) \
+ -h bin/inc \
+ -d bin/modules \
+ -m $* \
+ $($*_JAVA) $($*_JAVA_generated)
+ if [ -d bin/inc/$* ] ; then \
+ install -DC -t bin/include/$* bin/inc/$*/*.h ; \
+ fi
+ touch $@
+
+# ######################################################################
+# C stuff
+# ######################################################################
+
+SUFFIXES=.c .C .cc
+SO=$($(TARGET)_SO)
+LIB=$($(TARGET)_LIB)
+
+# functions to find cross-module stuff $(call library-path,modname,libname)
+library-path=bin/$(1)/$(TARGET)/lib/$(LIB)$(2)$(SO)
+library-dir=bin/$(1)/$(TARGET)/lib/
+
+define jni_library=
+# Rule for library $(2) in module $(1)
+$(2)_OBJS = $(foreach sx,$(SUFFIXES),$(patsubst %$(sx), $($(1)_objdir)/%.o, $(filter %$(sx),$($(2)_SOURCES))))
+$(2)_SRCS = $(addprefix src/$(1)/jni/,$($(2)_SOURCES))
+
+$($(1)_libdir)/$(LIB)$(2)$(SO): $$($(2)_OBJS) $($(2)_LIBADD) $($(2)_DEPENDENCIES)
+ @install -d $$(@D)
+ $($(TARGET)_CC) -o $$@ -shared \
+ $($(TARGET)_LDFLAGS) $($(2)_LDFLAGS) $$($(2)_OBJS) $($(2)_LIBADD) $($(TARGET)_LDLIBS) $($(2)_LDLIBS)
+
+$($(1)_objdir)/%.o: src/$(1)/jni/%.c bin/status/$(1).classes
+ @install -d $$(@D)
+ $($(TARGET)_CC) -Isrc/$(1)/jni -Ibin/include/$(1) $($(TARGET)_CPPFLAGS) $($(2)_CPPFLAGS) \
+ $($(TARGET)_CFLAGS) $($(2)_CFLAGS) -c -o $$@ $$<
+
+$($(1)_incdir)/%.h: src/$(1)/jni/%.h
+ install -D $$< $$@
+
+$($(1)_objdir)/%.d: src/$(1)/jni/%.c bin/status/$(1).classes
+ @install -d $$(@D)
+ @rm -f $$@
+ @$($(TARGET)_CC) -MM -MT "bin/$(1)/$(TARGET)/obj/$$*.o" -Isrc/$(1)/jni -Ibin/include/$(1) \
+ $($(TARGET)_CPPFLAGS) $($(2)_CPPFLAGS) $$< -o $$@.d 2>/dev/null
+ @sed 's,\($$*\.o\) *:,\1 $$@ : ,g' $$@.d > $$@ ; rm $$@.d
+
+bin jni $(1) bin/$(1)/$(TARGET)/$(1).jmod: $($(1)_libdir)/$(LIB)$(2)$(SO) \
+ $(addprefix $($(1)_incdir)/,$($(2)_HEADERS)) \
+ $(addprefix $($(1)_bindir)/,$($(2)_COMMANDS))
+
+$(if $(filter clean dist gen,$(MAKECMDGOALS)),,-include $$($(2)_OBJS:.o=.d))
+endef
+
+#$(foreach module,$(java_JMODS),$(foreach library,$($(module)_JNI_LIBRARIES),$(info $(call jni_library,$(module),$(library)))))
+$(foreach module,$(java_JMODS),$(foreach library,$($(module)_JNI_LIBRARIES),$(eval $(call jni_library,$(module),$(library)))))
+
+# ######################################################################
+
+dist:
+ @install -d bin
+ tar cfz bin/$(dist_NAME)-$(dist_VERSION).tar.gz \
+ --transform=s,^,$(dist_NAME)-$(dist_VERSION)/, \
+ config.make java.make Makefile src \
+ $(dist_EXTRA)
+
--- /dev/null
+#
+# Copyright (C) 2019 Michael Zucchi
+#
+# This is the copyright for java.make
+#
+# 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 <http://www.gnu.org/licenses/>.
+#
+
+# ######################################################################
+# junit(4) makefile fragment
+
+# This is still in development.
+
+# This should be compatible with the way the ant task (and netbeans)
+# runs the same junit4 tests
+
+# It needs some parameterisation, e.g. module path, generated tests,
+# etc.
+
+# Where to get junit4:
+# http://central.maven.org/maven2/junit/junit/4.12/junit-4.12.jar
+# http://central.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar
+
+# this is from netbeans 11
+junit4_classpath ?= /usr/local/netbeans-11.0/platform/modules/ext/junit-4.12.jar \
+ /usr/local/netbeans-11.0/platform/modules/ext/hamcrest-core-1.3.jar
+junit4_runner ?= org.junit.runner.JUnitCore
+
+# ######################################################################
+
+define java_tests=
+ifndef $(1)_TEST_JAVA
+$(1)_TEST_JAVA := $$(shell find src/$(1)/tests -type f -name '*.java')
+$(1)_TEST := $$(subst /,.,$$(basename $$(shell find src/$(1)/tests -type f -name '*Test.java' -printf '%P\n')))
+$(1)_IT := $$(subst /,.,$$(basename $$(shell find src/$(1)/tests -type f -name '*IT.java' -printf '%P\n')))
+endif
+
+test: $(1)-test
+test-it: $(1)-it
+check: $(1)-test $(1)-it
+bin/status/$(1).tests: bin/status/$(1).classes $(notzed.dez_TEST_JAVA)
+endef
+
+$(foreach module,$(java_MODULES),$(if $(wildcard src/$(module)/tests),$(eval $(call java_tests,$(module)))))
+
+# ######################################################################
+
+bin/status/%.tests:
+ @install -d $(@D)
+ $(JAVAC) \
+ -classpath $(subst $(S),:,$(junit4_classpath) ) \
+ --patch-module $*=src/$*/tests \
+ --add-reads $*=ALL-UNNAMED \
+ -source 11 \
+ --module-source-path 'src/*/tests' \
+ --module-path bin/modules \
+ -d bin/tests \
+ $($*_TEST_JAVA)
+ touch $@
+
+%-test: bin/status/%.tests
+ java \
+ --class-path $(subst $(S),:,$(junit4_classpath)) \
+ --module-path bin/modules \
+ --patch-module $*=bin/tests/$* \
+ --add-modules $* \
+ --add-reads $*=ALL-UNNAMED \
+ $(junit4_runner) \
+ $($*_TEST)
+
+%-it: bin/status/%.tests
+ java \
+ --class-path $(subst $(S),:,$(junit4_classpath)) \
+ --module-path bin/modules \
+ --patch-module $*=bin/tests/$* \
+ --add-modules $* \
+ --add-reads $*=ALL-UNNAMED \
+ $(junit4_runner) \
+ $($*_IT)
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+*** GENERATED FROM project.xml - DO NOT EDIT ***
+*** EDIT ../build.xml INSTEAD ***
+
+For the purpose of easier reading the script
+is divided into following sections:
+
+ - initialization
+ - compilation
+ - jar
+ - execution
+ - debugging
+ - javadoc
+ - test compilation
+ - test execution
+ - test debugging
+ - applet
+ - cleanup
+
+ -->
+<project xmlns:if="ant:if" xmlns:unless="ant:unless" basedir=".." default="default" name="notzed.dez-impl">
+ <fail message="Please build using Ant 1.9.7 or higher.">
+ <condition>
+ <not>
+ <antversion atleast="1.9.7"/>
+ </not>
+ </condition>
+ </fail>
+ <target depends="test,jar,javadoc" description="Build and test whole project." name="default"/>
+ <!--
+ ======================
+ INITIALIZATION SECTION
+ ======================
+ -->
+ <target name="-pre-init">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="-pre-init" name="-init-private">
+ <property file="nbproject/private/config.properties"/>
+ <property file="nbproject/private/configs/${config}.properties"/>
+ <property file="nbproject/private/private.properties"/>
+ </target>
+ <target depends="-pre-init,-init-private" name="-init-user">
+ <property file="${user.properties.file}"/>
+ <!-- The two properties below are usually overridden -->
+ <!-- by the active platform. Just a fallback. -->
+ <property name="default.javac.source" value="9"/>
+ <property name="default.javac.target" value="9"/>
+ </target>
+ <target depends="-pre-init,-init-private,-init-user" name="-init-project">
+ <property file="nbproject/configs/${config}.properties"/>
+ <property file="nbproject/project.properties"/>
+ </target>
+ <target name="-init-source-module-properties">
+ <property name="javac.modulepath" value=""/>
+ <property name="run.modulepath" value="${javac.modulepath}:${build.modules.dir}"/>
+ <property name="debug.modulepath" value="${run.modulepath}"/>
+ <property name="javac.upgrademodulepath" value=""/>
+ <property name="run.upgrademodulepath" value="${javac.upgrademodulepath}"/>
+ <condition else="" property="javac.systemmodulepath.cmd.line.arg" value="-system '${javac.systemmodulepath}'">
+ <and>
+ <isset property="javac.systemmodulepath"/>
+ <length length="0" string="${javac.systemmodulepath}" when="greater"/>
+ </and>
+ </condition>
+ <property name="dist.jlink.dir" value="${dist.dir}/jlink"/>
+ <property name="dist.jlink.output" value="${dist.jlink.dir}/${application.title}"/>
+ </target>
+ <target depends="-pre-init,-init-private,-init-user,-init-project,-init-macrodef-property" name="-do-init">
+ <property name="platform.java" value="${java.home}/bin/java"/>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" modsource="${test.src.dir.path}" property="have.tests.test.src.dir.regexp"/>
+ <dirset dir="${basedir}/${test.src.dir}" id="have.tests.test.src.dir.set" includes="*/*">
+ <filename regex="${have.tests.test.src.dir.regexp}"/>
+ </dirset>
+ <union id="have.tests.set">
+ <dirset refid="have.tests.test.src.dir.set"/>
+ </union>
+ <condition property="have.tests">
+ <or>
+ <resourcecount count="0" when="greater">
+ <union refid="have.tests.set"/>
+ </resourcecount>
+ </or>
+ </condition>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" modsource="${test.src.dir.path}" property="have.tests.test.src.dir.regexp"/>
+ <dirset dir="${basedir}/${test.src.dir}" id="have.tests.test.src.dir.patchset" includes="*/*">
+ <filename regex="${have.tests.test.src.dir.regexp}"/>
+ <scriptselector language="javascript">
+ self.setSelected(!new java.io.File(file, "module-info.java").exists());
+ </scriptselector>
+ </dirset>
+ <union id="have.tests.patchset">
+ <dirset refid="have.tests.test.src.dir.patchset"/>
+ </union>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" modsource="${src.dir.path}" property="have.sources.src.dir.regexp"/>
+ <dirset dir="${basedir}/${src.dir}" id="have.sources.src.dir.set" includes="*/*">
+ <filename regex="${have.sources.src.dir.regexp}"/>
+ </dirset>
+ <union id="have.sources.set">
+ <dirset refid="have.sources.src.dir.set"/>
+ </union>
+ <condition property="have.sources">
+ <or>
+ <resourcecount count="0" when="greater">
+ <union refid="have.sources.set"/>
+ </resourcecount>
+ </or>
+ </condition>
+ <condition property="main.class.available">
+ <and>
+ <isset property="main.class"/>
+ <not>
+ <equals arg1="${main.class}" arg2="" trim="true"/>
+ </not>
+ </and>
+ </condition>
+ <condition property="netbeans.home+have.tests">
+ <and>
+ <isset property="netbeans.home"/>
+ <isset property="have.tests"/>
+ </and>
+ </condition>
+ <condition property="no.javadoc.preview">
+ <and>
+ <isset property="javadoc.preview"/>
+ <isfalse value="${javadoc.preview}"/>
+ </and>
+ </condition>
+ <condition property="do.archive">
+ <or>
+ <not>
+ <istrue value="${jar.archive.disabled}"/>
+ </not>
+ <istrue value="${not.archive.disabled}"/>
+ </or>
+ </condition>
+ <property name="run.jvmargs" value=""/>
+ <property name="run.jvmargs.ide" value=""/>
+ <property name="javac.compilerargs" value=""/>
+ <property name="work.dir" value="${basedir}"/>
+ <condition property="no.deps">
+ <and>
+ <istrue value="${no.dependencies}"/>
+ </and>
+ </condition>
+ <property name="javac.debug" value="true"/>
+ <property name="javadoc.preview" value="true"/>
+ <property name="application.args" value=""/>
+ <property name="source.encoding" value="${file.encoding}"/>
+ <property name="runtime.encoding" value="${source.encoding}"/>
+ <condition property="javadoc.encoding.used" value="${javadoc.encoding}">
+ <and>
+ <isset property="javadoc.encoding"/>
+ <not>
+ <equals arg1="${javadoc.encoding}" arg2=""/>
+ </not>
+ </and>
+ </condition>
+ <property name="javadoc.encoding.used" value="${source.encoding}"/>
+ <property name="includes" value="**"/>
+ <property name="excludes" value=""/>
+ <property name="do.depend" value="false"/>
+ <condition property="do.depend.true">
+ <istrue value="${do.depend}"/>
+ </condition>
+ <path id="endorsed.classpath.path" path="${endorsed.classpath}"/>
+ <condition else="" property="endorsed.classpath.cmd.line.arg" value="-Xbootclasspath/p:'${toString:endorsed.classpath.path}'">
+ <and>
+ <isset property="endorsed.classpath"/>
+ <not>
+ <equals arg1="${endorsed.classpath}" arg2="" trim="true"/>
+ </not>
+ </and>
+ </condition>
+ <condition else="" property="javac.profile.cmd.line.arg" value="-profile ${javac.profile}">
+ <isset property="profile.available"/>
+ </condition>
+ <condition else="false" property="jdkBug6558476">
+ <and>
+ <matches pattern="1\.[56]" string="${java.specification.version}"/>
+ <not>
+ <os family="unix"/>
+ </not>
+ </and>
+ </condition>
+ <condition else="false" property="javac.fork">
+ <or>
+ <istrue value="${jdkBug6558476}"/>
+ <istrue value="${javac.external.vm}"/>
+ </or>
+ </condition>
+ <condition property="main.class.check.available">
+ <and>
+ <isset property="libs.CopyLibs.classpath"/>
+ <available classname="org.netbeans.modules.java.j2seproject.moduletask.ModuleMainClass" classpath="${libs.CopyLibs.classpath}"/>
+ </and>
+ </condition>
+ <property name="jar.index" value="false"/>
+ <property name="jar.index.metainf" value="${jar.index}"/>
+ <condition property="junit.available">
+ <or>
+ <available classname="org.junit.Test" classpath="${run.test.classpath}"/>
+ <available classname="junit.framework.Test" classpath="${run.test.classpath}"/>
+ </or>
+ </condition>
+ <condition property="testng.available">
+ <available classname="org.testng.annotations.Test" classpath="${run.test.classpath}"/>
+ </condition>
+ <condition property="junit+testng.available">
+ <and>
+ <istrue value="${junit.available}"/>
+ <istrue value="${testng.available}"/>
+ </and>
+ </condition>
+ <condition else="testng" property="testng.mode" value="mixed">
+ <istrue value="${junit+testng.available}"/>
+ </condition>
+ <condition else="" property="testng.debug.mode" value="-mixed">
+ <istrue value="${junit+testng.available}"/>
+ </condition>
+ <property name="java.failonerror" value="true"/>
+ <macrodef name="for-paths" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute name="paths"/>
+ <attribute default="${path.separator}" name="separator"/>
+ <element implicit="yes" name="call"/>
+ <sequential>
+ <local name="entry"/>
+ <local name="tail"/>
+ <local name="moreElements"/>
+ <loadresource property="entry" quiet="true" unless:blank="@{paths}">
+ <concat>@{paths}</concat>
+ <filterchain>
+ <replaceregex pattern="([^@{separator}]*)\Q@{separator}\E.*" replace="\1"/>
+ </filterchain>
+ </loadresource>
+ <sequential if:set="entry">
+ <call/>
+ </sequential>
+ <condition else="false" property="moreElements" value="true">
+ <contains string="@{paths}" substring="@{separator}"/>
+ </condition>
+ <loadresource if:true="${moreElements}" property="tail" quiet="true">
+ <concat>@{paths}</concat>
+ <filterchain>
+ <replaceregex pattern="[^@{separator}]*\Q@{separator}\E(.*)" replace="\1"/>
+ </filterchain>
+ </loadresource>
+ <j2semodularproject1:for-paths xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" if:true="${moreElements}" paths="${tail}">
+ <call/>
+ </j2semodularproject1:for-paths>
+ </sequential>
+ </macrodef>
+ <property name="modules.supported.internal" value="true"/>
+ <condition else="${file.separator}" property="file.separator.string" value="\${file.separator}">
+ <equals arg1="${file.separator}" arg2="\"/>
+ </condition>
+ </target>
+ <target name="-post-init">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="-pre-init,-init-private,-init-user,-init-project,-do-init" name="-init-check">
+ <fail unless="src.dir">Must set src.dir</fail>
+ <fail unless="test.src.dir">Must set test.src.dir</fail>
+ <fail unless="build.dir">Must set build.dir</fail>
+ <fail unless="dist.dir">Must set dist.dir</fail>
+ <fail unless="build.modules.dir">Must set build.modules.dir</fail>
+ <fail unless="dist.javadoc.dir">Must set dist.javadoc.dir</fail>
+ <fail unless="build.test.modules.dir">Must set build.test.modules.dir</fail>
+ <fail unless="build.test.results.dir">Must set build.test.results.dir</fail>
+ <fail unless="build.classes.excludes">Must set build.classes.excludes</fail>
+ <fail message="Java 9 support requires Ant 1.10.0 or higher.">
+ <condition>
+ <not>
+ <antversion atleast="1.10.0"/>
+ </not>
+ </condition>
+ </fail>
+ </target>
+ <target name="-init-macrodef-property">
+ <macrodef name="property" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute name="name"/>
+ <attribute name="value"/>
+ <sequential>
+ <property name="@{name}" value="${@{value}}"/>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-ap-cmdline-properties,-init-source-module-properties" name="-init-macrodef-javac">
+ <macrodef name="javac" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${build.modules.dir}" name="destdir"/>
+ <attribute default="${javac.classpath}" name="classpath"/>
+ <attribute default="${javac.modulepath}" name="modulepath"/>
+ <attribute default="${src.dir}/*/${src.dir.path}" name="modulesourcepath"/>
+ <attribute default="${javac.upgrademodulepath}" name="upgrademodulepath"/>
+ <attribute default="${javac.processorpath}" name="processorpath"/>
+ <attribute default="${javac.processormodulepath}" name="processormodulepath"/>
+ <attribute default="${build.generated.sources.dir}/ap-source-output" name="apgeneratedsrcdir"/>
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="${javac.debug}" name="debug"/>
+ <attribute default="${empty.dir}" name="gensrcdir"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <property location="${build.dir}/empty" name="empty.dir"/>
+ <mkdir dir="${empty.dir}"/>
+ <mkdir dir="@{apgeneratedsrcdir}"/>
+ <condition property="processormodulepath.set">
+ <resourcecount count="0" when="greater">
+ <path>
+ <pathelement path="@{processormodulepath}"/>
+ </path>
+ </resourcecount>
+ </condition>
+ <javac debug="@{debug}" deprecation="${javac.deprecation}" destdir="@{destdir}" encoding="${source.encoding}" excludes="@{excludes}" fork="${javac.fork}" includeantruntime="false" includes="@{includes}" source="${javac.source}" target="${javac.target}" tempdir="${java.io.tmpdir}">
+ <classpath>
+ <path path="@{classpath}"/>
+ </classpath>
+ <modulepath>
+ <path path="@{modulepath}"/>
+ </modulepath>
+ <modulesourcepath>
+ <path path="@{modulesourcepath}"/>
+ </modulesourcepath>
+ <upgrademodulepath>
+ <path path="@{upgrademodulepath}"/>
+ </upgrademodulepath>
+ <compilerarg line="${javac.systemmodulepath.cmd.line.arg}"/>
+ <compilerarg line="${javac.profile.cmd.line.arg}"/>
+ <compilerarg line="${javac.compilerargs}"/>
+ <compilerarg if:set="processormodulepath.set" value="--processor-module-path"/>
+ <compilerarg if:set="processormodulepath.set" path="@{processormodulepath}"/>
+ <compilerarg unless:set="processormodulepath.set" value="-processorpath"/>
+ <compilerarg path="@{processorpath}:${empty.dir}" unless:set="processormodulepath.set"/>
+ <compilerarg line="${ap.processors.internal}"/>
+ <compilerarg line="${annotation.processing.processor.options}"/>
+ <compilerarg value="-s"/>
+ <compilerarg path="@{apgeneratedsrcdir}"/>
+ <compilerarg line="${ap.proc.none.internal}"/>
+ <customize/>
+ </javac>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-javac" name="-init-macrodef-javac-depend">
+ <macrodef name="depend" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${src.dir}" name="srcdir"/>
+ <attribute default="${build.classes.dir}" name="destdir"/>
+ <attribute default="${javac.classpath}" name="classpath"/>
+ <sequential>
+ <depend cache="${build.dir}/depcache" destdir="@{destdir}" excludes="${excludes}" includes="${includes}" srcdir="@{srcdir}">
+ <classpath>
+ <path path="@{classpath}"/>
+ </classpath>
+ </depend>
+ </sequential>
+ </macrodef>
+ <macrodef name="force-recompile" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${build.modules.dir}" name="destdir"/>
+ <sequential>
+ <fail unless="javac.includes">Must set javac.includes</fail>
+ <pathconvert pathsep="${line.separator}" property="javac.includes.binary">
+ <path>
+ <filelist dir="@{destdir}" files="${javac.includes}"/>
+ </path>
+ <globmapper from="*.java" to="*.class"/>
+ </pathconvert>
+ <tempfile deleteonexit="true" property="javac.includesfile.binary"/>
+ <echo file="${javac.includesfile.binary}" message="${javac.includes.binary}"/>
+ <delete>
+ <files includesfile="${javac.includesfile.binary}"/>
+ </delete>
+ <delete>
+ <fileset file="${javac.includesfile.binary}"/>
+ </delete>
+ </sequential>
+ </macrodef>
+ </target>
+ <target if="${junit.available}" name="-init-macrodef-junit-init">
+ <condition else="false" property="nb.junit.batch" value="true">
+ <and>
+ <istrue value="${junit.available}"/>
+ <not>
+ <isset property="test.method"/>
+ </not>
+ </and>
+ </condition>
+ <condition else="false" property="nb.junit.single" value="true">
+ <and>
+ <istrue value="${junit.available}"/>
+ <isset property="test.method"/>
+ </and>
+ </condition>
+ </target>
+ <target name="-init-test-properties">
+ <property name="test.binaryincludes" value="<nothing>"/>
+ <property name="test.binarytestincludes" value=""/>
+ <property name="test.binaryexcludes" value=""/>
+ </target>
+ <target name="-init-macrodef-junit-prototype">
+ <macrodef name="junit-prototype" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <element name="customizePrototype" optional="true"/>
+ <sequential>
+ <property location="${build.dir}/empty" name="empty.dir"/>
+ <property name="junit.forkmode" value="perTest"/>
+ <junit dir="${work.dir}" errorproperty="tests.failed" failureproperty="tests.failed" fork="true" forkmode="${junit.forkmode}" showoutput="true" tempdir="${build.dir}">
+ <syspropertyset>
+ <propertyref prefix="test-sys-prop."/>
+ <mapper from="test-sys-prop.*" to="*" type="glob"/>
+ </syspropertyset>
+ <classpath>
+ <path path="${run.test.classpath}"/>
+ </classpath>
+ <formatter type="brief" usefile="false"/>
+ <formatter type="xml"/>
+ <jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
+ <jvmarg value="-ea"/>
+ <jvmarg value="--module-path"/>
+ <jvmarg path="${run.modulepath}${path.separator}${run.test.modulepath}${path.separator}${empty.dir}"/>
+ <jvmarg line="${run.test.jvmargs}"/>
+ <customizePrototype/>
+ </junit>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-test-properties,-init-macrodef-junit-prototype" if="${nb.junit.single}" name="-init-macrodef-junit-single" unless="${nb.junit.batch}">
+ <macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <j2semodularproject1:junit-prototype xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <customizePrototype>
+ <test methods="@{testmethods}" name="@{testincludes}" todir="${build.test.results.dir}"/>
+ <customize/>
+ </customizePrototype>
+ </j2semodularproject1:junit-prototype>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-test-properties,-init-macrodef-junit-prototype" if="${nb.junit.batch}" name="-init-macrodef-junit-batch" unless="${nb.junit.single}">
+ <macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <j2semodularproject1:junit-prototype xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <customizePrototype>
+ <batchtest todir="${build.test.results.dir}">
+ <mappedresources>
+ <union>
+ <fileset dir="${test.src.dir}" excludes="@{excludes},${excludes}" includes="**/@{includes}">
+ <filename name="**/@{testincludes}"/>
+ <filename regex="${have.tests.test.src.dir.regexp}"/>
+ </fileset>
+ </union>
+ <regexpmapper from="${have.tests.test.src.dir.regexp}\Q${file.separator}\E(.*)$" to="\3"/>
+ </mappedresources>
+ <fileset dir="${build.test.modules.dir}" excludes="@{excludes},${excludes},${test.binaryexcludes}" includes="${test.binaryincludes}">
+ <filename name="${test.binarytestincludes}"/>
+ </fileset>
+ </batchtest>
+ <customize/>
+ </customizePrototype>
+ </j2semodularproject1:junit-prototype>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-junit-init,-init-macrodef-junit-single, -init-macrodef-junit-batch" if="${junit.available}" name="-init-macrodef-junit"/>
+ <target if="${testng.available}" name="-init-macrodef-testng">
+ <macrodef name="testng" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <condition else="" property="testng.methods.arg" value="@{testincludes}.@{testmethods}">
+ <isset property="test.method"/>
+ </condition>
+ <union id="test.set">
+ <fileset dir="${test.src.dir}" excludes="@{excludes},**/*.xml,${excludes}" includes="@{includes}">
+ <filename name="@{testincludes}"/>
+ </fileset>
+ </union>
+ <taskdef classname="org.testng.TestNGAntTask" classpath="${run.test.classpath}" name="testng"/>
+ <testng classfilesetref="test.set" failureProperty="tests.failed" listeners="org.testng.reporters.VerboseReporter" methods="${testng.methods.arg}" mode="${testng.mode}" outputdir="${build.test.results.dir}" suitename="notzed.dez" testname="TestNG tests" workingDir="${work.dir}">
+ <xmlfileset dir="${build.test.classes.dir}" includes="@{testincludes}"/>
+ <propertyset>
+ <propertyref prefix="test-sys-prop."/>
+ <mapper from="test-sys-prop.*" to="*" type="glob"/>
+ </propertyset>
+ <classpath>
+ <path path="${run.test.classpath}"/>
+ </classpath>
+ <jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
+ <customize/>
+ </testng>
+ </sequential>
+ </macrodef>
+ </target>
+ <target name="-init-macrodef-test-impl">
+ <macrodef name="test-impl" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element implicit="true" name="customize" optional="true"/>
+ <sequential>
+ <echo>No tests executed.</echo>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-junit" if="${junit.available}" name="-init-macrodef-junit-impl">
+ <macrodef name="test-impl" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element implicit="true" name="customize" optional="true"/>
+ <sequential>
+ <j2semodularproject1:junit xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="@{excludes}" includes="@{includes}" testincludes="@{testincludes}" testmethods="@{testmethods}">
+ <customize/>
+ </j2semodularproject1:junit>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-testng" if="${testng.available}" name="-init-macrodef-testng-impl">
+ <macrodef name="test-impl" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element implicit="true" name="customize" optional="true"/>
+ <sequential>
+ <j2semodularproject1:testng xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="@{excludes}" includes="@{includes}" testincludes="@{testincludes}" testmethods="@{testmethods}">
+ <customize/>
+ </j2semodularproject1:testng>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-test-impl,-init-macrodef-junit-impl,-init-macrodef-testng-impl" name="-init-macrodef-test">
+ <macrodef name="test" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <sequential>
+ <j2semodularproject1:test-impl xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="@{excludes}" includes="@{includes}" testincludes="@{testincludes}" testmethods="@{testmethods}">
+ <customize>
+ <jvmarg line="${run.jvmargs}"/>
+ <jvmarg line="${run.jvmargs.ide}"/>
+ </customize>
+ </j2semodularproject1:test-impl>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-junit" if="${junit.available}" name="-init-macrodef-junit-debug-impl">
+ <macrodef name="test-debug-impl" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <element name="customizeDebuggee" optional="true"/>
+ <sequential>
+ <j2semodularproject1:junit xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="@{excludes}" includes="@{includes}" testincludes="@{testincludes}" testmethods="@{testmethods}">
+ <customize>
+ <jvmarg value="-agentlib:jdwp=transport=${debug-transport},address=${jpda.address}"/>
+ <customizeDebuggee/>
+ </customize>
+ </j2semodularproject1:junit>
+ </sequential>
+ </macrodef>
+ </target>
+ <target if="${testng.available}" name="-init-macrodef-testng-debug">
+ <macrodef name="testng-debug" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${main.class}" name="testClass"/>
+ <attribute default="" name="testMethod"/>
+ <element name="customize2" optional="true"/>
+ <sequential>
+ <condition else="-testclass @{testClass}" property="test.class.or.method" value="-methods @{testClass}.@{testMethod}">
+ <isset property="test.method"/>
+ </condition>
+ <condition else="-suitename notzed.dez -testname @{testClass} ${test.class.or.method}" property="testng.cmd.args" value="@{testClass}">
+ <matches pattern=".*\.xml" string="@{testClass}"/>
+ </condition>
+ <delete dir="${build.test.results.dir}" quiet="true"/>
+ <mkdir dir="${build.test.results.dir}"/>
+ <j2semodularproject1:debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="org.testng.TestNG" classpath="${debug.test.classpath}">
+ <customizeDebuggee>
+ <customize2/>
+ <jvmarg value="-ea"/>
+ <arg line="${testng.debug.mode}"/>
+ <arg line="-d ${build.test.results.dir}"/>
+ <arg line="-listener org.testng.reporters.VerboseReporter"/>
+ <arg line="${testng.cmd.args}"/>
+ </customizeDebuggee>
+ </j2semodularproject1:debug>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-testng-debug" if="${testng.available}" name="-init-macrodef-testng-debug-impl">
+ <macrodef name="testng-debug-impl" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${main.class}" name="testClass"/>
+ <attribute default="" name="testMethod"/>
+ <element implicit="true" name="customize2" optional="true"/>
+ <sequential>
+ <j2semodularproject1:testng-debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" testClass="@{testClass}" testMethod="@{testMethod}">
+ <customize2/>
+ </j2semodularproject1:testng-debug>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-junit-debug-impl" if="${junit.available}" name="-init-macrodef-test-debug-junit">
+ <macrodef name="test-debug" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <attribute default="${main.class}" name="testClass"/>
+ <attribute default="" name="testMethod"/>
+ <sequential>
+ <j2semodularproject1:test-debug-impl xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="@{excludes}" includes="@{includes}" testincludes="@{testincludes}" testmethods="@{testmethods}">
+ <customizeDebuggee>
+ <jvmarg line="${run.jvmargs}"/>
+ <jvmarg line="${run.jvmargs.ide}"/>
+ </customizeDebuggee>
+ </j2semodularproject1:test-debug-impl>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-testng-debug-impl" if="${testng.available}" name="-init-macrodef-test-debug-testng">
+ <macrodef name="test-debug" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <attribute default="**" name="testincludes"/>
+ <attribute default="" name="testmethods"/>
+ <attribute default="${main.class}" name="testClass"/>
+ <attribute default="" name="testMethod"/>
+ <sequential>
+ <j2semodularproject1:testng-debug-impl xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" testClass="@{testClass}" testMethod="@{testMethod}">
+ <customize2>
+ <syspropertyset>
+ <propertyref prefix="test-sys-prop."/>
+ <mapper from="test-sys-prop.*" to="*" type="glob"/>
+ </syspropertyset>
+ </customize2>
+ </j2semodularproject1:testng-debug-impl>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-macrodef-test-debug-junit,-init-macrodef-test-debug-testng" name="-init-macrodef-test-debug"/>
+ <!--
+ pre NB7.2 profiling section; consider it deprecated
+ -->
+ <target depends="-profile-pre-init, init, -profile-post-init, -profile-init-macrodef-profile, -profile-init-check" if="profiler.info.jvmargs.agent" name="profile-init"/>
+ <target if="profiler.info.jvmargs.agent" name="-profile-pre-init">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target if="profiler.info.jvmargs.agent" name="-profile-post-init">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target if="profiler.info.jvmargs.agent" name="-profile-init-macrodef-profile">
+ <macrodef name="resolve">
+ <attribute name="name"/>
+ <attribute name="value"/>
+ <sequential>
+ <property name="@{name}" value="${env.@{value}}"/>
+ </sequential>
+ </macrodef>
+ <macrodef name="profile">
+ <attribute default="${main.class}" name="classname"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <property environment="env"/>
+ <resolve name="profiler.current.path" value="${profiler.info.pathvar}"/>
+ <java classname="@{classname}" dir="${profiler.info.dir}" failonerror="${java.failonerror}" fork="true" jvm="${profiler.info.jvm}">
+ <jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
+ <jvmarg value="${profiler.info.jvmargs.agent}"/>
+ <jvmarg line="${profiler.info.jvmargs}"/>
+ <env key="${profiler.info.pathvar}" path="${profiler.info.agentpath}:${profiler.current.path}"/>
+ <arg line="${application.args}"/>
+ <classpath>
+ <path path="${run.classpath}"/>
+ </classpath>
+ <syspropertyset>
+ <propertyref prefix="run-sys-prop."/>
+ <mapper from="run-sys-prop.*" to="*" type="glob"/>
+ </syspropertyset>
+ <customize/>
+ </java>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-profile-pre-init, init, -profile-post-init, -profile-init-macrodef-profile" if="profiler.info.jvmargs.agent" name="-profile-init-check">
+ <fail unless="profiler.info.jvm">Must set JVM to use for profiling in profiler.info.jvm</fail>
+ <fail unless="profiler.info.jvmargs.agent">Must set profiler agent JVM arguments in profiler.info.jvmargs.agent</fail>
+ </target>
+ <!--
+ end of pre NB7.2 profiling section
+ -->
+ <target depends="-init-debug-args" name="-init-macrodef-nbjpda">
+ <macrodef name="nbjpdastart" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${main.class}" name="name"/>
+ <attribute default="${debug.modulepath}" name="modulepath"/>
+ <attribute default="${debug.classpath}" name="classpath"/>
+ <attribute default="" name="stopclassname"/>
+ <sequential>
+ <nbjpdastart addressproperty="jpda.address" name="@{name}" stopclassname="@{stopclassname}" transport="${debug-transport}">
+ <modulepath>
+ <path path="@{modulepath}"/>
+ </modulepath>
+ <classpath>
+ <path path="@{classpath}"/>
+ </classpath>
+ </nbjpdastart>
+ </sequential>
+ </macrodef>
+ <macrodef name="nbjpdareload" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${debug.modules.dir}" name="dir"/>
+ <sequential>
+ <nbjpdareload>
+ <fileset dir="@{dir}" includes="${fix.classes}">
+ <include name="*/${fix.includes}*.class"/>
+ </fileset>
+ </nbjpdareload>
+ </sequential>
+ </macrodef>
+ </target>
+ <target name="-init-debug-args">
+ <condition else="dt_socket" property="debug-transport-by-os" value="dt_shmem">
+ <os family="windows"/>
+ </condition>
+ <condition else="${debug-transport-by-os}" property="debug-transport" value="${debug.transport}">
+ <isset property="debug.transport"/>
+ </condition>
+ </target>
+ <target depends="-init-debug-args" name="-init-macrodef-debug">
+ <macrodef name="debug" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${module.name}" name="modulename"/>
+ <attribute default="${main.class}" name="classname"/>
+ <attribute default="${debug.modulepath}" name="modulepath"/>
+ <attribute default="${debug.classpath}" name="classpath"/>
+ <element name="customizeDebuggee" optional="true"/>
+ <sequential>
+ <j2semodularproject1:java xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="@{classname}" classpath="@{classpath}" modulename="@{modulename}" modulepath="@{modulepath}">
+ <customize>
+ <jvmarg value="-agentlib:jdwp=transport=${debug-transport},address=${jpda.address}"/>
+ <customizeDebuggee/>
+ </customize>
+ </j2semodularproject1:java>
+ </sequential>
+ </macrodef>
+ </target>
+ <target depends="-init-source-module-properties" name="-init-macrodef-java">
+ <macrodef name="java" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${module.name}" name="modulename"/>
+ <attribute default="${main.class}" name="classname"/>
+ <attribute default="${run.modulepath}" name="modulepath"/>
+ <attribute default="${run.upgrademodulepath}" name="upgrademodulepath"/>
+ <attribute default="${run.classpath}" name="classpath"/>
+ <attribute default="jvm" name="jvm"/>
+ <element name="customize" optional="true"/>
+ <sequential>
+ <java classname="@{classname}" dir="${work.dir}" failonerror="${java.failonerror}" fork="true" module="@{modulename}">
+ <classpath>
+ <path path="@{classpath}"/>
+ </classpath>
+ <modulepath>
+ <path path="@{modulepath}"/>
+ </modulepath>
+ <upgrademodulepath>
+ <path path="@{upgrademodulepath}"/>
+ </upgrademodulepath>
+ <jvmarg value="-Dfile.encoding=${runtime.encoding}"/>
+ <redirector errorencoding="${runtime.encoding}" inputencoding="${runtime.encoding}" outputencoding="${runtime.encoding}"/>
+ <jvmarg line="${run.jvmargs}"/>
+ <jvmarg line="${run.jvmargs.ide}"/>
+ <syspropertyset>
+ <propertyref prefix="run-sys-prop."/>
+ <mapper from="run-sys-prop.*" to="*" type="glob"/>
+ </syspropertyset>
+ <customize/>
+ </java>
+ </sequential>
+ </macrodef>
+ </target>
+ <target name="-init-presetdef-jar">
+ <presetdef name="jar" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <jar compress="${jar.compress}" index="${jar.index}" jarfile="${dist.jar}" manifestencoding="UTF-8">
+ <j2semodularproject1:fileset xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" dir="${build.classes.dir}" excludes="${dist.archive.excludes}"/>
+ </jar>
+ </presetdef>
+ </target>
+ <target name="-init-ap-cmdline-properties">
+ <property name="annotation.processing.enabled" value="true"/>
+ <property name="annotation.processing.processors.list" value=""/>
+ <property name="annotation.processing.processor.options" value=""/>
+ <property name="annotation.processing.run.all.processors" value="true"/>
+ <property name="javac.processorpath" value="${javac.classpath}"/>
+ <property name="javac.test.processorpath" value="${javac.test.classpath}"/>
+ </target>
+ <target depends="-init-ap-cmdline-properties" name="-init-ap-cmdline-supported">
+ <condition else="" property="ap.processors.internal" value="-processor ${annotation.processing.processors.list}">
+ <isfalse value="${annotation.processing.run.all.processors}"/>
+ </condition>
+ <condition else="" property="ap.proc.none.internal" value="-proc:none">
+ <isfalse value="${annotation.processing.enabled}"/>
+ </condition>
+ </target>
+ <target depends="-init-ap-cmdline-properties,-init-ap-cmdline-supported" name="-init-ap-cmdline">
+ <property name="ap.cmd.line.internal" value=""/>
+ </target>
+ <target depends="-pre-init,-init-private,-init-user,-init-project,-do-init,-post-init,-init-check,-init-macrodef-property,-init-macrodef-javac-depend,-init-macrodef-test,-init-macrodef-test-debug,-init-macrodef-nbjpda,-init-macrodef-debug,-init-macrodef-java,-init-presetdef-jar,-init-ap-cmdline" name="init"/>
+ <!--
+ ===================
+ COMPILATION SECTION
+ ===================
+ -->
+ <target name="-deps-jar-init" unless="built-jar.properties">
+ <property location="${build.dir}/built-jar.properties" name="built-jar.properties"/>
+ <delete file="${built-jar.properties}" quiet="true"/>
+ </target>
+ <target if="already.built.jar.${basedir}" name="-warn-already-built-jar">
+ <echo level="warn" message="Cycle detected: notzed.dez was already built"/>
+ </target>
+ <target depends="init,-deps-jar-init" name="deps-jar" unless="no.deps">
+ <mkdir dir="${build.dir}"/>
+ <touch file="${built-jar.properties}" verbose="false"/>
+ <property file="${built-jar.properties}" prefix="already.built.jar."/>
+ <antcall target="-warn-already-built-jar"/>
+ <propertyfile file="${built-jar.properties}">
+ <entry key="${basedir}" value=""/>
+ </propertyfile>
+ <antcall target="-maybe-call-dep">
+ <param name="call.built.properties" value="${built-jar.properties}"/>
+ <param location="${project.notzed_nativez}" name="call.subproject"/>
+ <param location="${project.notzed_nativez}/build.xml" name="call.script"/>
+ <param name="call.target" value="jar"/>
+ <param name="transfer.built-jar.properties" value="${built-jar.properties}"/>
+ <param name="transfer.not.archive.disabled" value="true"/>
+ <param name="transfer.do.jlink" value="false"/>
+ </antcall>
+ </target>
+ <target depends="init,-check-automatic-build,-clean-after-automatic-build" name="-verify-automatic-build"/>
+ <target depends="init" name="-check-automatic-build">
+ <available file="${build.modules.dir}/.netbeans_automatic_build" property="netbeans.automatic.build"/>
+ </target>
+ <target depends="init" if="netbeans.automatic.build" name="-clean-after-automatic-build">
+ <antcall target="clean">
+ <param name="no.dependencies" value="true"/>
+ </antcall>
+ </target>
+ <target name="-pre-pre-compile">
+ <mkdir dir="${build.modules.dir}"/>
+ </target>
+ <target name="-pre-compile">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <scriptdef language="javascript" name="coalesce_keyvalue" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute name="property"/>
+ <attribute name="value"/>
+ <attribute name="value-sep"/>
+ <attribute name="entry-sep"/>
+ <attribute name="multi-sep"/>
+ <attribute name="out-sep"/>
+
+
+ function coalesce(input, keyValueSeparator, multiSeparator, entrySeparator) {
+ var result = [];
+ var values = {};
+
+ (typeof input === "string" ? input.split(entrySeparator) : input).forEach(function(entry) {
+ var idx = entry.indexOf(keyValueSeparator);
+ if (idx < 1) {
+ result.push(entry);
+ } else {
+ var key = entry.substring(0, idx);
+ var val = entry.substring(idx + 1);
+ if (!values[key]) {
+ values[key] = [];
+ }
+ values[key].push(val.trim());
+ }
+ });
+ Object.keys(values).sort().forEach(function(k) {
+ result.push(k + keyValueSeparator + values[k].join(multiSeparator));
+ });
+ return result.join(" " + entrySeparator);
+ }
+ self.project.setProperty(attributes.get("property"),
+ coalesce(attributes.get("value"),
+ attributes.get("value-sep"),
+ attributes.get("entry-sep"),
+ attributes.get("multi-sep")
+ ));
+
+
+
+ </scriptdef>
+ <scriptdef language="javascript" name="modsource_regexp" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute name="property"/>
+ <attribute name="filePattern"/>
+ <attribute name="modsource"/>
+ function expandGroup(grp) {
+ var exp = [];
+ var item = "";
+ var depth = 0;
+
+ for (i = 0; i < grp.length; i++) {
+ var c = grp[i];
+ switch (c) {
+ case '{':
+ if (depth++ === 0) {
+ continue;
+ }
+ break;
+ case '}':
+ if (--depth === 0) {
+ exp.push(item);
+ continue;
+ }
+ break;
+ case ',':
+ if (depth === 1) {
+ exp.push(item);
+ item = "";
+ continue;
+ }
+ default:
+ break;
+ }
+ item = item + c;
+ }
+ return exp;
+ }
+
+ function pathVariants(spec, res) {
+ res = res || [];
+ var start = spec.indexOf('{');
+ if (start === -1) {
+ res.push(spec);
+ return res;
+ }
+ var depth = 1;
+ var end;
+ for (end = start + 1; end < spec.length && depth > 0; end++) {
+ var c = spec[end];
+ switch (c) {
+ case '{': depth++; break;
+ case '}': depth--; break;
+ }
+ }
+ var prefix = spec.substring(0, start);
+ var suffix = spec.substring(end);
+ expandGroup(spec.slice(start, end)).forEach(function (item) {
+ pathVariants(prefix + item + suffix, res);
+ })
+ return res;
+ }
+
+ function toRegexp2(spec, filepattern, separator) {
+ var prefixes = [];
+ var suffixes = [];
+ pathVariants(spec).forEach(function(item) {
+ suffixes.push(item);
+ });
+ var tail = "";
+ var separatorString = separator;
+ if (separatorString == "\\") {
+ separatorString = "\\\\";
+ }
+ if (filepattern && filepattern != tail) {
+ tail = separatorString + filepattern;
+ }
+ return "([^" + separatorString +"]+)\\Q" + separator + "\\E(" + suffixes.join("|") + ")" + tail;
+ }
+ self.project.setProperty(attributes.get("property"),
+ toRegexp2(attributes.get("modsource"), attributes.get("filepattern"), self.project.getProperty("file.separator")));
+
+
+
+
+ </scriptdef>
+ <target if="do.depend.true" name="-compile-depend">
+ <pathconvert property="build.generated.subdirs">
+ <dirset dir="${build.generated.sources.dir}" erroronmissingdir="false">
+ <include name="*"/>
+ </dirset>
+ </pathconvert>
+ <j2semodularproject1:depend xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" srcdir="${src.dir}:${build.generated.subdirs}"/>
+ </target>
+ <target depends="init,deps-jar,-pre-pre-compile,-pre-compile,-compile-depend" if="have.sources" name="-do-compile">
+ <j2semodularproject1:javac xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" gensrcdir="${build.generated.sources.dir}"/>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" filePattern="(.*$)" modsource="${src.dir.path}" property="src.dir.path.regexp"/>
+ <echo message="Copying resources from ${src.dir}"/>
+ <copy todir="${build.modules.dir}">
+ <fileset dir="${src.dir}" excludes="${build.classes.excludes},${excludes}" includes="${includes}"/>
+ <regexpmapper from="${src.dir.path.regexp}" to="\1/\3"/>
+ </copy>
+ </target>
+ <target if="has.persistence.xml" name="-copy-persistence-xml">
+ <fail message="XXX: Not supported on MM projects"/>
+ <mkdir dir="${build.classes.dir}/META-INF"/>
+ <copy todir="${build.classes.dir}/META-INF">
+ <fileset dir="${meta.inf.dir}" includes="persistence.xml orm.xml"/>
+ </copy>
+ </target>
+ <target name="-post-compile">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,deps-jar,-verify-automatic-build,-pre-pre-compile,-pre-compile,-do-compile,-post-compile" description="Compile project." name="compile"/>
+ <target name="-pre-compile-single">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,deps-jar" name="-do-compile-single">
+ <fail unless="javac.includes">Must select some files in the IDE or set javac.includes</fail>
+ <j2semodularproject1:force-recompile xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1"/>
+ <j2semodularproject1:javac xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="" gensrcdir="${build.generated.sources.dir}" includes="${javac.includes}, module-info.java"/>
+ </target>
+ <target name="-post-compile-single">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,deps-jar,-verify-automatic-build,-pre-pre-compile,-pre-compile-single,-do-compile-single,-post-compile-single" name="compile-single"/>
+ <!--
+ ====================
+ JAR BUILDING SECTION
+ ====================
+ -->
+ <target depends="init,compile" name="-check-module-main-class">
+ <condition property="do.module.main.class">
+ <and>
+ <available file="${module.dir}/module-info.class"/>
+ <isset property="main.class.check.available"/>
+ </and>
+ </condition>
+ </target>
+ <target depends="init" name="-pre-pre-jar">
+ <dirname file="${dist.jar}" property="dist.jar.dir"/>
+ <mkdir dir="${dist.jar.dir}"/>
+ </target>
+ <target name="-pre-jar">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target name="-pre-single-jar"/>
+ <target depends="-pre-single-jar" if="module.jar.filename" name="-make-single-jar">
+ <jar basedir="${module.dir}" compress="${jar.compress}" destfile="${dist.dir}/${module.jar.filename}" excludes="${dist.archive.excludes}" manifestencoding="UTF-8"/>
+ </target>
+ <target depends="init,compile,-pre-pre-jar,-pre-jar" if="do.archive" name="-do-jar-jar" unless="do.mkdist">
+ <property location="${build.modules.dir}" name="build.modules.dir.resolved"/>
+ <dirset dir="${build.modules.dir.resolved}" id="do.jar.dirs" includes="*"/>
+ <pathconvert property="do.jar.dir.list" refid="do.jar.dirs">
+ <identitymapper/>
+ </pathconvert>
+ <j2semodularproject1:for-paths xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" paths="${do.jar.dir.list}">
+ <local name="module.jar.filename"/>
+ <local name="module.jar.name.tmp"/>
+ <basename file="${entry}" property="module.jar.name.tmp"/>
+ <property name="module.jar.filename" value="${module.jar.name.tmp}.jar"/>
+ <antcall inheritRefs="true" target="-make-single-jar">
+ <param name="module.jar.filename" value="${module.jar.filename}"/>
+ <param location="${entry}" name="module.dir"/>
+ </antcall>
+ </j2semodularproject1:for-paths>
+ <property location="${build.classes.dir}" name="build.classes.dir.resolved"/>
+ <property location="${dist.jar}" name="dist.jar.resolved"/>
+ <pathconvert property="run.classpath.with.dist.jar">
+ <path path="${run.classpath}"/>
+ <map from="${build.classes.dir.resolved}" to="${dist.jar.resolved}"/>
+ </pathconvert>
+ <pathconvert property="run.modulepath.with.dist.jar">
+ <path path="${run.modulepath}"/>
+ <map from="${build.classes.dir.resolved}" to="${dist.jar.resolved}"/>
+ </pathconvert>
+ <condition else="" property="jar.usage.message.module.path" value=" -modulepath ${run.modulepath.with.dist.jar}">
+ <and>
+ <isset property="modules.supported.internal"/>
+ <length length="0" string="${run.modulepath.with.dist.jar}" when="greater"/>
+ </and>
+ </condition>
+ <condition else="" property="jar.usage.message.class.path" value=" -cp ${run.classpath.with.dist.jar}">
+ <length length="0" string="${run.classpath.with.dist.jar}" when="greater"/>
+ </condition>
+ <condition else=" ${main.class}" property="jar.usage.message.main.class" value=" -m ${module.name}/${main.class}">
+ <isset property="named.module.internal"/>
+ </condition>
+ <condition else="" property="jar.usage.message" value="To run this application from the command line without Ant, try:${line.separator}${platform.java}${jar.usage.message.module.path}${jar.usage.message.class.path}${jar.usage.message.main.class}">
+ <isset property="main.class.available"/>
+ </condition>
+ <condition else="debug" property="jar.usage.level" value="info">
+ <isset property="main.class.available"/>
+ </condition>
+ <echo level="${jar.usage.level}" message="${jar.usage.message}"/>
+ </target>
+ <target depends="init,compile,-pre-pre-jar,-pre-jar,-do-jar-jar" name="-do-jar-without-libraries"/>
+ <target depends="init,compile,-pre-pre-jar,-pre-jar" name="-do-jar-with-libraries"/>
+ <target name="-post-jar">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,compile,-pre-jar,-do-jar-without-libraries,-do-jar-with-libraries,-post-jar" name="-do-jar"/>
+ <target depends="init,compile,-pre-jar,-do-jar,-post-jar,deploy" description="Build JAR." name="jar"/>
+ <!--
+ =================
+ DEPLOY SECTION
+ =================
+ -->
+ <target name="-pre-deploy">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init" name="-check-jlink">
+ <condition property="do.jlink.internal">
+ <and>
+ <istrue value="${do.jlink}"/>
+ <isset property="do.archive"/>
+ </and>
+ </condition>
+ </target>
+ <target depends="init,-do-jar,-post-jar,-pre-deploy,-check-jlink,-main-module-set" if="do.jlink.internal" name="-do-deploy">
+ <delete dir="${dist.jlink.dir}" failonerror="false" quiet="true"/>
+ <property name="jlink.launcher.name" value="${application.title}"/>
+ <pathconvert pathsep="," property="jlink.modulelist.internal">
+ <fileset dir="${dist.dir}" includes="*.jar"/>
+ <mapper>
+ <chainedmapper>
+ <flattenmapper/>
+ <globmapper from="*.jar" to="*"/>
+ </chainedmapper>
+ </mapper>
+ </pathconvert>
+ <condition else="${jlink.modulelist.internal}" property="jlink.add.modules" value="${jlink.modulelist.internal},${jlink.additionalmodules}">
+ <and>
+ <isset property="jlink.additionalmodules"/>
+ <length length="0" string="${jlink.additionalmodules}" when="greater"/>
+ </and>
+ </condition>
+ <condition property="jlink.do.strip.internal">
+ <and>
+ <isset property="jlink.strip"/>
+ <istrue value="${jlink.strip}"/>
+ </and>
+ </condition>
+ <condition property="jlink.do.additionalparam.internal">
+ <and>
+ <isset property="jlink.additionalparam"/>
+ <length length="0" string="${jlink.additionalparam}" when="greater"/>
+ </and>
+ </condition>
+ <condition property="jlink.do.launcher.internal">
+ <and>
+ <istrue value="${jlink.launcher}"/>
+ <isset property="module.name"/>
+ <length length="0" string="${module.name}" when="greater"/>
+ <isset property="main.class.available"/>
+ </and>
+ </condition>
+ <property name="platform.jlink" value="${jdk.home}/bin/jlink"/>
+ <property name="jlink.systemmodules.internal" value="${jdk.home}/jmods"/>
+ <exec executable="${platform.jlink}">
+ <arg value="--module-path"/>
+ <arg path="${jlink.systemmodules.internal}:${run.modulepath}:${dist.dir}"/>
+ <arg value="--add-modules"/>
+ <arg value="${jlink.add.modules}"/>
+ <arg if:set="jlink.do.strip.internal" value="--strip-debug"/>
+ <arg if:set="jlink.do.launcher.internal" value="--launcher"/>
+ <arg if:set="jlink.do.launcher.internal" value="${jlink.launcher.name}=${module.name}/${main.class}"/>
+ <arg if:set="jlink.do.additionalparam.internal" line="${jlink.additionalparam}"/>
+ <arg value="--output"/>
+ <arg value="${dist.jlink.output}"/>
+ </exec>
+ </target>
+ <target name="-post-deploy">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="-do-jar,-post-jar,-pre-deploy,-do-deploy,-post-deploy" name="deploy"/>
+ <!--
+ =================
+ EXECUTION SECTION
+ =================
+ -->
+ <target name="-check-main-class">
+ <fail unless="main.class">No main class specified</fail>
+ </target>
+ <target depends="init,compile,-check-main-class,-main-module-check" description="Run a main class." name="run">
+ <property name="main.class.relativepath" refid="main.class.relativepath"/>
+ <pathconvert pathsep="," property="src.dir.list" refid="have.sources.set"/>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" filePattern="(.*$)" modsource="${src.dir.path}" property="run.src.dir.path.regexp"/>
+ <j2semodularproject1:java xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <customize>
+ <arg line="${application.args}"/>
+ </customize>
+ </j2semodularproject1:java>
+ </target>
+ <target name="-main-module-set" unless="module.name">
+ <condition else="${main.class}" property="check.class.name" value="${run.class}">
+ <isset property="run.class"/>
+ </condition>
+ <condition property="run.modules.dir" value="${build.modules.dir}">
+ <not>
+ <isset property="run.modules.dir"/>
+ </not>
+ </condition>
+ <resources id="main.class.relativepath">
+ <mappedresources>
+ <string value="${check.class.name}"/>
+ <unpackagemapper from="*" to="*.class"/>
+ </mappedresources>
+ </resources>
+ <property location="${run.modules.dir}" name="run.modules.dir.location"/>
+ <pathconvert property="module.name">
+ <fileset dir="${run.modules.dir}" includes="**/${toString:main.class.relativepath}"/>
+ <regexpmapper from="\Q${run.modules.dir.location}${file.separator}\E([^${file.separator.string}]+)\Q${file.separator}\E.*\.class" to="\1"/>
+ </pathconvert>
+ </target>
+ <target depends="-main-module-set" name="-main-module-check">
+ <fail message="Could not determine module of the main class and module.name is not set">
+ <condition>
+ <or>
+ <not>
+ <isset property="module.name"/>
+ </not>
+ <length length="0" string="${module.name}" when="equal"/>
+ </or>
+ </condition>
+ </fail>
+ </target>
+ <target name="-do-not-recompile">
+ <property name="javac.includes.binary" value=""/>
+ </target>
+ <target depends="init,compile-single,-main-module-check" name="run-single">
+ <fail unless="run.class">Must select one file in the IDE or set run.class</fail>
+ <j2semodularproject1:java xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="${run.class}"/>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-main-module-check" name="run-test-with-main">
+ <fail unless="run.class">Must select one file in the IDE or set run.class</fail>
+ <j2semodularproject1:java xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="${run.class}" classpath="${run.test.classpath}" modulepath="${run.test.modulepath}">
+ <customize>
+ <jvmarg line="${run.test.jvmargs}"/>
+ </customize>
+ </j2semodularproject1:java>
+ </target>
+ <!--
+ =================
+ DEBUGGING SECTION
+ =================
+ -->
+ <target name="-debug-init">
+ <condition else="${main.class}" property="run.class" value="${debug.class}">
+ <isset property="debug.class"/>
+ </condition>
+ <fail message="debug.class or main.class property is not set" unless="run.class"/>
+ </target>
+ <target depends="init,-debug-init,-main-module-check" if="netbeans.home" name="-debug-start-debugger">
+ <j2semodularproject1:nbjpdastart xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" name="${debug.class}"/>
+ </target>
+ <target depends="init,-debug-init,-main-module-check" if="netbeans.home" name="-debug-start-debugger-main-test">
+ <j2semodularproject1:nbjpdastart xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classpath="${debug.test.classpath}" name="${debug.class}"/>
+ </target>
+ <target depends="init,compile,-debug-init,-main-module-check" name="-debug-start-debuggee">
+ <j2semodularproject1:debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="${run.class}">
+ <customizeDebuggee>
+ <arg line="${application.args}"/>
+ </customizeDebuggee>
+ </j2semodularproject1:debug>
+ </target>
+ <target depends="init,compile,-debug-init,-main-module-check,-debug-start-debugger,-debug-start-debuggee" description="Debug project in IDE." if="netbeans.home" name="debug"/>
+ <target depends="init,-debug-init,-main-module-check" if="netbeans.home" name="-debug-start-debugger-stepinto">
+ <j2semodularproject1:nbjpdastart xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" stopclassname="${debug.class}"/>
+ </target>
+ <target depends="init,compile,-debug-start-debugger-stepinto,-debug-start-debuggee" if="netbeans.home" name="debug-stepinto"/>
+ <target depends="init,compile-single,-debug-init,-main-module-check" if="netbeans.home" name="-debug-start-debuggee-single">
+ <fail unless="debug.class">Must select one file in the IDE or set debug.class</fail>
+ <j2semodularproject1:debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="${debug.class}"/>
+ </target>
+ <target depends="init,compile-single,-debug-start-debugger,-debug-start-debuggee-single" if="netbeans.home" name="debug-single"/>
+ <target depends="init,compile-test-single,-debug-init,-main-module-check" if="netbeans.home" name="-debug-start-debuggee-main-test">
+ <fail unless="debug.class">Must select one file in the IDE or set debug.class</fail>
+ <j2semodularproject1:debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classname="${debug.class}" classpath="${debug.test.classpath}"/>
+ </target>
+ <target depends="init,compile-test-single,-debug-start-debugger-main-test,-debug-start-debuggee-main-test" if="netbeans.home" name="debug-test-with-main"/>
+ <target depends="init" name="-pre-debug-fix">
+ <fail unless="fix.includes">Must set fix.includes</fail>
+ <property name="javac.includes" value="${fix.includes}.java"/>
+ </target>
+ <target depends="init,-pre-debug-fix,compile-single" if="netbeans.home" name="-do-debug-fix">
+ <property location="${build.modules.dir}" name="debug.modules.dir"/>
+ <j2semodularproject1:nbjpdareload xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1"/>
+ </target>
+ <target depends="init,-pre-debug-fix,-do-debug-fix" if="netbeans.home" name="debug-fix"/>
+ <!--
+ =================
+ PROFILING SECTION
+ =================
+ -->
+ <!--
+ pre NB7.2 profiler integration
+ -->
+ <target depends="profile-init,compile" description="Profile a project in the IDE." if="profiler.info.jvmargs.agent" name="-profile-pre72">
+ <fail unless="netbeans.home">This target only works when run from inside the NetBeans IDE.</fail>
+ <nbprofiledirect>
+ <classpath>
+ <path path="${run.classpath}"/>
+ </classpath>
+ </nbprofiledirect>
+ <profile/>
+ </target>
+ <target depends="profile-init,compile-single" description="Profile a selected class in the IDE." if="profiler.info.jvmargs.agent" name="-profile-single-pre72">
+ <fail unless="profile.class">Must select one file in the IDE or set profile.class</fail>
+ <fail unless="netbeans.home">This target only works when run from inside the NetBeans IDE.</fail>
+ <nbprofiledirect>
+ <classpath>
+ <path path="${run.classpath}"/>
+ </classpath>
+ </nbprofiledirect>
+ <profile classname="${profile.class}"/>
+ </target>
+ <target depends="profile-init,compile-single" if="profiler.info.jvmargs.agent" name="-profile-applet-pre72">
+ <fail unless="netbeans.home">This target only works when run from inside the NetBeans IDE.</fail>
+ <nbprofiledirect>
+ <classpath>
+ <path path="${run.classpath}"/>
+ </classpath>
+ </nbprofiledirect>
+ <profile classname="sun.applet.AppletViewer">
+ <customize>
+ <arg value="${applet.url}"/>
+ </customize>
+ </profile>
+ </target>
+ <target depends="-init-macrodef-junit,profile-init,compile-test-single" if="profiler.info.jvmargs.agent" name="-profile-test-single-pre72">
+ <fail unless="netbeans.home">This target only works when run from inside the NetBeans IDE.</fail>
+ <nbprofiledirect>
+ <classpath>
+ <path path="${run.test.classpath}"/>
+ </classpath>
+ </nbprofiledirect>
+ <j2semodularproject1:junit xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="${excludes}" includes="${includes}" testincludes="${profile.class}" testmethods="">
+ <customize>
+ <jvmarg value="-agentlib:jdwp=transport=${debug-transport},address=${jpda.address}"/>
+ <env key="${profiler.info.pathvar}" path="${profiler.info.agentpath}:${profiler.current.path}"/>
+ <jvmarg value="${profiler.info.jvmargs.agent}"/>
+ <jvmarg line="${profiler.info.jvmargs}"/>
+ <classpath>
+ <path path="${run.test.classpath}"/>
+ </classpath>
+ </customize>
+ </j2semodularproject1:junit>
+ </target>
+ <!--
+ end of pre NB72 profiling section
+ -->
+ <target if="netbeans.home" name="-profile-check">
+ <condition property="profiler.configured">
+ <or>
+ <contains casesensitive="true" string="${run.jvmargs.ide}" substring="-agentpath:"/>
+ <contains casesensitive="true" string="${run.jvmargs.ide}" substring="-javaagent:"/>
+ </or>
+ </condition>
+ </target>
+ <target depends="-profile-check,-profile-pre72" description="Profile a project in the IDE." if="profiler.configured" name="profile" unless="profiler.info.jvmargs.agent">
+ <startprofiler/>
+ <antcall target="run"/>
+ </target>
+ <target depends="-profile-check,-profile-single-pre72" description="Profile a selected class in the IDE." if="profiler.configured" name="profile-single" unless="profiler.info.jvmargs.agent">
+ <fail unless="run.class">Must select one file in the IDE or set run.class</fail>
+ <startprofiler/>
+ <antcall target="run-single"/>
+ </target>
+ <target depends="-profile-test-single-pre72" description="Profile a selected test in the IDE." name="profile-test-single"/>
+ <target depends="-profile-check" description="Profile a selected test in the IDE." if="profiler.configured" name="profile-test" unless="profiler.info.jvmargs">
+ <fail unless="test.includes">Must select some files in the IDE or set test.includes</fail>
+ <startprofiler/>
+ <antcall target="test-single"/>
+ </target>
+ <target depends="-profile-check" description="Profile a selected class in the IDE." if="profiler.configured" name="profile-test-with-main">
+ <fail unless="run.class">Must select one file in the IDE or set run.class</fail>
+ <startprofiler/>
+ <antcall target="run-test-with-main"/>
+ </target>
+ <target depends="-profile-check,-profile-applet-pre72" if="profiler.configured" name="profile-applet" unless="profiler.info.jvmargs.agent">
+ <fail unless="applet.url">Must select one file in the IDE or set applet.url</fail>
+ <startprofiler/>
+ <antcall target="run-applet"/>
+ </target>
+ <!--
+ ===============
+ JAVADOC SECTION
+ ===============
+ -->
+ <target depends="init" if="have.sources" name="-javadoc-build">
+ <mkdir dir="${dist.javadoc.dir}"/>
+ <condition else="" property="javadoc.endorsed.classpath.cmd.line.arg" value="-J${endorsed.classpath.cmd.line.arg}">
+ <and>
+ <isset property="endorsed.classpath.cmd.line.arg"/>
+ <not>
+ <equals arg1="${endorsed.classpath.cmd.line.arg}" arg2=""/>
+ </not>
+ </and>
+ </condition>
+ <condition else="" property="bug5101868workaround" value="*.java">
+ <matches pattern="1\.[56](\..*)?" string="${java.version}"/>
+ </condition>
+ <condition else="" property="javadoc.html5.cmd.line.arg" value="-html5">
+ <and>
+ <isset property="javadoc.html5"/>
+ <available file="${jdk.home}${file.separator}lib${file.separator}jrt-fs.jar"/>
+ </and>
+ </condition>
+ <javadoc additionalparam="-J-Dfile.encoding=${file.encoding} ${javadoc.additionalparam}" author="${javadoc.author}" charset="UTF-8" destdir="${dist.javadoc.dir}" docencoding="UTF-8" encoding="${javadoc.encoding.used}" failonerror="true" noindex="${javadoc.noindex}" nonavbar="${javadoc.nonavbar}" notree="${javadoc.notree}" private="${javadoc.private}" source="${javac.source}" splitindex="${javadoc.splitindex}" use="${javadoc.use}" useexternalfile="true" version="${javadoc.version}" windowtitle="${javadoc.windowtitle}">
+ <classpath>
+ <path path="${javac.classpath}"/>
+ </classpath>
+ <fileset dir="${src.dir}" excludes="${bug5101868workaround},${excludes}" includes="${includes}">
+ <filename name="**/*.java"/>
+ </fileset>
+ <fileset dir="${build.generated.sources.dir}" erroronmissingdir="false">
+ <include name="**/*.java"/>
+ <exclude name="*.java"/>
+ </fileset>
+ <arg line="${javadoc.endorsed.classpath.cmd.line.arg}"/>
+ <arg line="${javadoc.html5.cmd.line.arg}"/>
+ </javadoc>
+ <copy todir="${dist.javadoc.dir}">
+ <fileset dir="${src.dir}" excludes="${excludes}" includes="${includes}">
+ <filename name="**/doc-files/**"/>
+ </fileset>
+ <fileset dir="${build.generated.sources.dir}" erroronmissingdir="false">
+ <include name="**/doc-files/**"/>
+ </fileset>
+ </copy>
+ </target>
+ <target depends="init,-javadoc-build" if="netbeans.home" name="-javadoc-browse" unless="no.javadoc.preview">
+ <nbbrowse file="${dist.javadoc.dir}/index.html"/>
+ </target>
+ <target depends="init,-javadoc-build,-javadoc-browse" description="Build Javadoc." name="javadoc"/>
+ <!--
+ =========================
+ TEST COMPILATION SECTION
+ =========================
+ -->
+ <target depends="init,compile" if="have.tests" name="-pre-pre-compile-test">
+ <mkdir dir="${build.test.modules.dir}"/>
+ </target>
+ <target name="-pre-compile-test">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="-init-source-module-properties" name="-init-test-run-module-properties">
+ <fileset dir="${build.test.modules.dir}" id="run.test.packages.internal" includes="**/*.class"/>
+ <property location="${build.test.modules.dir}" name="build.test.modules.dir.abs.internal"/>
+ <pathconvert pathsep=" " property="run.test.addexports.internal" refid="run.test.packages.internal">
+ <chainedmapper>
+ <filtermapper>
+ <replacestring from="${build.test.modules.dir.abs.internal}${file.separator}" to=""/>
+ </filtermapper>
+ <regexpmapper from="^([^${file.separator.string}]*)\Q${file.separator}\E(.*)\Q${file.separator}\E.*\.class$$" to="\1${path.separator}\2"/>
+ <filtermapper>
+ <uniqfilter/>
+ <replacestring from="${file.separator}" to="."/>
+ </filtermapper>
+ <regexpmapper from="([^${file.separator.string}]+)${path.separator}(.*)" to="--add-exports \1/\2=ALL-UNNAMED"/>
+ </chainedmapper>
+ </pathconvert>
+ <property location="${build.test.modules.dir}" name="build.test.modules.location"/>
+ <pathconvert pathsep="," property="run.test.addmodules.list">
+ <map from="${build.test.modules.location}${file.separator}" to=""/>
+ <dirset dir="${build.test.modules.dir}" includes="*"/>
+ <chainedmapper>
+ <filtermapper>
+ <uniqfilter/>
+ </filtermapper>
+ </chainedmapper>
+ </pathconvert>
+ <pathconvert pathsep=" " property="run.test.patchmodules.list">
+ <dirset dir="${build.test.modules.dir}" includes="*">
+ <scriptselector language="javascript">
+ self.setSelected(!new java.io.File(file, "module-info.class").exists());
+ </scriptselector>
+ </dirset>
+ <chainedmapper>
+ <filtermapper>
+ <uniqfilter/>
+ </filtermapper>
+ <regexpmapper from=".*\Q${file.separator}\E([^${file.separator.string}]+)$" to="--patch-module \1=\0"/>
+ </chainedmapper>
+ </pathconvert>
+ <j2semodularproject1:coalesce_keyvalue xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" entry-sep="${path.separator}" multi-sep="--patch-module " property="run.test.patchmodules" value="${run.test.patchmodules.list}" value-sep="="/>
+ <condition else="" property="run.test.addmodules.internal" value="--add-modules ${run.test.addmodules.list}">
+ <isset property="run.test.addmodules.list"/>
+ </condition>
+ <pathconvert pathsep=" " property="run.test.addreads.internal">
+ <map from="${build.test.modules.location}" to=""/>
+ <dirset dir="${build.test.modules.dir}" includes="*"/>
+ <chainedmapper>
+ <regexpmapper from="^\Q${build.test.modules.location}${file.separator}\E(.*)" to="\1"/>
+ <regexpmapper from="(.*)" to="--add-reads \1=ALL-UNNAMED"/>
+ <filtermapper>
+ <uniqfilter/>
+ </filtermapper>
+ </chainedmapper>
+ </pathconvert>
+ <property name="run.test.jvmargs" value="${run.test.addmodules.internal} ${run.test.addreads.internal} ${run.test.addexports.internal} ${run.test.patchmodules}"/>
+ </target>
+ <target depends="-init-source-module-properties" name="-init-test-javac-module-properties">
+ <pathconvert pathsep=" " property="compile.test.patchmodule.internal" refid="have.tests.patchset">
+ <regexpmapper from="(.*\Q${file.separator}\E)([^${file.separator.string}]+)\Q${file.separator}\E(.*)$$" to="--patch-module \2=\1\2${file.separator.string}\3"/>
+ </pathconvert>
+ <pathconvert pathsep=" " property="compile.test.addreads">
+ <union refid="have.tests.set"/>
+ <chainedmapper>
+ <firstmatchmapper>
+ <regexpmapper from="${have.tests.test.src.dir.regexp}" to="\1"/>
+ </firstmatchmapper>
+ <regexpmapper from="(.*)" to="--add-reads \1=ALL-UNNAMED"/>
+ <filtermapper>
+ <uniqfilter/>
+ </filtermapper>
+ </chainedmapper>
+ </pathconvert>
+ <j2semodularproject1:coalesce_keyvalue xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" entry-sep="${path.separator}" multi-sep="--patch-module " property="compile.test.patchmodules" value="${compile.test.patchmodule.internal}" value-sep="="/>
+ <property name="javac.test.moduleargs" value="${compile.test.patchmodules} ${compile.test.addreads}"/>
+ </target>
+ <target depends="-init-test-javac-module-properties" name="-init-test-module-properties">
+ <property location="${build.modules.dir}" name="test.module.build.location"/>
+ <property name="test.source.modulepath" value="${test.src.dir}/*/${test.src.dir.path}"/>
+ <property name="test.compile.modulepath" value="${javac.test.modulepath}:${build.modules.dir}"/>
+ <macrodef name="test-javac" uri="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <attribute default="${includes}" name="includes"/>
+ <attribute default="${excludes}" name="excludes"/>
+ <element implicit="true" name="additionalargs" optional="true"/>
+ <sequential>
+ <j2semodularproject1:javac xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" apgeneratedsrcdir="${build.test.modules.dir}" classpath="${javac.test.classpath}" debug="true" destdir="${build.test.modules.dir}" excludes="@{excludes}" includes="@{includes}" modulepath="${test.compile.modulepath}" modulesourcepath="${test.source.modulepath}" processorpath="${javac.test.processorpath}">
+ <customize>
+ <compilerarg line="${javac.test.moduleargs}"/>
+ <additionalargs/>
+ </customize>
+ </j2semodularproject1:javac>
+ </sequential>
+ </macrodef>
+ </target>
+ <target if="do.depend.true" name="-compile-test-depend">
+ <j2semodularproject1:depend xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classpath="${javac.test.classpath}" destdir="${build.test.classes.dir}" srcdir="${test.src.dir}"/>
+ </target>
+ <target depends="init,deps-jar,compile,-init-test-module-properties,-pre-pre-compile-test,-pre-compile-test,-compile-test-depend" if="have.tests" name="-do-compile-test">
+ <j2semodularproject1:test-javac xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1"/>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" filePattern="(.*$)" modsource="${test.src.dir.path}" property="test.src.dir.path.regexp"/>
+ <echo message="Copying resources from ${test.src.dir}"/>
+ <copy todir="${build.test.modules.dir}">
+ <fileset dir="${test.src.dir}" excludes="${build.classes.excludes},${excludes}" includes="${includes}"/>
+ <regexpmapper from="${test.src.dir.path.regexp}" to="\1/\3"/>
+ </copy>
+ </target>
+ <target name="-post-compile-test">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,compile,-pre-pre-compile-test,-pre-compile-test,-do-compile-test,-post-compile-test" name="compile-test"/>
+ <target name="-pre-compile-test-single">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,deps-jar,compile,-init-test-module-properties,-pre-pre-compile-test,-pre-compile-test-single" if="have.tests" name="-do-compile-test-single">
+ <fail unless="javac.includes">Must select some files in the IDE or set javac.includes</fail>
+ <j2semodularproject1:force-recompile xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" destdir="${build.test.modules.dir}"/>
+ <j2semodularproject1:test-javac xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" includes="${javac.includes}"/>
+ <j2semodularproject1:modsource_regexp xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" filePattern="(.*$)" modsource="${test.src.dir.path}" property="test.src.dir.path.regexp"/>
+ <echo message="Copying resources from ${test.src.dir}"/>
+ <copy todir="${build.test.modules.dir}">
+ <fileset dir="${test.src.dir}" excludes="${build.classes.excludes},${excludes}" includes="${includes}"/>
+ <regexpmapper from="${test.src.dir.path.regexp}" to="\1/\3"/>
+ </copy>
+ </target>
+ <target name="-post-compile-test-single">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,compile,-pre-pre-compile-test,-pre-compile-test-single,-do-compile-test-single,-post-compile-test-single" name="compile-test-single"/>
+ <!--
+ =======================
+ TEST EXECUTION SECTION
+ =======================
+ -->
+ <target depends="init" if="have.tests" name="-pre-test-run">
+ <mkdir dir="${build.test.results.dir}"/>
+ </target>
+ <target name="-init-test-run">
+ <property name="run.modules.dir" value="${build.test.modules.dir}"/>
+ </target>
+ <target depends="init,compile-test,-init-test-run-module-properties,-pre-test-run" if="have.tests" name="-do-test-run">
+ <j2semodularproject1:test xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" includes="${includes}" testincludes="**/*Test.java"/>
+ </target>
+ <target depends="init,compile-test,-pre-test-run,-do-test-run" if="have.tests" name="-post-test-run">
+ <fail if="tests.failed" unless="ignore.failing.tests">Some tests failed; see details above.</fail>
+ </target>
+ <target depends="init" if="have.tests" name="test-report"/>
+ <target depends="init" if="netbeans.home+have.tests" name="-test-browse"/>
+ <target depends="init,compile-test,-pre-test-run,-do-test-run,test-report,-post-test-run,-test-browse" description="Run unit tests." name="test"/>
+ <target depends="init" if="have.tests" name="-pre-test-run-single">
+ <mkdir dir="${build.test.results.dir}"/>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-pre-test-run-single" if="have.tests" name="-do-test-run-single">
+ <fail unless="test.includes">Must select some files in the IDE or set test.includes</fail>
+ <j2semodularproject1:test xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="" includes="${test.includes}" testincludes="${test.includes}"/>
+ </target>
+ <target depends="init,compile-test-single,-pre-test-run-single,-do-test-run-single" if="have.tests" name="-post-test-run-single">
+ <fail if="tests.failed" unless="ignore.failing.tests">Some tests failed; see details above.</fail>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-pre-test-run-single,-do-test-run-single,-post-test-run-single" description="Run single unit test." name="test-single"/>
+ <target depends="init,compile-test-single,-pre-test-run-single" if="have.tests" name="-do-test-run-single-method">
+ <fail unless="test.class">Must select some files in the IDE or set test.class</fail>
+ <fail unless="test.method">Must select some method in the IDE or set test.method</fail>
+ <j2semodularproject1:test xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="" includes="${javac.includes}" testincludes="${test.class}" testmethods="${test.method}"/>
+ </target>
+ <target depends="init,compile-test-single,-pre-test-run-single,-do-test-run-single-method" if="have.tests" name="-post-test-run-single-method">
+ <fail if="tests.failed" unless="ignore.failing.tests">Some tests failed; see details above.</fail>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-pre-test-run-single,-do-test-run-single-method,-post-test-run-single-method" description="Run single unit test." name="test-single-method"/>
+ <!--
+ =======================
+ TEST DEBUGGING SECTION
+ =======================
+ -->
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-pre-test-run-single" if="have.tests" name="-debug-start-debuggee-test">
+ <fail unless="test.class">Must select one file in the IDE or set test.class</fail>
+ <j2semodularproject1:test-debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="" includes="${javac.includes}" testClass="${test.class}" testincludes="${javac.includes}"/>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-pre-test-run-single" if="have.tests" name="-debug-start-debuggee-test-method">
+ <fail unless="test.class">Must select one file in the IDE or set test.class</fail>
+ <fail unless="test.method">Must select some method in the IDE or set test.method</fail>
+ <j2semodularproject1:test-debug xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" excludes="" includes="${javac.includes}" testClass="${test.class}" testMethod="${test.method}" testincludes="${test.class}" testmethods="${test.method}"/>
+ </target>
+ <target depends="init,compile-test" if="netbeans.home+have.tests" name="-debug-start-debugger-test">
+ <j2semodularproject1:nbjpdastart xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1" classpath="${debug.test.classpath}" name="${test.class}"/>
+ </target>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-debug-start-debugger-test,-debug-start-debuggee-test" name="debug-test"/>
+ <target depends="init,compile-test-single,-init-test-run-module-properties,-debug-start-debugger-test,-debug-start-debuggee-test-method" name="debug-test-method"/>
+ <target depends="init,-pre-debug-fix,compile-test-single" if="netbeans.home" name="-do-debug-fix-test">
+ <property name="debug.modules.dir" value="${build.test.modules.dir}"/>
+ <j2semodularproject1:nbjpdareload xmlns:j2semodularproject1="http://www.netbeans.org/ns/j2se-modular-project/1"/>
+ </target>
+ <target depends="init,-pre-debug-fix,-do-debug-fix-test" if="netbeans.home" name="debug-fix-test"/>
+ <!--
+ =========================
+ APPLET EXECUTION SECTION
+ =========================
+ -->
+ <target name="run-applet">
+ <fail message="Applets are no longer supported by JDK 9"/>
+ </target>
+ <!--
+ =========================
+ APPLET DEBUGGING SECTION
+ =========================
+ -->
+ <target name="-debug-start-debuggee-applet">
+ <fail message="Applets are no longer supported by JDK 9"/>
+ </target>
+ <target name="debug-applet">
+ <fail message="Applets are no longer supported by JDK 9"/>
+ </target>
+ <!--
+ ===============
+ CLEANUP SECTION
+ ===============
+ -->
+ <target name="-deps-clean-init" unless="built-clean.properties">
+ <property location="${build.dir}/built-clean.properties" name="built-clean.properties"/>
+ <delete file="${built-clean.properties}" quiet="true"/>
+ </target>
+ <target if="already.built.clean.${basedir}" name="-warn-already-built-clean">
+ <echo level="warn" message="Cycle detected: notzed.dez was already built"/>
+ </target>
+ <target depends="init,-deps-clean-init" name="deps-clean" unless="no.deps">
+ <mkdir dir="${build.dir}"/>
+ <touch file="${built-clean.properties}" verbose="false"/>
+ <property file="${built-clean.properties}" prefix="already.built.clean."/>
+ <antcall target="-warn-already-built-clean"/>
+ <propertyfile file="${built-clean.properties}">
+ <entry key="${basedir}" value=""/>
+ </propertyfile>
+ <antcall target="-maybe-call-dep">
+ <param name="call.built.properties" value="${built-clean.properties}"/>
+ <param location="${project.notzed_nativez}" name="call.subproject"/>
+ <param location="${project.notzed_nativez}/build.xml" name="call.script"/>
+ <param name="call.target" value="clean"/>
+ <param name="transfer.built-clean.properties" value="${built-clean.properties}"/>
+ <param name="transfer.not.archive.disabled" value="true"/>
+ <param name="transfer.do.jlink" value="false"/>
+ </antcall>
+ </target>
+ <target depends="init" name="-do-clean">
+ <delete dir="${build.dir}"/>
+ <delete dir="${dist.jlink.output}"/>
+ <delete dir="${dist.dir}" followsymlinks="false" includeemptydirs="true"/>
+ </target>
+ <target name="-post-clean">
+ <!-- Empty placeholder for easier customization. -->
+ <!-- You can override this target in the ../build.xml file. -->
+ </target>
+ <target depends="init,deps-clean,-do-clean,-post-clean" description="Clean build products." name="clean"/>
+ <target name="-check-call-dep">
+ <property file="${call.built.properties}" prefix="already.built."/>
+ <condition property="should.call.dep">
+ <and>
+ <not>
+ <isset property="already.built.${call.subproject}"/>
+ </not>
+ <available file="${call.script}"/>
+ </and>
+ </condition>
+ </target>
+ <target depends="-check-call-dep" if="should.call.dep" name="-maybe-call-dep">
+ <ant antfile="${call.script}" inheritall="false" target="${call.target}">
+ <propertyset>
+ <propertyref prefix="transfer."/>
+ <mapper from="transfer.*" to="*" type="glob"/>
+ </propertyset>
+ </ant>
+ </target>
+</project>
--- /dev/null
+build.xml.data.CRC32=508a6882
+build.xml.script.CRC32=b55362bc
+build.xml.stylesheet.CRC32=32069288@1.6.1
+# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
+# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
+nbproject/build-impl.xml.data.CRC32=e4239d52
+nbproject/build-impl.xml.script.CRC32=4564887e
+nbproject/build-impl.xml.stylesheet.CRC32=0f0529df@1.6.1
--- /dev/null
+annotation.processing.enabled=true
+annotation.processing.enabled.in.editor=false
+annotation.processing.processors.list=
+annotation.processing.run.all.processors=true
+annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output
+application.title=notzed.dez
+application.vendor=notzed
+build.classes.dir=${build.dir}/classes
+build.classes.excludes=**/*.java,**/*.form
+# This directory is removed when the project is cleaned:
+build.dir=build
+build.generated.dir=${build.dir}/generated
+build.generated.sources.dir=${build.dir}/generated-sources
+build.modules.dir=${build.dir}/modules
+# Only compile against the classpath explicitly listed here:
+build.sysclasspath=ignore
+build.test.classes.dir=${build.dir}/test/classes
+build.test.modules.dir=${build.dir}/test/modules
+build.test.results.dir=${build.dir}/test/results
+# Uncomment to specify the preferred debugger connection transport:
+#debug.transport=dt_socket
+debug.classpath=\
+ ${run.classpath}
+debug.modulepath=\
+ ${run.modulepath}
+debug.test.classpath=\
+ ${run.test.classpath}
+debug.test.modulepath=\
+ ${run.test.modulepath}
+# Files in build.classes.dir which should be excluded from distribution jar
+dist.archive.excludes=
+# This directory is removed when the project is cleaned:
+dist.dir=dist
+dist.javadoc.dir=${dist.dir}/javadoc
+dist.jlink.dir=${dist.dir}/jlink
+dist.jlink.output=${dist.jlink.dir}/notzed.dez
+endorsed.classpath=
+excludes=
+includes=**
+jar.compress=false
+javac.classpath=
+# Space-separated list of extra javac options
+javac.compilerargs=-Xlint:unchecked
+javac.deprecation=false
+javac.external.vm=false
+javac.modulepath=
+javac.processormodulepath=
+javac.processorpath=\
+ ${javac.classpath}
+javac.source=11
+javac.target=11
+javac.test.classpath=\
+ ${javac.classpath}:\
+ ${libs.junit_4.classpath}:\
+ ${libs.hamcrest.classpath}
+javac.test.modulepath=\
+ ${javac.modulepath}:\
+ ${build.modules.dir}
+javac.test.processorpath=\
+ ${javac.test.classpath}
+javadoc.additionalparam=
+javadoc.author=false
+javadoc.encoding=${source.encoding}
+javadoc.html5=false
+javadoc.noindex=false
+javadoc.nonavbar=false
+javadoc.notree=false
+javadoc.private=false
+javadoc.splitindex=true
+javadoc.use=true
+javadoc.version=false
+javadoc.windowtitle=
+# The jlink additional root modules to resolve
+jlink.additionalmodules=
+# The jlink additional command line parameters
+jlink.additionalparam=
+jlink.launcher=true
+jlink.launcher.name=notzed.dez
+platform.active=default_platform
+run.classpath=
+# Space-separated list of JVM arguments used when running the project.
+# You may also define separate properties like run-sys-prop.name=value instead of -Dname=value.
+# To set system properties for unit tests define test-sys-prop.name=value:
+run.jvmargs=
+run.modulepath=\
+ ${javac.modulepath}:\
+ ${build.modules.dir}
+run.test.classpath=\
+ ${javac.test.classpath}
+run.test.modulepath=\
+ ${javac.test.modulepath}:\
+ ${build.test.modules.dir}
+source.encoding=UTF-8
+src.dir=src
+src.dir.path=classes
+test.src.dir=src
+test.src.dir.path=tests
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+ <type>org.netbeans.modules.java.j2semodule</type>
+ <configuration>
+ <data xmlns="http://www.netbeans.org/ns/j2se-modular-project/1">
+ <name>notzed.dez</name>
+ <source-roots>
+ <root id="src.dir" pathref="src.dir.path"/>
+ </source-roots>
+ <test-roots>
+ <root id="test.src.dir" pathref="test.src.dir.path"/>
+ </test-roots>
+ </data>
+ <references xmlns="http://www.netbeans.org/ns/ant-project-references/1">
+ <reference>
+ <foreign-project>notzed_nativez</foreign-project>
+ <artifact-type>jar</artifact-type>
+ <script>build.xml</script>
+ <target>jar</target>
+ <clean-target>clean</clean-target>
+ <id>notzed.nativez.jar</id>
+ </reference>
+ </references>
+ </configuration>
+</project>
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez.demo;
+
+import au.notzed.dez.DEZFormat;
+import java.io.PrintStream;
+
+/**
+ * Prints a DEZ patch.
+ * <p>
+ * Displays the editing commands and some stats.
+ * <p>
+ * @see au.notzed.dez.DEZEncoder
+ */
+public class DEZPrinter implements DEZFormat {
+
+ private final byte[] patch;
+ private int pi, si;
+ // Recent address cache. TODO: These can be combined
+ private final int[] matchAddr = new int[64];
+ private int matchNext = 0;
+ private int[] recentAddr = new int[32];
+ private int recentNext = 0;
+ // some statistics.
+ private Stats copy = new Stats();
+ private Stats add = new Stats();
+ private Stats run = new Stats();
+
+ public DEZPrinter(byte[] patch) {
+ this.patch = patch;
+ }
+
+ private int decodeInt() {
+ int v = 0;
+ byte b;
+
+ do {
+ b = patch[pi++];
+ v = (v << 7) | (b & 0x7f);
+ } while ((b & 0x80) != 0);
+
+ return v;
+ }
+
+ private void updateAddr(int addr) {
+ recentAddr[recentNext++] = addr;
+ recentNext &= recentAddr.length - 1;
+ matchAddr[matchNext++] = addr;
+ matchNext &= matchAddr.length - 1;
+ }
+
+ private int decodeAddr() {
+ int addr;
+
+ int op = patch[pi];
+
+ if ((op & 0x80) == 0) {
+ // An encoded address
+ if ((op & 0x40) == 0) {
+ //direct
+ pi++;
+ addr = matchAddr[op & 63];
+ } else {
+ // signed relative
+ pi++;
+ int d = decodeInt();
+ if ((op & 0x20) != 0)
+ d = -d;
+ addr = recentAddr[op & 31] + d;
+ }
+ } else {
+ // Normal address
+ addr = decodeInt();
+ }
+ updateAddr(addr);
+ return addr;
+ }
+
+ /**
+ * Dumps the patch details to stdout.
+ *
+ */
+ public void print() {
+ DEZPrinter.this.print(System.out);
+ }
+
+ public void print(PrintStream out) {
+ int ti = 0;
+ int flags;
+ int smallest = 4;
+
+ pi = 0;
+ si = 0;
+
+ // 'decode' magic
+ out.printf("magic: %c%c%c%c\n", patch[0], patch[1], patch[2], patch[3]);
+ pi += 4;
+ // decode flags
+ flags = patch[pi++];
+ out.printf("flags: %02x\n", flags & 0xff);
+
+ if ((flags & DEZ_SMALLEST) != 0)
+ smallest = decodeInt();
+ out.printf("smallest: %d\n", smallest);
+
+ // get sizes
+ int sourceSize = decodeInt();
+ int targetSize = decodeInt();
+
+ int oc = 0;
+
+ out.printf("source: %d\ntarget: %d\n", sourceSize, targetSize, patch.length);
+
+ while (ti < targetSize) {
+ int op = patch[pi++] & 0xff;
+
+ out.printf("%02x ", op);
+
+ if ((op & 0x80) == 0) {
+ // One-byte pair commands
+ if ((op & 0x40) == 0) {
+ // 00AAACCC
+ int add = ((op >> 3) & 0x07) + 1;
+ int copy = (op & 0x07) + smallest;
+ int addr;
+
+ pi += add;
+ addr = decodeAddr();
+
+ out.printf("%08x: ADD %d COPY %d @ $%08x\n",
+ ti, add, copy, addr);
+ ti += add + copy;
+
+ this.add.add(add);
+ this.copy.add(copy);
+ } else {
+ // 01cccCCC
+ int copy0 = ((op >> 3) & 0x07) + smallest;
+ int copy1 = (op & 0x07) + smallest;
+ int addr0 = decodeAddr();
+ int addr1 = decodeAddr();
+
+ out.printf("%08x: COPY %d @ $%08x COPY %d @ $%08x\n",
+ ti, copy0, addr0, copy1, addr1);
+ ti += copy0 + copy1;
+
+ this.copy.add(copy0);
+ this.copy.add(copy1);
+ }
+ } else {
+ // 1NNNNNNN
+ // 0 ... 99 copy smallest ... 99+smallest
+ // 100 ... 123 add 1 ... 24
+ // 124 copy + length
+ // 125 add + length
+ // 126 run + length + byte
+ // 127 ext command
+ int n = op & 0x7f;
+
+ if (n < OP_SINGLE_SPLIT) {
+ // COPY + addr
+ int copy = n + smallest;
+ int addr = decodeAddr();
+
+ out.printf("%08x: COPY %d @ $%08x\n", ti, copy, addr);
+ ti += copy;
+
+ this.copy.add(copy);
+ } else if (n < 124) {
+ // ADD + data
+ int add = n - OP_SINGLE_SPLIT + 1;
+
+ out.printf("%08x: ADD %d\n", ti, add);
+ ti += add;
+ pi += add;
+
+ this.add.add(add);
+ } else if (n == 124) {
+ // COPY + length + addr
+ int copy = decodeInt() + smallest + OP_SINGLE_SPLIT;
+ int addr = decodeAddr();
+
+ out.printf("%08x: COPY %d @ $%08x\n", ti, copy, addr);
+ ti += copy;
+
+ this.copy.add(copy);
+ } else if (n == 125) {
+ // ADD + length + data
+ int add = decodeInt() + (124 - OP_SINGLE_SPLIT) + 1;
+
+ out.printf("%08x: ADD %d\n", ti, add);
+ ti += add;
+ pi += add;
+
+ this.add.add(add);
+ } else if (n == 126) {
+ // RUN + length + byte
+ int run = decodeInt() + 3;
+ byte r = patch[pi++];
+
+ out.printf("%08x: RUN $%02x %d\n", ti, r & 0xff, run);
+ ti += run;
+
+ this.run.add(run);
+ }
+ }
+ }
+ if (ti > targetSize)
+ throw new ArrayIndexOutOfBoundsException(String.format("Target overflow %d > %d", ti, targetSize));
+ if (ti != targetSize)
+ throw new ArrayIndexOutOfBoundsException(String.format("Target short write %d != %d", ti, targetSize));
+
+ out.printf("summary\n");
+ out.printf(" copy: %s\n", copy);
+ out.printf(" add: %s\n", add);
+ out.printf(" run: %s\n", run);
+ out.printf("patch: %d\n", pi);
+ out.printf("sorce: %d\n", sourceSize);
+ out.printf("targt: %d\n", targetSize);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez.demo;
+
+import au.notzed.dez.ByteDeltaEncoder;
+
+/**
+ * A dummy encoder for debugging purposes.
+ */
+public class PrintEncoder implements ByteDeltaEncoder {
+
+ int oc = 0;
+
+ @Override
+ public void init(int sourceSize, int targetSize) {
+ System.out.printf("source = %d, target=%d\n", sourceSize, targetSize);
+ }
+
+ @Override
+ public void copy(int addr, int len) {
+ System.out.printf("%5d: COPY @ %d for %d\n", oc++, addr, len);
+ }
+
+ @Override
+ public void add(byte[] data, int off, int len) {
+ System.out.printf("%5d: ADD @ %d for %d\n", oc++, off, len);
+ }
+
+ @Override
+ public void run(byte b, int len) {
+ System.out.printf("%5d: RUN $%02x for %d\n", oc++, b & 0xff, len);
+ }
+
+ @Override
+ public byte[] toPatch() {
+ return new byte[0];
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez.demo;
+
+/**
+ * Basic incremental stats accumulator.
+ * <p>
+ * This may be used as a streaming collector/reducer.
+ */
+public class Stats {
+
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ long sum = 0;
+ int count = 0;
+
+ public void add(int v) {
+ sum += v;
+ count += 1;
+ min = Math.min(v, min);
+ max = Math.max(v, max);
+ }
+
+ public void addAll(Stats o) {
+ sum += o.sum;
+ count += o.count;
+ min = Math.min(o.min, min);
+ max = Math.min(o.max, max);
+ }
+
+ public long getSum() {
+ return sum;
+ }
+
+ public int getMax() {
+ return max;
+ }
+
+ public int getMin() {
+ return min;
+ }
+
+ public double getMean() {
+ return (double) sum / count;
+ }
+
+ @Override
+ public String toString() {
+ if (count == 0)
+ return "min/max/ave = 0 / 0 / 0";
+ return String.format("min/max/ave = %d / %d / %f", min, max, (double) sum / count);
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez.demo;
+
+import au.notzed.dez.ByteDeltaEncoder;
+import au.notzed.dez.ByteMatcherHash;
+import au.notzed.dez.DEZDecoder;
+import au.notzed.dez.DEZEncoder;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+/**
+ * A basic tool.
+ * <p>
+ * Creating a delta:
+ * <code>java -cp au.notzed.dez.DEZ -c source target > patch</code>
+ * <p>
+ * Restoring a delta:
+ * <code>java -cp au.notzed.dez.DEZ -d source patch > restored</code>
+ * <p>
+ * Printing delta:
+ * <code>java -cp au.notzed.dez.DEZ -p patch</code>
+ *
+ */
+public class dez {
+
+ static void usage() {
+ System.err.println("Usage:\n");
+ System.err.println(" create:\n dez -c source target > patch");
+ System.err.println(" decode:\n dez -d source patch > target");
+ System.err.println(" print:\n dez -p patch");
+ System.exit(1);
+ }
+
+ static void create(String source, String target) {
+ try {
+ byte[] s = Files.readAllBytes(Paths.get(source));
+ byte[] t = Files.readAllBytes(Paths.get(target));
+
+ byte[] p = ByteDeltaEncoder.toDiff(new ByteMatcherHash(6, 4, s, 1, t), new DEZEncoder());
+
+ System.out.write(p);
+ } catch (IOException ex) {
+ System.err.printf("IOError: %s\n", ex.getLocalizedMessage());
+ }
+ }
+
+ static void decode(String source, String patch) {
+ try {
+ byte[] s = Files.readAllBytes(Paths.get(source));
+ byte[] p = Files.readAllBytes(Paths.get(patch));
+
+ byte[] t = new DEZDecoder(s, p).decode();
+
+ System.out.write(t);
+ } catch (IOException ex) {
+ System.err.printf("IOError: %s\n", ex.getLocalizedMessage());
+ }
+ }
+
+ static void print(String patch) {
+ try {
+ byte[] p = Files.readAllBytes(Paths.get(patch));
+
+ new DEZPrinter(p).print();
+ } catch (IOException ex) {
+ System.err.printf("IOError: %s\n", ex.getLocalizedMessage());
+ }
+ }
+
+ public static void main(String[] args) {
+ if (args.length < 2) {
+ usage();
+ return;
+ }
+
+ switch (args[0]) {
+ case "-c":
+ if (args.length == 3)
+ create(args[1], args[2]);
+ else
+ usage();
+ break;
+ case "-d":
+ if (args.length == 3)
+ decode(args[1], args[2]);
+ else
+ usage();
+ break;
+ case "-p":
+ if (args.length == 2)
+ print(args[1]);
+ else
+ usage();
+ break;
+ default:
+ usage();
+ break;
+ }
+
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2019 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+module notzed.dez.demo {
+ requires transitive notzed.dez;
+
+ exports au.notzed.dez.demo;
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+/**
+ * The interface for encoding a delta.
+ * <p>
+ * A delta encoder will implement a specific file/transfer format.
+ */
+public interface ByteDeltaEncoder {
+
+ /**
+ * Initialises creating a new patch.
+ *
+ * @param sourceSize
+ * @param targetSize
+ */
+ public void init(int sourceSize, int targetSize);
+
+ /**
+ * Appends a copy command.
+ *
+ * @param addr
+ * @param len
+ */
+ public void copy(int addr, int len);
+
+ /**
+ * Appends an append command.
+ *
+ * @param data
+ * @param off
+ * @param len
+ */
+ public void add(byte[] data, int off, int len);
+
+ /**
+ * Appends a byte-run.
+ *
+ * @param b
+ * @param len
+ */
+ public void run(byte b, int len);
+
+ /**
+ * Retrieves the patch.
+ *
+ * @return
+ */
+ public byte[] toPatch();
+
+ /**
+ * Creates a delta from a matcher and writes it to an encoder.
+ *
+ * @param matcher
+ * @param enc
+ * @return
+ */
+ public static byte[] toDiff(ByteMatcher matcher, ByteDeltaEncoder enc) {
+ byte[] source = matcher.getSource();
+ byte[] target = matcher.getTarget();
+
+ enc.init(source.length, target.length);
+
+ int targetEnd = 0;
+ int state;
+
+ while ((state = matcher.nextMatch()) != ByteMatcher.EOF) {
+ int toff = matcher.getTargetOffset();
+ int slength = matcher.getLength();
+
+ if (targetEnd != toff)
+ enc.add(target, targetEnd, toff - targetEnd);
+
+ if (state == ByteMatcher.RUN)
+ enc.run(matcher.getRunByte(), slength);
+ else
+ enc.copy(matcher.getMatchOffset(), slength);
+
+ targetEnd = toff + slength;
+ }
+ if (targetEnd != target.length)
+ enc.add(target, targetEnd, target.length - targetEnd);
+
+ return enc.toPatch();
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+/**
+ * Common interface for byte matchers.
+ * <p>
+ * Byte matchers look for common sub-strings between a source and
+ * a target byte array and may optionally detect runs of duplicated
+ * bytes.
+ */
+public interface ByteMatcher {
+
+ public final static int COPY = 0;
+ public final static int RUN = 1;
+ public static final int EOF = -1;
+
+ /**
+ * Finds the next match or run.
+ * <p>
+ * Note that only matches or byte runs will be indicated. The location
+ * of non-matching data (i.e. append sequences) must be determined from
+ * the difference between the last targetOffset, the last length, and the
+ * current targetOffset.
+ * </p>
+ *
+ * @return the new state.
+ */
+ public int nextMatch();
+
+ /**
+ * Retrieves the current target position.
+ * <p>
+ * The position within the target to which the current match refers.
+ *
+ * @return
+ */
+ public int getTargetOffset();
+
+ /**
+ * Retrieves the best match location.
+ * <p>
+ * If the current state is COPY then this returns a valid location
+ * of the best match. This should be interpreted
+ * using {@link #getBlockArray} and {@link #getBlockOffset}.
+ *
+ * @return
+ */
+ public int getMatchOffset();
+
+ /**
+ * Retrieves the byte to be run-length encoded.
+ * <p>
+ * If the current state is RUN then this returns the corresponding byte to run.
+ *
+ * @return
+ */
+ public byte getRunByte();
+
+ /**
+ * Retrieves the current length.
+ * <p>
+ * This is the number of bytes to copy for the COPY state or repeat for the RUN state.
+ *
+ * @return
+ */
+ public int getLength();
+
+ /**
+ * Retrieves the array containing the current match.
+ * <p>
+ * Maps the offset to the correct internal array.
+ *
+ * @param offset
+ * @return
+ * @see getBlockOffset
+ */
+ public byte[] getBlockArray(int offset);
+
+ /**
+ * Calculates the offset for the block array.
+ * <p>
+ * Maps the match offset to the array from <code>getBlockArray</code>.
+ *
+ * @param offset
+ * @return
+ * @see getBlockArray
+ */
+ public int getBlockOffset(int offset);
+
+ public byte[] getSource();
+
+ public byte[] getTarget();
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import java.util.Arrays;
+
+/**
+ * Finds common strings of bytes between a source and target buffer.
+ * <p>
+ * This is basically an implementation of Bentley & McIllroy's paper
+ * ``Data Compression Using Long Common Strings'' applied instead to producing
+ * deltas and using a cyclic hash as the fingerprint function.
+ * <p>
+ * Two other
+ * modifications are that back-tracking is not implemented but instead
+ * overlapping blocks can be used by setting the step size.
+ * And a further refinement is the detection of runs of the same byte which
+ * might otherwise pollute the hash tree for certain data.
+ */
+public class ByteMatcherHash implements ByteMatcher {
+
+ private final int b;
+ private final int shortest;
+ private final byte[] source;
+ private final int sstep;
+ private final byte[] target;
+ // Incremental hashes
+ private final CyclicHash targetHash;
+ private final CyclicHash sourceHash;
+ // Runtime state
+ private int ti;
+ private int thash;
+ private int skipTo;
+ private int targetAvailable;
+ // Public state
+ private int bestLength;
+ private int bestOffset;
+ private int targetOffset;
+ private byte runByte;
+ // Data to implement chain limit.
+ private int limit = Integer.MAX_VALUE;
+ private int roll = 1;
+
+ /**
+ * Inline hash+array table.
+ * <p>
+ * All values which hash the same are appended to the same list.
+ * <p>
+ * Index is the current length/next insertion point for that hash chain.
+ * Values contains the chained hash table values.
+ */
+ final private int hashMask;
+ final private int[][] hashValues;
+
+ /**
+ * Creates and initialises a new byte matcher.
+ * <p>
+ * This is a single-use object.
+ * <p>
+ * A step size of 1 produces the best output but requires the most memory and run time.
+ * <p>
+ * @param b Sets block size, which is the number of bytes hashed per key (>=3).
+ * @param shortest shortest string considered for a copy. Typically 4 bytes but dependent on the encoder used and
+ * the value of b.
+ * @param source Source array.
+ * @param sstep Sets the step size which is the interval of sampling of the source.
+ * @param target Target array.
+ */
+ public ByteMatcherHash(int b, int shortest, byte[] source, int sstep, byte[] target) {
+ int size;
+
+ b = Math.max(b, 3);
+
+ // This may need tuning.
+ int logN = 31 - Integer.numberOfLeadingZeros((source.length + target.length) / sstep);
+ size = 1 << Math.max(14, logN - 5);
+
+ hashMask = size - 1;
+ hashValues = new int[size][];
+
+ targetHash = new CyclicHash(b);
+ sourceHash = new CyclicHash(b);
+
+ this.b = b;
+ this.shortest = shortest;
+ this.source = source;
+ this.sstep = sstep;
+ this.target = target;
+
+ addAll(source, source.length, 0, 0);
+ if (target.length >= b)
+ this.thash = targetHash.init(target, 0);
+ }
+
+ /**
+ * Checks for run of 3 bytes.
+ * <p>
+ * Boundaries are not checked.
+ *
+ * @param s
+ * @param pos
+ * @return
+ */
+ private boolean isRun(byte[] s, int pos) {
+ byte v = s[pos];
+ return v == s[pos + 1] && v == s[pos + 2];
+ }
+
+ private int addAll(byte[] s, int limit, int pos, int off) {
+ if (sstep == 1) {
+ if (pos == 0 && limit >= b) {
+ add(sourceHash.init(s, 0), off);
+ pos = 1;
+ }
+
+ while (pos <= limit - b) {
+ int hash = sourceHash.update(s[pos - 1], s[pos - 1 + b]);
+
+ if (!isRun(s, pos))
+ add(hash, pos + off);
+ pos += 1;
+ }
+ } else {
+ while (pos <= limit - b) {
+ if (!isRun(s, pos))
+ add(sourceHash.init(s, pos), pos + off);
+ pos += sstep;
+ }
+ }
+ return pos;
+ }
+
+ /**
+ * Sets the hash bucket chain limit.
+ * <p>
+ * Limiting this value will reduce the search for common prefixes
+ * which will in turn limit the search accuracy. A runtime/quality
+ * trade-off.
+ * <p>
+ * By default there is no limit.
+ *
+ * @param value A value between 2 and 30 which sets the length limit to (1<<value)-1.
+ */
+ public void setChainLimit(int value) {
+ if (value >= 31)
+ this.limit = Integer.MAX_VALUE;
+ else
+ this.limit = (1 << Math.max(2, value));
+ }
+
+ private void add(int hash, int value) {
+ int j = hash & hashMask;
+ int[] vs = hashValues[j];
+
+ if (vs == null) {
+ hashValues[j] = vs = new int[4];
+ vs[0] = 2;
+ vs[1] = value;
+ } else {
+ int i = vs[0];
+
+ if (i < limit) {
+ if (i >= vs.length)
+ hashValues[j] = vs = Arrays.copyOf(vs, vs.length * 2);
+ vs[i++] = value;
+ vs[0] = i;
+ } else {
+ int ri = (roll++) & (vs.length - 1);
+
+ if (ri == 0)
+ ri = 1;
+ vs[ri] = value;
+
+ //vs[roll++] = value;
+ //if (roll == vs.length)
+ // roll = 1;
+ }
+ }
+ }
+
+ /**
+ * Finds the length of similarity between the two sub-arrays.
+ * <p>
+ *
+ * @param soff source offset starting location, locations above source.length refer to the target buffer.
+ * @param toff target offset starting location
+ * @param bestLength sets the current best length. Used to short-circuit 'definitely can't be longer' cases.
+ * @return how many bytes are sequentially identical.
+ */
+ private int matchLength(int soff, int toff, int bestLength) {
+ if (soff < source.length) {
+ int limit = Math.min(source.length - soff, target.length - toff);
+
+ if (limit < bestLength
+ || (limit > bestLength && source[soff + bestLength] != target[toff + bestLength]))
+ return 0;
+
+ for (int i = 0; i < limit; i++)
+ if (source[soff + i] != target[toff + i])
+ return i;
+ return limit;
+ } else {
+ soff -= source.length;
+ int limit = Math.min(target.length - soff, target.length - toff);
+
+ if (limit < bestLength
+ || (limit > bestLength && target[soff + bestLength] != target[toff + bestLength]))
+ return 0;
+
+ for (int i = 0; i < limit; i++)
+ if (target[soff + i] != target[toff + i])
+ return i;
+ return limit;
+ }
+ }
+
+ @Override
+ public byte[] getSource() {
+ return source;
+ }
+
+ @Override
+ public byte[] getTarget() {
+ return target;
+ }
+
+ @Override
+ public int getMatchOffset() {
+ return bestOffset;
+ }
+
+ @Override
+ public int getTargetOffset() {
+ return targetOffset;
+ }
+
+ @Override
+ public int getLength() {
+ return bestLength;
+ }
+
+ @Override
+ public byte getRunByte() {
+ return runByte;
+ }
+
+ @Override
+ public int nextMatch() {
+ bestLength = 0;
+ bestOffset = 0;
+
+ /**
+ * Reset thash on seek.
+ */
+ if (skipTo != ti) {
+ if (skipTo <= target.length - b)
+ thash = targetHash.init(target, skipTo);
+ ti = skipTo;
+ }
+
+ while (bestLength < shortest && ti <= target.length - b) {
+ /**
+ * Short circuit test for byte-runs.
+ */
+ if (isRun(target, ti)) {
+ byte b0 = target[ti];
+ int j = ti + 3;
+ while (j < target.length && target[j] == b0)
+ j++;
+ targetOffset = ti;
+ bestLength = j - ti;
+ runByte = b0;
+ skipTo = j;
+ return RUN;
+ }
+
+ /**
+ * Include any of the target buffer which has been decoded to this point to the hash table.
+ */
+ targetAvailable = addAll(target, ti + b - 1, targetAvailable, source.length);
+
+ /**
+ * Checks the current string for the longest match against the hash table.
+ */
+ int j = thash & hashMask;
+ int[] soffs = hashValues[j];
+
+ if (soffs != null) {
+ int len = soffs[0];
+
+ for (int i = 1; i < len; i++) {
+ int soff = soffs[i];
+ int length = matchLength(soff, ti, bestLength);
+
+ if (length > bestLength) {
+ bestLength = length;
+ bestOffset = soff;
+ }
+ }
+ }
+
+ /**
+ * Advance. thash is always the next block to examine.
+ */
+ targetOffset = ti;
+ ti += 1;
+ if (ti <= target.length - b)
+ thash = targetHash.update(target[ti - 1], target[ti - 1 + b]);
+ }
+
+ if (bestLength >= shortest) {
+ skipTo = targetOffset + bestLength;
+ return COPY;
+ } else
+ return EOF;
+ }
+
+ @Override
+ public byte[] getBlockArray(int offset) {
+ return (offset < source.length) ? source : target;
+ }
+
+ @Override
+ public int getBlockOffset(int offset) {
+ return (offset < source.length) ? offset : offset - source.length;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+
+import static java.lang.Integer.rotateLeft;
+import java.util.Random;
+
+/**
+ * Cyclic polynomial rolling hash.
+ * <p>
+ * This implements a rolling hash of a fixed length.
+ * <p>
+ * Input bytes are hashed using a random table. The randomness
+ * affects the quality of the hash.
+ */
+public class CyclicHash {
+
+ private static final int[] random;
+
+ private final int b;
+ private int hash;
+ private final int first;
+ private final int bits = 9;
+
+ static {
+ // keyboard bashed the results unvalidated.
+ random = new Random(97435).ints(256).toArray();
+ }
+
+ /**
+ * Creates a cyclic hash.
+ *
+ * @param b
+ */
+ public CyclicHash(int b) {
+ this.b = b;
+ this.first = ((b - 1) * bits) & 31;
+ }
+
+ /**
+ * Initialises the hash.
+ * <p>
+ * This will hash a block of data at the given location.
+ *
+ * @param data
+ * @param off
+ * @return
+ */
+ public int init(byte[] data, int off) {
+ hash = 0;
+ for (int i = 0; i < b; i++)
+ hash = rotateLeft(hash, bits) ^ random[data[i + off] & 0xff];
+ return hash;
+ }
+
+ /**
+ * Updates the hash incrementally.
+ * <p>
+ * Advance the hash by one location.
+ *
+ * @param leave the byte leaving. Must match the oldest byte included in the hash value.
+ * @param enter the byte entering.
+ * @return
+ */
+ public int update(byte leave, byte enter) {
+ int leaving = rotateLeft(random[leave & 0xff], first);
+ int entering = random[enter & 0xff];
+
+ hash = rotateLeft(hash ^ leaving, bits) ^ entering;
+ return hash;
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+/**
+ * Decodes a DEZ patch.
+ * <p>
+ * @see au.notzed.dez.DEZEncoder
+ */
+public class DEZDecoder implements DEZFormat {
+
+ final static boolean dump = false;
+
+ private final byte[] source;
+ private final byte[] patch;
+ private int pi, si;
+ // recent address cache. TODO: These can be combined
+ private int[] matchAddr = new int[64];
+ private int matchNext = 0;
+ private int[] recentAddr = new int[32];
+ private int recentNext = 0;
+
+ public DEZDecoder(byte[] source, byte[] patch) {
+ this.source = source;
+ this.patch = patch;
+ }
+
+ private int decodeInt() {
+ int v = 0;
+ byte b;
+
+ do {
+ b = patch[pi++];
+ v = (v << 7) | (b & 0x7f);
+ } while ((b & 0x80) != 0);
+
+ return v;
+ }
+
+ private int copy(int addr, byte[] target, int ti, int copy) {
+ if (addr < source.length)
+ System.arraycopy(source, addr, target, ti, copy);
+ else {
+ addr = addr - source.length;
+ for (int i = 0; i < copy; i++)
+ target[ti + i] = target[addr + i];
+ }
+ return ti + copy;
+ }
+
+ private void updateAddr(int addr) {
+ recentAddr[recentNext++] = addr;
+ recentNext &= recentAddr.length - 1;
+ matchAddr[matchNext++] = addr;
+ matchNext &= matchAddr.length - 1;
+ }
+
+ private int decodeAddr() {
+ int addr;
+ int op = patch[pi];
+
+ if ((op & 0x80) == 0) {
+ // An encoded address
+ if ((op & 0x40) == 0) {
+ //direct
+ pi++;
+ addr = matchAddr[op & 63];
+ } else {
+ // signed relative
+ pi++;
+ int d = decodeInt();
+ if ((op & 0x20) != 0)
+ d = -d;
+ addr = recentAddr[op & 31] + d;
+ //updateAddr(addr);
+ }
+ } else {
+ // Normal address
+ addr = decodeInt();
+ //updateAddr(addr);
+ }
+ updateAddr(addr);
+
+ return addr;
+ }
+
+ /**
+ * Recreates the original target data from the source and patch.
+ *
+ * @return
+ */
+ public byte[] decode() {
+ int ti = 0;
+ int smallest = 4;
+ int flags;
+
+ PrintStream out = dump ? System.out : null;
+ pi = 0;
+ si = 0;
+
+ // 'decode' magic
+ //out.printf("magic: %c%c%c%c\n", patch[0] & 0xff, patch[1] & 0xff, patch[2] & 0xff, patch[3] & 0xff);
+ pi += 4;
+ // decode flags
+ flags = patch[pi++];
+ if ((flags & DEZ_SMALLEST) != 0)
+ smallest = decodeInt();
+
+ // get sizes
+ int sourceSize = decodeInt();
+ int targetSize = decodeInt();
+
+ int oc = 0;
+
+ byte[] target = new byte[targetSize];
+
+ while (ti < targetSize) {
+ int op = patch[pi++] & 0xff;
+
+ //out.printf("%02x ", op);
+ if ((op & 0x80) == 0) {
+ // One-byte pair commands
+ if ((op & 0x40) == 0) {
+ // 00AAACCC
+ int add = (op >> 3) + 1;
+ int copy = (op & 0x07) + smallest;
+ int addr;
+
+ System.arraycopy(patch, pi, target, ti, add);
+ ti += add;
+ pi += add;
+
+ addr = decodeAddr();
+ if (dump)
+ out.printf("%08x: ADD %d COPY %d @ $%08x\n", ti, add, copy, addr);
+ ti = copy(addr, target, ti, copy);
+ } else {
+ // 01cccCCC
+ int copy0 = ((op >> 3) & 0x07) + smallest;
+ int copy1 = (op & 0x07) + smallest;
+ int addr0 = decodeAddr();
+ int addr1 = decodeAddr();
+
+ ti = copy(addr0, target, ti, copy0);
+ ti = copy(addr1, target, ti, copy1);
+
+ if (dump)
+ out.printf("%08x: COPY %d @ $%08x COPY %d @ $%08x\n", ti, copy0, addr0, copy1, addr1);
+ }
+ } else {
+ // 1NNNNNNN
+ // 0 ... 99 copy smallest ... 99+smallest
+ // 100 ... 123 add 1 ... 24
+ // 124 copy + length
+ // 125 add + length
+ // 126 run + length + byte
+ // 127 ext command
+ int n = op & 0x7f;
+
+ if (n < OP_SINGLE_SPLIT) {
+ // COPY + addr
+ int copy = n + smallest;
+ int addr = decodeAddr();
+
+ if (dump)
+ out.printf("%08x: COPY %d @ $%08x\n", ti, copy, addr);
+ ti = copy(addr, target, ti, copy);
+ } else if (n < OP_SINGLE_LIMIT) {
+ // ADD + data
+ int add = n - OP_SINGLE_SPLIT + 1;
+
+ if (dump)
+ out.printf("%08x: ADD %d\n", ti, add);
+ System.arraycopy(patch, pi, target, ti, add);
+ ti += add;
+ pi += add;
+ } else if (n == OP_COPY) {
+ // COPY + length + addr
+ int copy = decodeInt() + smallest + OP_SINGLE_SPLIT;
+ int addr = decodeAddr();
+
+ if (dump)
+ out.printf("%08x: OP_COPY %d @ $%08x\n", ti, copy, addr);
+ ti = copy(addr, target, ti, copy);
+ } else if (n == OP_ADD) {
+ // ADD + length + data
+ int add = decodeInt() + (124 - OP_SINGLE_SPLIT) + 1;
+
+ if (dump)
+ out.printf("%08x: OP_ADD %d\n", ti, add);
+ System.arraycopy(patch, pi, target, ti, add);
+ ti += add;
+ pi += add;
+ } else if (n == OP_RUN) {
+ // RUN + length + byte
+ int run = decodeInt() + 3;
+ byte r = patch[pi++];
+
+ if (dump)
+ out.printf("%08x: OP_RUN $%02x %d\n", ti, r & 0xff, run);
+ Arrays.fill(target, ti, ti + run, r);
+ ti += run;
+ }
+ }
+ }
+
+ return target;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * 'DeltaZ-1' format encoder.
+ * <p>
+ * Encoder for the a binary delta format.
+ * <p>
+ *
+ * @see au.notzed.dez.DEZDecoder
+ */
+public class DEZEncoder implements ByteDeltaEncoder, DEZFormat {
+
+ final static boolean dump = false;
+ private final ByteArrayOutputStream patch = new ByteArrayOutputStream();
+
+ int here;
+ int header;
+ int sourceSize, targetSize;
+
+ // Configurable parameters.
+ final int smallest;
+ // Last operation information
+ int last = -1;
+ byte[] lastData;
+ int lastOff;
+ int lastLen;
+ int lastAddr;
+ // Recent address cache. These can be combined?
+ private int[] matchAddr = new int[64];
+ private int matchNext = 0;
+ private int[] recentAddr = new int[32];
+ private int recentNext = 0;
+
+ /**
+ * Creates a new encoder.
+ * <p>
+ * The smallest copy size allowed is 4.
+ */
+ public DEZEncoder() {
+ this.smallest = 4;
+ }
+
+ /**
+ * Creates a new encoder with a smallest copy size.
+ *
+ * @param smallest Sets the smallest copy allowed.
+ */
+ public DEZEncoder(int smallest) {
+ this.smallest = smallest;
+ }
+
+ public void init(int sourceSize, int targetSize) {
+ try {
+ int flags = 0;
+
+ patch.reset();
+ patch.write(MAGIC);
+ if (smallest != 4)
+ flags |= DEZ_SMALLEST;
+ patch.write(flags);
+ if ((flags & DEZ_SMALLEST) != 0)
+ encodeInt(smallest);
+ encodeInt(sourceSize);
+ encodeInt(targetSize);
+ header = patch.size();
+
+ this.sourceSize = sourceSize;
+ this.targetSize = targetSize;
+ matchNext = 0;
+ recentNext = 0;
+ Arrays.fill(matchAddr, 0);
+ Arrays.fill(recentAddr, 0);
+ } catch (IOException ex) {
+ }
+ }
+
+ /**
+ * Encodes an integer.
+ * <p>
+ * Format is big-endian order encoded as:
+ * <p>
+ * CXXXXXXX+
+ * <p>
+ * Where C is the continue bit.
+ *
+ * @param addr
+ */
+ private void encodeInt(int addr) {
+ //int shift = ((31 - Integer.numberOfLeadingZeros(addr)) / 7) * 7;
+ int shift = ((32 + 6 - Integer.numberOfLeadingZeros(addr)) / 7) * 7 - 7;
+
+ // Don't need to mask the shift since only 8 bits are significant for write()
+ while (shift > 0) {
+ int v = (addr >>> shift) | 0x80;
+ patch.write(v);
+ shift -= 7;
+ }
+ patch.write((addr & 0x7f));
+ }
+
+ /**
+ * Always encodes at least two bytes even for 7 bit data.
+ *
+ * @param addr
+ */
+ private void encodeShortInt(int addr) {
+ //int shift = ((31 - Integer.numberOfLeadingZeros(addr | 0x2000)) / 7) * 7;
+ int shift = ((32 + 6 - Integer.numberOfLeadingZeros(addr | 0x2000)) / 7) * 7 - 7;
+
+ while (shift > 0) {
+ int v = (addr >>> shift) | 0x80;
+
+ patch.write(v);
+ shift -= 7;
+ }
+ patch.write((addr & 0x7f));
+ }
+
+ private int encLength(int addr) {
+ return addr != 0 ? (32 + 6 - Integer.numberOfLeadingZeros(addr)) / 7 : 1;
+ }
+
+ /**
+ * Updates the recent address table(s).
+ *
+ * @param addr
+ */
+ private void updateAddr(int addr) {
+ recentAddr[recentNext++] = addr;
+ recentNext &= recentAddr.length - 1;
+ matchAddr[matchNext++] = addr;
+ matchNext &= matchAddr.length - 1;
+ }
+
+ /**
+ * Determines the most compact encoding for an address and writes it to the delta.
+ *
+ * @param addr
+ */
+ private void encodeAddr(int addr) {
+ // Check for perfect match
+ for (int i = 0; i < matchAddr.length; i++)
+ if (matchAddr[i] == addr) {
+ patch.write(i);
+ updateAddr(addr);
+ return;
+ }
+
+ // Check for near delta
+ int best = addr;
+ int d = Integer.MAX_VALUE;
+ int besti = 0;
+ for (int i = 0; i < recentAddr.length; i++) {
+ int r = recentAddr[i];
+ int rd = Math.abs(r - addr);
+ if (rd < d) {
+ d = rd;
+ best = r;
+ besti = i;
+ }
+ }
+
+ // shouldn't this be +1 ? it's smaller without it
+ if (encLength(d) < encLength(addr | 0x3fff)) {
+ // a delta reference is smaller
+ int sign = (addr - best) < 0 ? 0x20 : 0;
+
+ patch.write(0x40 | sign | besti);
+ encodeInt(d);
+ } else {
+ encodeShortInt(addr);
+ }
+
+ updateAddr(addr);
+ }
+
+ /**
+ * Flushes any pending operation.
+ */
+ private void flush() {
+ // 1NNNNNNN
+ // 0 ... 99 copy smallest ... 99+smallest
+ // 100 ... 123 add 1 ... 24
+ // 124 copy + length (+100+smallest)
+ // 125 add + length (+24+1)
+ // 126 run + length (+3) + byte
+ // 127 ext command
+ if (last == OP_COPY) {
+ if (lastLen < OP_SINGLE_SPLIT + smallest) {
+ patch.write(0x80 | (lastLen - smallest));
+ if (dump)
+ System.out.printf("%02x %08x: COPY %d @ $%08x\n", 0x80 | (lastLen - smallest), here, lastLen, lastAddr);
+ } else {
+ patch.write(0x80 | OP_COPY);
+ encodeInt(lastLen - smallest - OP_SINGLE_SPLIT);
+ if (dump)
+ System.out.printf("%02x %08x: COPY %d @ $%08x\n", 0x80 | OP_COPY, here, lastLen, lastAddr);
+ }
+ encodeAddr(lastAddr);
+ here += lastLen;
+ } else if (last == OP_ADD) {
+ if ((lastLen + OP_SINGLE_SPLIT - 1) < OP_SINGLE_LIMIT) {
+ patch.write(0x80 | (lastLen + OP_SINGLE_SPLIT - 1));
+ if (dump)
+ System.out.printf("%02x %08x: ADD %d\n", 0x80 | (lastLen + OP_SINGLE_SPLIT - 1), here, lastLen);
+ } else {
+ patch.write(0x80 | OP_ADD);
+ encodeInt(lastLen - (OP_SINGLE_LIMIT - OP_SINGLE_SPLIT) - 1);
+ if (dump)
+ System.out.printf("%02x %08x: ADD %d\n", 0x80 | OP_ADD, here, lastLen);
+ }
+ patch.write(lastData, lastOff, lastLen);
+ here += lastLen;
+ }
+ last = -1;
+ }
+
+ public void copy(int addr, int len) {
+ if (len < smallest)
+ throw new IndexOutOfBoundsException("Copy length too small");
+
+ if (last == OP_ADD && lastLen < 1 + 8 && len < smallest + 8) {
+ // 00AAACCC
+ if (dump)
+ System.out.printf("%02x %08x: ADD %d COPY %d @ $%08x\n",
+ ((lastLen - 1) << 3) | (len - smallest),
+ here,
+ lastLen,
+ len, addr);
+
+ patch.write(((lastLen - 1) << 3) | (len - smallest));
+ patch.write(lastData, lastOff, lastLen);
+ encodeAddr(addr);
+
+ here += lastLen + len;
+ last = -1;
+ } else if (last == OP_COPY && lastLen < smallest + 8 && len < smallest + 8) {
+ // 01cccCCC
+ patch.write(((lastLen - smallest) << 3) | (len - smallest) | 0x40);
+ encodeAddr(lastAddr);
+ encodeAddr(addr);
+
+ if (dump)
+ System.out.printf("%02x %08x: COPY %d @ $%08x COPY %d @ $%08x\n",
+ ((lastLen - smallest) << 3) | (len - smallest) | 0x40,
+ here,
+ lastLen, lastAddr, len, addr);
+ here += lastLen + len;
+ last = -1;
+ } else {
+ flush();
+ last = OP_COPY;
+ lastLen = len;
+ lastAddr = addr;
+ }
+ }
+
+ public void add(byte[] data, int off, int len) {
+ flush();
+
+ /*
+ * Let someone else handle this next call.
+ */
+ last = OP_ADD;
+ lastData = data;
+ lastOff = off;
+ lastLen = len;
+ }
+
+ public void run(byte b, int len) {
+ flush();
+
+ /*
+ * Runs are always written alone.
+ */
+ patch.write(0x80 | OP_RUN);
+ encodeInt(len - 3);
+ patch.write(b);
+
+ if (dump)
+ System.out.printf("%02x %08x: RUN $%02x %d\n",
+ 0x80 | OP_RUN,
+ here,
+ b & 0xff,
+ len);
+
+ here += len;
+ }
+
+ public byte[] toPatch() {
+ flush();
+
+ if (here != targetSize)
+ throw new RuntimeException("Insufficiant data"); // FIXME: better exception
+
+ return patch.toByteArray();
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+/**
+ * Defines constants used in the DEZ1 format.
+ * <p>
+ * <h3>Header</h3>
+ * <pre>
+ * magic: 'D' 'E' 'Z' '1'
+ * flags: one byte
+ * 00000001 Includes 'smallest' value setting
+ * [smallest: one integer] Indicates the smallest value in any copy. The default is 4.
+ * source size: one integer
+ * target size: one integer
+ * instructions follow directly
+ * ?? no epilogue defined ??
+ * </pre>
+ * <h3>Instruction stream</h3>
+ * <pre>
+ * Dual commands:
+ *
+ * 00lllccc dddddddd* aaaaaaaa* - add 1-8 then copy (0-7)+smallest
+ * 01cccCCC aaaaaaaa* aaaaaaaa* - copy (0-7)+smallest then copy (0-7)+smallest
+ *
+ * Single commands:
+ *
+ * 1nnnnnnn
+ *
+ * n is interpreted as a number of ranges, inclusive:
+ * 000 ... 099 aaaaaaaa* - copy (0-99)+smallest
+ * 100 ... 123 dddddddd* - add 1-24
+ * 124 Ciiiiiii* aaaaaaaa* - copy i + 100 + smallest
+ * 125 Ciiiiiii* dddddddd* - add i+24+1
+ * 126 Ciiiiiii* dddddddd - run length of i+3
+ * 127 - reserved
+ * </pre>
+ * <p>
+ * Integers are encoded as a compacted big-endian sequence
+ * with 7 bits per byte. Leading zero septets are discarded.
+ * The MSB of each byte is a continue bit which indicates
+ * another 7 bits are to be read.
+ * <p>
+ * <h3>Addresses</h3>
+ * <p>
+ * All addresses (aaaaaaaa*) above are encoded using a rolling lookup table.
+ * The first byte of each address indicates whether a lookup-table specific
+ * address is used or an absolute address.
+ * <pre>
+ * 00nnnnnn - use address 'n' exactly.
+ * 01Smmmmm iiiiiiii* - use address 'm' plus or minus 'i'. S={ 0: plus, 1: minus }
+ * 1iiiiiii Ciiiiiii* - use address 'i' absolute. Always at least 2 bytes.
+ * </pre>
+ * <p>
+ * Given that 7-bit absolute addresses will rarely occur in typical data all
+ * absolute addresses use at least 2x bytes. This allows 2+ byte values to be encoded
+ * as compactly as they would otherwise be and leaves the lower 128 values for other
+ * encoding options.
+ * <p>
+ * The address table is 64 elements long but the relative instruction can only
+ * reference the most recent 32 elements. It is updated each time an address is
+ * encoded or decoded in a simple rolling manner.
+ * <p>
+ * Conceptually it can be broken into two separate parts:
+ * <pre>
+ * matchAddr[(matchNext++) & 63] = addr;
+ * recentAddr[(recentNext++) & 31] = addr;
+ * </pre>
+ * First the encoder searches the match table; if it finds a match the address
+ * is encoded implicitly in the opcode via an index.
+ * <p>
+ * Next the encoder finds the nearest match from the recent table as absolute
+ * distance. The encoder may encode the address as a relative offset from
+ * a member of the table if the total is smaller than encoding the address absolutely.
+ * <p>
+ */
+public interface DEZFormat {
+
+ /**
+ * File magic 'DEZ1'.
+ */
+ public static final byte[] MAGIC = {'D', 'E', 'Z', '1'};
+
+ /**
+ * Header flags indicating the smallest copy size is present in the header.
+ */
+ public static final int DEZ_SMALLEST = 0x01;
+
+ /**
+ * COPY select bit in dual opcode.
+ */
+ public static final int OP_DUAL_COPY = 0x40;
+ /**
+ * Single-operation opcode selector bit.
+ */
+ public static final int OP_SINGLE = 0x80;
+ /**
+ * The split-point between copy and add for immediate length single operations.
+ * <p>
+ * A code below this value is a COPY, otherwise it is an ADD.
+ */
+ public static final int OP_SINGLE_SPLIT = 100;
+ /**
+ * The limit of immediate length single operations.
+ * <p>
+ * This is the first non-immediate opcode (i.e. op_copy)
+ */
+ public static final int OP_SINGLE_LIMIT = 124;
+ /**
+ * Extended COPY opcode.
+ */
+ public static final int OP_COPY = 124;
+ /**
+ * Extended ADD opcode.
+ */
+ public static final int OP_ADD = 125;
+ /**
+ * RUN opcode.
+ */
+ public static final int OP_RUN = 126;
+ /**
+ * Extended command. Reserved.
+ */
+ public static final int OP_EXT = 127;
+
+ /**
+ * Indicates whether this is an absolute or indirect address.
+ * <p>
+ * If this bit it set this represents the first byte of a
+ * multi-byte encoded integer whose value is the absolute address reference.
+ * <p>
+ * If this bit is clear then the address is an indirect address.
+ */
+ public static final int ADDR_ABSOLUTE = 0x80;
+ /**
+ * Indicates whether the address is relative or exact indirect.
+ * <p>
+ * If set then the lower 5 bits select the source address slot and the
+ * ADDR_SIGN together with the following integer indicate the offset.
+ * <p>
+ * If not set this is an exact indirect address and the lower 6 bits select the source address slot.
+ */
+ public static final int ADDR_RELATIVE = 0x40;
+ /**
+ * The sign of the offset for a relative indirect address.
+ * <p>
+ * If set the offset should be negated.
+ */
+ public static final int ADDR_SIGN = 0x20;
+
+ /**
+ * Creates a DEZ-1 format patch from byte sources.
+ *
+ * @param source
+ * @param target
+ * @return
+ */
+ public static byte[] encode(byte[] source, byte[] target) {
+ return ByteDeltaEncoder.toDiff(new ByteMatcherHash(6, 4, source, 1, target), new DEZEncoder());
+ }
+
+ /**
+ * Applies a DEZ-1 patch.
+ *
+ * @param source
+ * @param patch
+ * @return
+ */
+ public static byte[] decode(byte[] source, byte[] patch) {
+ return new au.notzed.dez.DEZDecoder(source, patch).decode();
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2019 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+module notzed.dez {
+ exports au.notzed.dez;
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ */
+public class ByteMatcherHashTest {
+
+ public ByteMatcherHashTest() {
+ }
+
+ @BeforeClass
+ public static void setUpClass() {
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ }
+
+ @Before
+ public void setUp() {
+ }
+
+ @After
+ public void tearDown() {
+ }
+
+ @Test
+ public void testGetSource() {
+ System.out.println("getSource");
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ ByteMatcherHash instance = new ByteMatcherHash(4, 4, source, 1, target);
+ byte[] expResult = source;
+ byte[] result = instance.getSource();
+ assertArrayEquals(expResult, result);
+ }
+
+ @Test
+ public void testGetTarget() {
+ System.out.println("getTarget");
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ ByteMatcherHash instance = new ByteMatcherHash(4, 4, source, 1, target);
+ byte[] expResult = target;
+ byte[] result = instance.getTarget();
+ assertArrayEquals(expResult, result);
+ }
+
+ @Test
+ public void testEmpty() {
+ System.out.println("testEmpty");
+
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(bm.nextMatch(), ByteMatcherHash.EOF);
+ }
+
+ @Test
+ public void testRun() {
+ System.out.println("testRun");
+
+ byte[] source = new byte[0];
+ byte[] target = "aaa".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(2, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.RUN, bm.nextMatch());
+ assertEquals(3, bm.getLength());
+ assertEquals('a', bm.getRunByte());
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ @Test
+ public void testRunEnd() {
+ System.out.println("testRunEnd");
+
+ byte[] source = new byte[0];
+ byte[] target = "abcdaaa".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(2, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.RUN, bm.nextMatch());
+ assertEquals(3, bm.getLength());
+ assertEquals('a', bm.getRunByte());
+ assertEquals(4, bm.getTargetOffset());
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ @Test
+ public void testCopy() {
+ System.out.println("testCopy");
+
+ byte[] source = "abcdefg".getBytes();
+ byte[] target = "abcdefg".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(source.length, bm.getLength());
+ assertEquals(0, bm.getMatchOffset());
+ assertEquals(source, bm.getBlockArray(bm.getMatchOffset()));
+ assertEquals(0, bm.getBlockOffset(bm.getMatchOffset()));
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ @Test
+ public void testCopyEnd() {
+ System.out.println("testCopyEnd");
+
+ byte[] source = "xxxxabcd".getBytes();
+ byte[] target = "abcdabcd".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(4, bm.getLength());
+ assertEquals(4, bm.getMatchOffset());
+ assertEquals(source, bm.getBlockArray(bm.getMatchOffset()));
+ assertEquals(4, bm.getBlockOffset(bm.getMatchOffset()));
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(4, bm.getLength());
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ @Test
+ public void testCopyTarget() {
+ System.out.println("testCopyTarget");
+
+ byte[] source = "wxyz".getBytes();
+ byte[] target = "abcdabcd".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(4, bm.getMatchOffset());
+ assertEquals(4, bm.getTargetOffset());
+ assertEquals(target, bm.getBlockArray(bm.getMatchOffset()));
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ @Test
+ public void testNomatch() {
+ System.out.println("testNomatch");
+
+ byte[] source = "abcdefgh".getBytes();
+ byte[] target = "ijklmnop".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ assertEquals(0, bm.getMatchOffset());
+ }
+
+ @Test
+ public void testCopy2() {
+ System.out.println("testCopy2");
+
+ byte[] source = "abcdefgh".getBytes();
+ byte[] target = "abcdabcd".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(4, bm.getLength());
+ assertEquals(0, bm.getMatchOffset());
+ assertEquals(0, bm.getTargetOffset());
+ assertEquals(source, bm.getBlockArray(bm.getMatchOffset()));
+ assertEquals(0, bm.getBlockOffset(bm.getMatchOffset()));
+
+ assertEquals(ByteMatcherHash.COPY, bm.nextMatch());
+ assertEquals(4, bm.getLength());
+ assertEquals(4, bm.getTargetOffset());
+
+ assertEquals(ByteMatcherHash.EOF, bm.nextMatch());
+ }
+
+ static class Expected {
+
+ int state;
+ int length;
+ int targetOffset;
+ int matchOffset; // or match byte
+
+ public Expected(int state, int length, int targetOffset, int matchOffset) {
+ this.state = state;
+ this.length = length;
+ this.targetOffset = targetOffset;
+ this.matchOffset = matchOffset;
+ }
+
+ void check(ByteMatcherHash bm, int state) {
+ }
+
+ static void check(Expected[] list, ByteMatcherHash bm) {
+ for (int i = 0; i < list.length; i++) {
+ Expected e = list[i];
+ int state = bm.nextMatch();
+ assertEquals(e.state, state);
+ assertEquals(e.length, bm.getLength());
+ assertEquals(e.targetOffset, bm.getTargetOffset());
+ if (state == ByteMatcher.COPY) {
+ assertEquals(e.matchOffset, bm.getMatchOffset());
+ } else if (state == ByteMatcher.RUN) {
+ assertEquals(e.matchOffset, bm.getRunByte() & 0xff);
+ }
+ }
+
+ assertEquals(bm.nextMatch(), ByteMatcher.EOF);
+ }
+
+ static void make(String name, ByteMatcherHash bm) {
+ int s;
+
+ System.out.printf("static Expected[] %s = {\n", name);
+ while ((s = bm.nextMatch()) != bm.EOF) {
+ switch (s) {
+ case ByteMatcherHash.COPY:
+ System.out.printf("new Expected(ByteMatcher.COPY, %d, %d, %d),\n",
+ bm.getLength(),
+ bm.getTargetOffset(),
+ bm.getMatchOffset());
+ break;
+ case ByteMatcherHash.RUN:
+ System.out.printf("new Expected(ByteMatcher.RUN, %d, %d, 0x%02x),\n",
+ bm.getLength(),
+ bm.getTargetOffset(),
+ bm.getRunByte() & 0xff);
+ break;
+ }
+ }
+ System.out.printf("};\n");
+ }
+
+ }
+ static Expected[] testSequence = {
+ new Expected(ByteMatcher.COPY, 5, 0, 39),
+ new Expected(ByteMatcher.COPY, 7, 17, 57),
+ new Expected(ByteMatcher.COPY, 4, 24, 0),
+ new Expected(ByteMatcher.COPY, 5, 29, 4)
+ };
+
+ @Test
+ public void testSequence() {
+ System.out.println("testSequence");
+
+ byte[] source = "the rains in spain falls mainly on the plains.".getBytes();
+ byte[] target = "plain bread melts melts the brains.".getBytes();
+ ByteMatcherHash bm = new ByteMatcherHash(4, 4, source, 1, target);
+
+ //Expected.make("testSequence", bm);
+ Expected.check(testSequence, bm);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ * There could be plenty more tests here for all address and instruction variations.
+ */
+public class DEZEncoderTest {
+
+ public DEZEncoderTest() {
+ }
+
+ @BeforeClass
+ public static void setUpClass() {
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ }
+
+ @Before
+ public void setUp() {
+ }
+
+ @After
+ public void tearDown() {
+ }
+
+ @Test
+ public void testCopy() {
+ System.out.println("copy");
+ int addr = 0;
+ int len = 5;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(len, len);
+ instance.copy(addr, len);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ (byte) len,
+ (byte) len,
+ (byte) (128 + len - 4), 0
+ });
+ }
+
+ @Test
+ public void testAdd() {
+ System.out.println("add");
+ byte[] data = {1, 2, 3, 4};
+ int off = 0;
+ int len = data.length;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(0, len);
+ instance.add(data, off, len);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ (byte) len,
+ (byte) (128 + 100 + len - 1), 1, 2, 3, 4
+ });
+ }
+
+ @Test
+ public void testRun() {
+ System.out.println("run");
+ byte b = 65;
+ int len = 5;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(0, len);
+ instance.run(b, len);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ (byte) len,
+ (byte) (126 | 0x80),
+ (byte) (len - 3),
+ b
+ });
+ }
+
+ @Test
+ public void testRun1Byte() {
+ System.out.println("run 1 byte");
+ byte b = 65;
+ int len = 127 + 3;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(0, len);
+ instance.run(b, len);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ (byte) ((len >> 7) | 0x80),
+ (byte) (len & 127),
+ (byte) (126 | 0x80),
+ (byte) (len - 3),
+ b
+ });
+ }
+
+ @Test
+ public void testRun2Byte() {
+ System.out.println("run 2 byte");
+ byte b = 65;
+ int len = 127 + 3 + 1;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(0, len);
+ instance.run(b, len);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ (byte) ((len >> 7) | 0x80),
+ (byte) (len & 127),
+ (byte) (126 | 0x80),
+ (byte) (((len - 3) >> 7) | 0x80),
+ (byte) ((len - 3) & 0x7f),
+ b
+ });
+ }
+
+ @Test
+ public void testAddAdd() {
+ System.out.println("add add");
+ byte[] data = {1, 2, 3, 4, 5, 6, 7, 8};
+ int len = data.length;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(0, len);
+ instance.add(data, 0, 5);
+ instance.add(data, 5, 3);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ (byte) len,
+ (byte) (128 + 100 + 5 - 1), 1, 2, 3, 4, 5,
+ (byte) (128 + 100 + 3 - 1), 6, 7, 8
+ });
+ }
+
+ @Test
+ public void testCopyCopyShort() {
+ System.out.println("copy copy short");
+ int len = 20;
+ DEZEncoder instance = new DEZEncoder();
+ int smallest = 4;
+
+ instance.init(16, len);
+ instance.copy(0, 10);
+ instance.copy(0, 10);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 16,
+ (byte) len,
+ (byte) ((10 - smallest) << 3 | (10 - smallest) | 0x40),
+ 0, 0
+ }, patch);
+ }
+
+ @Test
+ public void testCopyCopyShortSmallest() {
+ System.out.println("copy copy short smallest!=4");
+ int len = 20;
+ int smallest = 7;
+ DEZEncoder instance = new DEZEncoder(smallest);
+
+ instance.init(16, len);
+ instance.copy(0, 10);
+ instance.copy(0, 10);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ DEZEncoder.DEZ_SMALLEST,
+ (byte) smallest,
+ 16,
+ (byte) len,
+ (byte) ((10 - smallest) << 3 | (10 - smallest) | 0x40),
+ 0, 0
+ }, patch);
+ }
+
+ private void dump(byte[] patch) {
+ for (int i = 0; i < patch.length; i++)
+ System.out.printf("%2d: %02x\n", i, patch[i] & 0xff);
+ }
+
+ @Test
+ public void testCopyAddrMinus() {
+ System.out.println("copy addr -");
+ int len = 20;
+ int smallest = 4;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(16, len);
+ instance.copy(10, 10);
+ instance.copy(8, 10);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 16,
+ (byte) len,
+ (byte) (((10 - smallest) << 3) | (10 - smallest) | 0x40),
+ 0x40, 10,
+ // - 2
+ 0x60, 2
+ }, patch);
+ }
+
+ @Test
+ public void testCopyAddrPlus() {
+ System.out.println("copy addr +");
+ int len = 20;
+ int smallest = 4;
+ DEZEncoder instance = new DEZEncoder();
+
+ instance.init(16, len);
+ instance.copy(8, 10);
+ instance.copy(10, 10);
+
+ byte[] patch = instance.toPatch();
+
+ assertArrayEquals(new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 16,
+ (byte) len,
+ (byte) (((10 - smallest) << 3) | (10 - smallest) | 0x40),
+ 0x40, 8,
+ // + 2
+ 0x40, 2
+ }, patch);
+ }
+
+ @Test
+ public void testFormatEmpty() {
+ System.out.println("fmt empty");
+
+ DEZEncoder instance = new DEZEncoder();
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ instance.init(source.length, target.length);
+
+ byte[] patch = instance.toPatch();
+
+ assertEquals(7, patch.length);
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ 0});
+ }
+
+ @Test
+ public void testFormatSmallest() {
+ System.out.println("smallest non-default");
+
+ DEZEncoder instance = new DEZEncoder(6);
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ instance.init(source.length, target.length);
+
+ byte[] patch = instance.toPatch();
+
+ assertEquals(8, patch.length);
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ DEZEncoder.DEZ_SMALLEST,
+ 6,
+ 0,
+ 0});
+ }
+
+ @Test
+ public void testFormatSmallestDefault() {
+ System.out.println("smallest default=4");
+
+ DEZEncoder instance = new DEZEncoder(4);
+ byte[] source = new byte[0];
+ byte[] target = new byte[0];
+ instance.init(source.length, target.length);
+
+ byte[] patch = instance.toPatch();
+
+ assertEquals(7, patch.length);
+ assertArrayEquals(patch, new byte[]{
+ DEZEncoder.MAGIC[0], DEZEncoder.MAGIC[1], DEZEncoder.MAGIC[2], DEZEncoder.MAGIC[3],
+ 0,
+ 0,
+ 0});
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2015 Michael Zucchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package au.notzed.dez;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ */
+public class DEZIT {
+
+ public DEZIT() {
+ }
+
+ @BeforeClass
+ public static void setUpClass() {
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ }
+
+ @Before
+ public void setUp() {
+ }
+
+ @After
+ public void tearDown() {
+ }
+
+ @Test
+ public void testSmallest() throws Exception {
+ System.out.println("decode/encode smallest changing");
+
+ byte[] source = "the rains in Spain fall mainly on the plains".getBytes();
+ byte[] target = "plain breads in Spain aids your dames brains".getBytes();
+
+ for (int smallest = 4; smallest <= 16; smallest++) {
+ DEZEncoder de = new DEZEncoder(smallest);
+ ByteMatcherHash matcher = new ByteMatcherHash(4, smallest, source, 1, target);
+ byte[] patch = ByteDeltaEncoder.toDiff(matcher, de);
+ DEZDecoder dd = new DEZDecoder(source, patch);
+ byte[] result = dd.decode();
+
+ assertArrayEquals(result, target);
+ }
+ }
+
+ @Test
+ public void testEmptySource() throws Exception {
+ System.out.println("empty source");
+
+ byte[] source = "".getBytes();
+ byte[] target = "plain breads in Spain aids your dames brains".getBytes();
+
+ for (int smallest = 4; smallest <= 16; smallest++) {
+ DEZEncoder de = new DEZEncoder(smallest);
+ ByteMatcherHash matcher = new ByteMatcherHash(4, smallest, source, 1, target);
+ byte[] patch = ByteDeltaEncoder.toDiff(matcher, de);
+ DEZDecoder dd = new DEZDecoder(source, patch);
+ byte[] result = dd.decode();
+
+ assertArrayEquals(result, target);
+ }
+ }
+
+ @Test
+ public void testEmptyTarget() throws Exception {
+ System.out.println("empty target");
+
+ byte[] source = "the rains in Spain fall mainly on the plains".getBytes();
+ byte[] target = "".getBytes();
+
+ for (int smallest = 4; smallest <= 16; smallest++) {
+ DEZEncoder de = new DEZEncoder(smallest);
+ ByteMatcherHash matcher = new ByteMatcherHash(4, smallest, source, 1, target);
+ byte[] patch = ByteDeltaEncoder.toDiff(matcher, de);
+ DEZDecoder dd = new DEZDecoder(source, patch);
+ byte[] result = dd.decode();
+
+ assertArrayEquals(result, target);
+ }
+ }
+
+ @Test
+ public void testRuns() throws Exception {
+ System.out.println("runs");
+
+ byte[] source = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".getBytes();
+ byte[] target = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".getBytes();
+
+ for (int smallest = 4; smallest <= 16; smallest++) {
+ DEZEncoder de = new DEZEncoder(smallest);
+ ByteMatcherHash matcher = new ByteMatcherHash(4, smallest, source, 1, target);
+ byte[] patch = ByteDeltaEncoder.toDiff(matcher, de);
+ DEZDecoder dd = new DEZDecoder(source, patch);
+ byte[] result = dd.decode();
+
+ assertArrayEquals(result, target);
+ }
+ }
+
+}