diff options
Diffstat (limited to 'gfx/graphite2')
84 files changed, 19831 insertions, 0 deletions
diff --git a/gfx/graphite2/COPYING b/gfx/graphite2/COPYING new file mode 100644 index 0000000000..f6630af533 --- /dev/null +++ b/gfx/graphite2/COPYING @@ -0,0 +1,26 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + + Alternatively, you may use this library under the terms of the Mozilla + Public License (http://mozilla.org/MPL) or under the GNU General Public + License, as published by the Free Sofware Foundation; either version + 2 of the license or (at your option) any later version. +*/ diff --git a/gfx/graphite2/ChangeLog b/gfx/graphite2/ChangeLog new file mode 100644 index 0000000000..e36110e1c1 --- /dev/null +++ b/gfx/graphite2/ChangeLog @@ -0,0 +1,238 @@ +1.3.14 + . Bug fixes + . Allow features to be hidden (for aliases) + . Move to python3 + . Rename doc files from .txt to .asc + +1.3.13 + . Resolve minor spacing issue in rtl non-overlap kerning + . python3 for graphite.py + . Better fuzzing + . Better building on windows + +1.3.12 + . Graphite no longer does dumb rendering for fonts with no smarts + . Segment caching code removed. Anything attempting to use the segment cache gets given a regular face instead + . Add libfuzzer support + . Builds now require C++11 + . Improvements to Windows 64 bit builds + . Support different versions of python including 32 bit and python 3 + . Various minor bug fixes + +1.3.11 + . Fixes due to security review + . Minor collision avoidance fixes + . Fix LZ4 decompressor against high compression + +1.3.10 + . Address floating point build parameters to give consistent positioning results across platforms + . Various bug fixes + +1.3.9 + . Add Collision COLL_ISSPACE to allow for visible spaces in collision avoidance + . Add segment and pass direction information to tracing output + . Bug fix rule length testing in 32-bit + . Increase slanted margin distances for collision avoidance + . Change kerning algorithm to simple outline expansion. Seems to make no visible difference. + . Add trace2svg to test tools + +1.3.8 + . Various bug fixes arising from fuzzing + . Fix regression that stopped piglatin from working + . Make collision avoidance kerning give more regular results + . Minor modification to clustering algorithm to handle variable width chars + +1.3.7 + . Bug fixes + . Start to deprecate SegCache. This will be going away in a later release. + +1.3.6 + . Bug fixes + +1.3.5 + . Bug fixes + . Security bug fix + . Fix ARM misalignment problem + . Track latest cmake + +1.3.4 + . Transition from Mercurial to Git + . Bug fixes + . Fix Collision Kerning ignoring some diacritics + . Handle pass bits 16-31 to speed up fonts with > 16 passes + . Various minor fuzz bug fixes + . Make Coverity happy + . Add GR_FALLTHROUGH macro for clang c++11 + +1.3.3 + . Slight speed up in Collision Avoidance + . Remove dead bidi code + . Bug fixes + . Between pass bidi reorderings and at the end + . Decompressor fuzz bugs + . Other fuzz bugs + +1.3.2 + . Remove full bidi. All segments are assumed to be single directioned. + . Bug fixes: + . Decompressor corner cases + . Various fuzz bugs + +1.3.1 + . Deprecation warning: Full bidi support is about to be deprecated. Make contact + if this impacts you. + . Change compression block format slightly to conform to LZ4 + . Bug fixes: + . Handle mono direction text with diacritics consistently. Fonts + now see the direction they expect consistently and bidi now + gives expected results. + . Fixed lots of fuzz bugs + . Coverity cleanups + . Build now works for clang and/or asan and/or afl etc. + +1.3.0 + . Add collision avoidance + . Shift Collider + . Kern Collider + . Octabox outlines and subboxes + . Add compressed Silf and Glat table support + . Bug fixes: + . Stop loops forming in the child, sibling tree + . Handle bidi mirroring correctly if no bidi occurring + +1.2.4 + . Face failure now has error code reporting via debug logging + . can now call gr_start_logging(NULL, fname) + . gr2fonttest --alltrace added + . Format 14 table support + . Not done. To be handled entirely in the compiler + . Bidi support for Unicode 6.3 Isolating direction controls + . Fonts no longer require a glyf/loca table. In such cases the bounding box is always 0. + . Clang ASAN build support added for testing. + . Handle out of memory sanely. + . Documentation improvements + . Bug fixes: + . Enforce fonts having to store glyph attributes by monotonically increasing attribute number + . zeropadding was not getting called on feature tags + . automatic associations for unassociated characters + . use direct engine on Mac + . various extreme case reading 1 past the end errors fixed + . remove tabs from sources so that it becomes readable again + +1.2.3 + . Bug fixes only: + . fix byte swapping when testing cmap subtable lengths + . work around armel compilation problems with conditional operators + . fix pseudoglyph support for advance and bbox + +1.2.2 + . Add support for passKeySlot (makes Charis 2x faster) up to 32 passes + . Add telemetry output to json if enabled in build GRAPHITE2_TELEMETRY + . Shrink font memory footprint particularly in the fsm + . Add -S to comparerenderer + . Bug fixes: + . Fix shift.x being reversed for rtl text + . Fix faulty fallback justification + . Fix bad cmap handling + . Support compiling on old Solaris where bidi attributes clash with register names + . Follow the crowd in using Windows.h + +1.2.1 + . Bug fixes: + . Allow glyph reattachment + . Allow signed glyph attributes + . Various build problems with MacOS, old gcc versions, etc. + . Various overrun read errors fixed + +1.2.0 + . API Changes: + . Added Windows friendly gr_start_logging and gr_stop_logging, now per face + . Added gr_make_face_with_ops, gr_make_face_with_seg_cache_and_ops + . Added gr_make_font_with_ops + . Added gr_face_is_char_supported + . Added gr_face_info to give info to apps about face capabilities + . Deprecated gr_make_face, gr_make_face_with_seg_cache, gr_make_font_with_advance_fn + . Deprecated graphite_start_logging and graphite_stop_logging + . These functions are stubbed now and do nothing, but do compile and link. + . Bump API version to 3 + . Add C# wrapper to contrib + . Handle justification information in a font and do something useful with it + . Builds clang clean (has done for a while) + . Bug fixes + . Windows build and bug fixes + . Add extra information to json debug output + . Added windows build documentation + . Added freetype sample code and test + +1.1.3 + . Default build has GRAPHITE2_COMPARE_RENDERER to OFF to reduce dependencies + . Builds on Mac with clang + . Debug output improvements + . Tidy up perl wrappers + . Fuzz tester improvements + . Various bug fixes for bad font handling + +1.1.2 + . Support feature ids < 4 chars when space padded for inclusion in FF 14. + . More fuzztesting and removal of causes of valgrind bad reads and sigabrts + . Remove contrib/android into its own repo (http://hg.palaso.org/grandroid) + . Update comparerenderer to latest harfbuzzng api + +1.1.1 + . Missing Log.h included + . perl wrappers updated + +1.1.0 + . Refactored debug output to use json + . Renamed VM_MACHINE_TYPE to GRAPHITE2_VM_TYPE + . Renamed DISABLE_SEGCACHE to GRAPHITE2_NSEGCACE + . Renamed DISBALE_FILE_FACE to GRAPHITE2_NFILEFACE + . Renamed ENABLE_COMPARE_RENDERER to GRAPHTIE2_COMPARE_RENDERER + . Renamed DOXYGEN_CONFIG to GRAPHITE2_DOXYGEN_CONFIG + . Renamed GR2_CUSTOM_HEADER to GRAPHITE2_CUSTOM_HEADER + . Renamed GR2_EXPORTING to GRAPHITE2_EXPORTING + . Added GRAPHITE2_STATIC for static only builds + . Added GRAPHITE2_NTRACING to compile out tracing code + . Documented GRAPHITE2_{EXPORTING,STATIC,NTRACING} in hacking.txt + . Bump libtool version to 2.1.0 + . dumb font rendering works + . slot user attributes are now signed rather than unsigned + . add support for long class maps + . Rename perl library to avoid nameclash on Windows + . Various robustness fixes + . Moved internal .h files into src/inc + . Parallelise fuzztest + . General build improvements, particularly on Windows + +1.0.3 + . Fix UTF16 surrogate support + . script and lang tags may be space padded or null padded + . Remove need for WORDS_BIGENDIAN, do it all automatically + . Remove all #include <new>. Use CLASS_NEW_DELETE instead. + . Fix comparerenderer to work with current hbng + . Add valgrind to fuzztest to ensure good memory use at all times + . Fix new fuzztest exposed bugs. + . Fix bugs exposed by Mozilla security review + . Add continuous integration build on Windows support + +1.0.2 + . Fix Windows build + . Comparerenderer uses hbng enforcing ot rendering + . Add Bidi .hasChar support and refactor mirroring code + . Make cmake default Release rather than debug + . Don't compile in a boat load of TtfUtil that isn't used, saving 15% of binary + . Chase the FSF around its latest office moves + . WORDS_BIGENDIAN is set at the top so tests now pass on ppc, etc. + . More words in the manual + +1.0.1 + . Release is the default build in cmake now. + . Refactor cmake build to not rebuild things so much. + . Include a missing file + . Remove -nostdlibs, making gcc happy everywhere + . Update comparerenderer to latest hbng interface + . Add changelog + +1.0.0 + . First major release of perfect code! + diff --git a/gfx/graphite2/LICENSE b/gfx/graphite2/LICENSE new file mode 100644 index 0000000000..2d2d780e60 --- /dev/null +++ b/gfx/graphite2/LICENSE @@ -0,0 +1,510 @@ + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations +below. + + When we speak of free software, we are referring to freedom of use, +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 this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it +becomes a de-facto standard. To achieve this, non-free programs must +be allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control +compilation and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at least + three years, to give the same user the materials specified in + Subsection 6a, above, for a charge no more than the cost of + performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +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 +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply, and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License +may add an explicit geographical distribution limitation excluding those +countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser 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 Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "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 +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY 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 +LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms +of the ordinary General Public License). + + To apply these terms, attach the following notices to the library. +It is safest to attach them to the start of each source file to most +effectively convey 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 library's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or +your school, if any, to sign a "copyright disclaimer" for the library, +if necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James + Random Hacker. + + <signature of Ty Coon>, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/gfx/graphite2/README.md b/gfx/graphite2/README.md new file mode 100644 index 0000000000..277c32777b --- /dev/null +++ b/gfx/graphite2/README.md @@ -0,0 +1,38 @@ +# Graphite engine + +## Project CI status +| OS | Intel 64 bit | Intel 32 bit | Arm 32 bit | +|---------|:------------:|:------------:|:----------:| +| Linux | [](http://build.palaso.org/viewType.html?buildTypeId=bt124&guest=1) | [](http://build.palaso.org/viewType.html?buildTypeId=bt123&guest=1) | [](http://build.palaso.org/viewType.html?buildTypeId=Graphite_Linux32bitArm&guest=1) | +| Windows | [](http://build.palaso.org/viewType.html?buildTypeId=Graphite_Windows64bit&guest=1) | [](http://build.palaso.org/viewType.html?buildTypeId=bt91&guest=1)| | + +## What is Graphite? + +Graphite is a system that can be used to create “smart fonts” capable of displaying writing systems with various complex behaviors. A smart font contains not only letter shapes but also additional instructions indicating how to combine and position the letters in complex ways. + +Graphite was primarily developed to provide the flexibility needed for minority languages which often need to be written according to slightly different rules than well-known languages that use the same script. + +Examples of complex script behaviors Graphite can handle include: + +* contextual shaping +* ligatures +* reordering +* split glyphs +* bidirectionality +* stacking diacritics +* complex positioning +* shape aware kerning +* automatic diacritic collision avoidance + +See [examples of scripts with complex rendering](http://scripts.sil.org/CmplxRndExamples). + +## Graphite system overview +The Graphite system consists of: + +* A rule-based programming language [Graphite Description Language](http://scripts.sil.org/cms/scripts/page.php?site_id=projects&item_id=graphite_devFont#gdl) (GDL) that can be used to describe the behavior of a writing system +* A compiler for that language +* A rendering engine that can serve as the layout component of a text-processing application + +Graphite renders TrueType fonts that have been extended by means of compiling a GDL program. + +Further technical information is available on the [Graphite technical overview](http://scripts.sil.org/cms/scripts/page.php?site_id=projects&item_id=graphite_techAbout) page. diff --git a/gfx/graphite2/geckoextra/include/GraphiteExtra.h b/gfx/graphite2/geckoextra/include/GraphiteExtra.h new file mode 100644 index 0000000000..9352e70991 --- /dev/null +++ b/gfx/graphite2/geckoextra/include/GraphiteExtra.h @@ -0,0 +1,42 @@ +// -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +// vim: set ts=2 et sw=2 tw=80: +// This Source Code is subject to the terms of the Mozilla Public License +// version 2.0 (the "License"). You can obtain a copy of the License at +// http://mozilla.org/MPL/2.0/. + +#ifndef GraphiteExtra_h__ +#define GraphiteExtra_h__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#include "graphite2/Segment.h" + +typedef struct { + uint32_t baseChar; // in UTF16 code units, not Unicode character indices + uint32_t baseGlyph; + uint32_t nChars; // UTF16 code units + uint32_t nGlyphs; +} gr_glyph_to_char_cluster; + +typedef struct { + gr_glyph_to_char_cluster* clusters; + uint16_t* gids; + float* xLocs; + float* yLocs; + uint32_t cIndex; +} gr_glyph_to_char_association; + +gr_glyph_to_char_association* gr_get_glyph_to_char_association( + gr_segment* aSegment, uint32_t aLength, const char16_t* aText); + +void gr_free_char_association(gr_glyph_to_char_association* aData); + +#ifdef __cplusplus +} +#endif + +#endif
\ No newline at end of file diff --git a/gfx/graphite2/geckoextra/include/GraphiteStructsForRLBox.h b/gfx/graphite2/geckoextra/include/GraphiteStructsForRLBox.h new file mode 100644 index 0000000000..64fb198936 --- /dev/null +++ b/gfx/graphite2/geckoextra/include/GraphiteStructsForRLBox.h @@ -0,0 +1,70 @@ +// -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +// vim: set ts=2 et sw=2 tw=80: +// This Source Code is subject to the terms of the Mozilla Public License +// version 2.0 (the "License"). You can obtain a copy of the License at +// http://mozilla.org/MPL/2.0/. + +#ifndef GraphiteStructsForRLBox_h__ +#define GraphiteStructsForRLBox_h__ + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" +#elif defined(__GNUC__) || defined(__GNUG__) +// Can't turn off the variadic macro warning emitted from -pedantic +# pragma GCC system_header +#elif defined(_MSC_VER) +// Doesn't seem to emit the warning +#else +// Don't know the compiler... just let it go through +#endif + +// Note that the two size fields below are actually size_t in the headers +// However RLBox currently does not handle these correctly. See Bug 1722127. +// Use a workaround of unsiged int instead of size_t. +#define sandbox_fields_reflection_graphite_class_gr_font_ops(f, g, ...) \ + f(unsigned int, size, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(float (*)(const void*, unsigned short), glyph_advance_x, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(float (*)(const void*, unsigned short), glyph_advance_y, FIELD_NORMAL, ##__VA_ARGS__) g() + +#define sandbox_fields_reflection_graphite_class_gr_face_ops(f, g, ...) \ + f(unsigned int, size, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(const void* (*)(const void*, unsigned int, unsigned int*), get_table, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(void (*)(const void*, const void*), release_table, FIELD_NORMAL, ##__VA_ARGS__) g() + +#define sandbox_fields_reflection_graphite_class_gr_glyph_to_char_cluster(f, g, ...) \ + f(unsigned int, baseChar, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned int, baseGlyph, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned int, nChars, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned int, nGlyphs, FIELD_NORMAL, ##__VA_ARGS__) g() + +#define sandbox_fields_reflection_graphite_class_gr_glyph_to_char_association(f, g, ...) \ + f(gr_glyph_to_char_cluster*, clusters, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned short*, gids, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(float*, xLocs, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(float*, yLocs, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned int, cIndex, FIELD_NORMAL, ##__VA_ARGS__) g() + +#define sandbox_fields_reflection_graphite_class_gr_faceinfo(f, g, ...) \ + f(short, extra_ascent, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(short, extra_descent, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(short, upem, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(gr_faceinfo::gr_space_contextuals, space_contextuals, FIELD_NORMAL, ##__VA_ARGS__) g() \ + f(unsigned int, has_bidi_pass, FIELD_NORMAL, ##__VA_ARGS__) g() + // Remaining bitfields skipped, as bitfields are not fully supported + +#define sandbox_fields_reflection_graphite_allClasses(f, ...) \ + f(gr_font_ops, graphite, ##__VA_ARGS__) \ + f(gr_face_ops, graphite, ##__VA_ARGS__) \ + f(gr_glyph_to_char_cluster, graphite, ##__VA_ARGS__) \ + f(gr_glyph_to_char_association, graphite, ##__VA_ARGS__) \ + f(gr_faceinfo, graphite, ##__VA_ARGS__) + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#elif defined(_MSC_VER) +#else +#endif + +#endif
\ No newline at end of file diff --git a/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp b/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp new file mode 100644 index 0000000000..b5c8802b15 --- /dev/null +++ b/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "graphite2/Font.h" +#include "graphite2/Segment.h" +#include "graphite2/GraphiteExtra.h" + +#include <stdlib.h> +#include <memory> +#include <limits> + +#define CHECK(cond, str) \ + do { \ + if (!(cond)) { \ + return false; \ + } \ + } while (false) + +// High surrogates are in the range 0xD800 -- OxDBFF +#define NS_IS_HIGH_SURROGATE(u) ((uint32_t(u) & 0xFFFFFC00) == 0xD800) +// Low surrogates are in the range 0xDC00 -- 0xDFFF +#define NS_IS_LOW_SURROGATE(u) ((uint32_t(u) & 0xFFFFFC00) == 0xDC00) + +#define IS_POWER_OF_2(n) (n & (n - 1)) == 0 + +typedef gr_glyph_to_char_cluster Cluster; + +// returns whether successful +static bool LoopThrough(gr_segment* aSegment, const uint32_t aLength, + const uint32_t aGlyphCount, const char16_t* aText, + uint32_t& aCIndex, Cluster* aClusters, uint16_t* aGids, + float* aXLocs, float* aYLocs) { + // walk through the glyph slots and check which original character + // each is associated with + uint32_t gIndex = 0; // glyph slot index + for (const gr_slot* slot = gr_seg_first_slot(aSegment); slot != nullptr; + slot = gr_slot_next_in_segment(slot), gIndex++) { + CHECK(gIndex < aGlyphCount, "iterating past glyphcount"); + uint32_t before = + gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_before(slot))); + uint32_t after = gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_after(slot))); + aGids[gIndex] = gr_slot_gid(slot); + aXLocs[gIndex] = gr_slot_origin_X(slot); + aYLocs[gIndex] = gr_slot_origin_Y(slot); + + // if this glyph has a "before" character index that precedes the + // current cluster's char index, we need to merge preceding + // aClusters until it gets included + while (before < aClusters[aCIndex].baseChar && aCIndex > 0) { + aClusters[aCIndex - 1].nChars += aClusters[aCIndex].nChars; + aClusters[aCIndex - 1].nGlyphs += aClusters[aCIndex].nGlyphs; + --aCIndex; + } + + // if there's a gap between the current cluster's base character and + // this glyph's, extend the cluster to include the intervening chars + if (gr_slot_can_insert_before(slot) && aClusters[aCIndex].nChars && + before >= aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars) { + CHECK(aCIndex < aLength - 1, "aCIndex at end of word"); + Cluster& c = aClusters[aCIndex + 1]; + c.baseChar = aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars; + c.nChars = before - c.baseChar; + c.baseGlyph = gIndex; + c.nGlyphs = 0; + ++aCIndex; + } + + // increment cluster's glyph count to include current slot + CHECK(aCIndex < aLength, "aCIndex beyond word length"); + ++aClusters[aCIndex].nGlyphs; + + // bump |after| index if it falls in the middle of a surrogate pair + if (NS_IS_HIGH_SURROGATE(aText[after]) && after < aLength - 1 && + NS_IS_LOW_SURROGATE(aText[after + 1])) { + after++; + } + + // extend cluster if necessary to reach the glyph's "after" index + if (aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars < after + 1) { + aClusters[aCIndex].nChars = after + 1 - aClusters[aCIndex].baseChar; + } + } + + // Succeeded + return true; +} + +static gr_glyph_to_char_association* calloc_glyph_to_char_association( + uint32_t aGlyphCount, uint32_t aLength) { + using Type1 = gr_glyph_to_char_association; + using Type2 = gr_glyph_to_char_cluster; + using Type3 = float; + using Type4 = float; + using Type5 = uint16_t; + + // We are allocating memory in a pool. To avoid dealing with thorny alignment + // issues, we allocate from most to least aligned + static_assert( + alignof(Type1) >= alignof(Type2) && alignof(Type2) >= alignof(Type3) && + alignof(Type3) >= alignof(Type4) && alignof(Type4) >= alignof(Type5), + "Unexpected alignments of types"); + + const uint64_t size1 = sizeof(Type1) * static_cast<uint64_t>(1); + const uint64_t size2 = sizeof(Type2) * static_cast<uint64_t>(aLength); + const uint64_t size3 = sizeof(Type3) * static_cast<uint64_t>(aGlyphCount); + const uint64_t size4 = sizeof(Type4) * static_cast<uint64_t>(aGlyphCount); + const uint64_t size5 = sizeof(Type5) * static_cast<uint64_t>(aGlyphCount); + + uint64_t totalSize = size1 + size2 + size3 + size4 + size5; + + if (totalSize > std::numeric_limits<uint32_t>::max()) { + // allocation request got too large + return nullptr; + } + + char* const memoryPool = static_cast<char*>(calloc(1, totalSize)); + if (!memoryPool) { + return nullptr; + } + + char* currentPoolFront = memoryPool; + + auto data = reinterpret_cast<Type1*>(currentPoolFront); + currentPoolFront += size1; + data->clusters = reinterpret_cast<Type2*>(currentPoolFront); + currentPoolFront += size2; + data->xLocs = reinterpret_cast<Type3*>(currentPoolFront); + currentPoolFront += size3; + data->yLocs = reinterpret_cast<Type4*>(currentPoolFront); + currentPoolFront += size4; + data->gids = reinterpret_cast<Type5*>(currentPoolFront); + + return data; +} + +// returns nullptr on failure and the glyph to char association on success +gr_glyph_to_char_association* gr_get_glyph_to_char_association( + gr_segment* aSegment, uint32_t aLength, const char16_t* aText) { + uint32_t glyphCount = gr_seg_n_slots(aSegment); + + gr_glyph_to_char_association* data = + calloc_glyph_to_char_association(glyphCount, aLength); + if (!data) { + return nullptr; + } + + bool succeeded = + LoopThrough(aSegment, aLength, glyphCount, aText, data->cIndex, + data->clusters, data->gids, data->xLocs, data->yLocs); + if (!succeeded) { + gr_free_char_association(data); + return nullptr; + } + return data; +} + +void gr_free_char_association(gr_glyph_to_char_association* aData) { + free(aData); +} + +#undef CHECK +#undef NS_IS_HIGH_SURROGATE +#undef NS_IS_LOW_SURROGATE +#undef IS_POWER_OF_2 diff --git a/gfx/graphite2/include/graphite2/Font.h b/gfx/graphite2/include/graphite2/Font.h new file mode 100644 index 0000000000..fe569295a5 --- /dev/null +++ b/gfx/graphite2/include/graphite2/Font.h @@ -0,0 +1,389 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + + Alternatively, the contents of this file may be used under the terms + of the Mozilla Public License (http://mozilla.org/MPL) or the GNU + General Public License, as published by the Free Software Foundation, + either version 2 of the License or (at your option) any later version. +*/ +#pragma once + +#include "graphite2/Types.h" + +#define GR2_VERSION_MAJOR 1 +#define GR2_VERSION_MINOR 3 +#define GR2_VERSION_BUGFIX 14 + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct gr_face gr_face; +typedef struct gr_font gr_font; +typedef struct gr_feature_ref gr_feature_ref; +typedef struct gr_feature_val gr_feature_val; + +/** +* Returns version information on this engine +*/ +GR2_API void gr_engine_version(int *nMajor, int *nMinor, int *nBugFix); + +/** +* The Face Options allow the application to require that certain tables are +* read during face construction. This may be of concern if the appFaceHandle +* used in the gr_get_table_fn may change. +* The values can be combined +*/ +enum gr_face_options { + /** No preload, no cmap caching, fail if the graphite tables are invalid */ + gr_face_default = 0, + /** Dumb rendering will be enabled if the graphite tables are invalid. @deprecated Since 1.311 */ + gr_face_dumbRendering = 1, + /** preload glyphs at construction time */ + gr_face_preloadGlyphs = 2, + /** Cache the lookup from code point to glyph ID at construction time */ + gr_face_cacheCmap = 4, + /** Preload everything */ + gr_face_preloadAll = gr_face_preloadGlyphs | gr_face_cacheCmap +}; + +/** Holds information about a particular Graphite silf table that has been loaded */ +struct gr_faceinfo { + gr_uint16 extra_ascent; /**< The extra_ascent in the GDL, in design units */ + gr_uint16 extra_descent; /**< The extra_descent in the GDL, in design units */ + gr_uint16 upem; /**< The design units for the font */ + enum gr_space_contextuals { + gr_space_unknown = 0, /**< no information is known. */ + gr_space_none = 1, /**< the space character never occurs in any rules. */ + gr_space_left_only = 2, /**< the space character only occurs as the first element in a rule. */ + gr_space_right_only = 3, /**< the space character only occurs as the last element in a rule. */ + gr_space_either_only = 4, /**< the space character only occurs as the only element in a rule. */ + gr_space_both = 5, /**< the space character may occur as the first or last element of a rule. */ + gr_space_cross = 6 /**< the space character occurs in a rule not as a first or last element. */ + } space_contextuals; + unsigned int has_bidi_pass : 1; /**< the table specifies that a bidirectional pass should run */ + unsigned int line_ends : 1; /**< there are line end contextuals somewhere */ + unsigned int justifies : 1; /**< there are .justify properties set somewhere on some glyphs */ +}; + +typedef struct gr_faceinfo gr_faceinfo; + +/** type describing function to retrieve font table information + * + * @return a pointer to the table in memory. The pointed to memory must exist as + * long as the gr_face which makes the call. + * @param appFaceHandle is the unique information passed to gr_make_face() + * @param name is a 32bit tag to the table name. + * @param len returned by this function to say how long the table is in memory. + */ +typedef const void *(*gr_get_table_fn)(const void* appFaceHandle, unsigned int name, size_t *len); + +/** type describing function to release any resources allocated by the above get_table table function + * + * @param appFaceHandle is the unique information passed to gr_make_face() + * @param pointer to table memory returned by get_table. + */ +typedef void (*gr_release_table_fn)(const void* appFaceHandle, const void *table_buffer); + +/** struct housing function pointers to manage font table buffers for the graphite engine. */ +struct gr_face_ops +{ + /** size in bytes of this structure */ + size_t size; + /** a pointer to a function to request a table from the client. */ + gr_get_table_fn get_table; + /** is a pointer to a function to notify the client the a table can be released. + * This can be NULL to signify that the client does not wish to do any release handling. */ + gr_release_table_fn release_table; +}; +typedef struct gr_face_ops gr_face_ops; + +/** Create a gr_face object given application information and a table functions. + * + * @return gr_face or NULL if the font fails to load for some reason. + * @param appFaceHandle This is application specific information that is passed + * to the getTable function. The appFaceHandle must stay + * alive as long as the gr_face is alive. + * @param face_ops Pointer to face specific callback structure for table + * management. Must stay alive for the duration of the + * call only. + * @param faceOptions Bitfield describing various options. See enum gr_face_options for details. + */ +GR2_API gr_face* gr_make_face_with_ops(const void* appFaceHandle/*non-NULL*/, const gr_face_ops *face_ops, unsigned int faceOptions); + +/** @deprecated Since v1.2.0 in favour of gr_make_face_with_ops. + * Create a gr_face object given application information and a getTable function. + * + * @return gr_face or NULL if the font fails to load for some reason. + * @param appFaceHandle This is application specific information that is passed + * to the getTable function. The appFaceHandle must stay + * alive as long as the gr_face is alive. + * @param getTable Callback function to get table data. + * @param faceOptions Bitfield describing various options. See enum gr_face_options for details. + */ +GR2_DEPRECATED_API gr_face* gr_make_face(const void* appFaceHandle/*non-NULL*/, gr_get_table_fn getTable, unsigned int faceOptions); + +/** @deprecated Since 1.3.7 this function is now an alias for gr_make_face_with_ops(). + * + * Create a gr_face object given application information, with subsegmental caching support + * + * @return gr_face or NULL if the font fails to load. + * @param appFaceHandle is a pointer to application specific information that is passed to getTable. + * This may not be NULL and must stay alive as long as the gr_face is alive. + * @param face_ops Pointer to face specific callback structure for table management. Must stay + * alive for the duration of the call only. + * @param segCacheMaxSize Unused. + * @param faceOptions Bitfield of values from enum gr_face_options + */ +GR2_DEPRECATED_API gr_face* gr_make_face_with_seg_cache_and_ops(const void* appFaceHandle, const gr_face_ops *face_ops, unsigned int segCacheMaxSize, unsigned int faceOptions); + +/** @deprecated Since 1.3.7 this function is now an alias for gr_make_face(). + * + * Create a gr_face object given application information, with subsegmental caching support. + * This function is deprecated as of v1.2.0 in favour of gr_make_face_with_seg_cache_and_ops. + * + * @return gr_face or NULL if the font fails to load. + * @param appFaceHandle is a pointer to application specific information that is passed to getTable. + * This may not be NULL and must stay alive as long as the gr_face is alive. + * @param getTable The function graphite calls to access font table data + * @param segCacheMaxSize How large the segment cache is. + * @param faceOptions Bitfield of values from enum gr_face_options + */ +GR2_DEPRECATED_API gr_face* gr_make_face_with_seg_cache(const void* appFaceHandle, gr_get_table_fn getTable, unsigned int segCacheMaxSize, unsigned int faceOptions); + +/** Convert a tag in a string into a gr_uint32 + * + * @return gr_uint32 tag, zero padded + * @param str a nul terminated string of which at most the first 4 characters are read + */ +GR2_API gr_uint32 gr_str_to_tag(const char *str); + +/** Convert a gr_uint32 tag into a string + * + * @param tag contains the tag to convert + * @param str is a pointer to a char array of at least size 4 bytes. The first 4 bytes of this array + * will be overwritten by this function. No nul is appended. + */ +GR2_API void gr_tag_to_str(gr_uint32 tag, char *str); + +/** Get feature values for a given language or default + * + * @return a copy of the default feature values for a given language. The application must call + * gr_featureval_destroy() to free this object when done. + * @param pFace The font face to get feature values from + * @param langname The language tag to get feature values for. If there is no such language or + * langname is 0, the default feature values for the font are returned. + * langname is right 0 padded and assumes lowercase. Thus the en langauge + * would be 0x656E0000. Langname may also be space padded, thus 0x656E2020. + */ +GR2_API gr_feature_val* gr_face_featureval_for_lang(const gr_face* pFace, gr_uint32 langname); + +/** Get feature reference for a given feature id from a face + * + * @return a feature reference corresponding to the given id. This data is part of the gr_face and + * will be freed when the face is destroyed. + * @param pFace Font face to get information on. + * @param featId Feature id tag to get reference to. + */ +GR2_API const gr_feature_ref* gr_face_find_fref(const gr_face* pFace, gr_uint32 featId); + +/** Returns number of feature references in a face **/ +GR2_API gr_uint16 gr_face_n_fref(const gr_face* pFace); + +/** Returns feature reference at given index in face **/ +GR2_API const gr_feature_ref* gr_face_fref(const gr_face* pFace, gr_uint16 i); + +/** Return number of languages the face knows about **/ +GR2_API unsigned short gr_face_n_languages(const gr_face* pFace); + +/** Returns a language id corresponding to a language of given index in the face **/ +GR2_API gr_uint32 gr_face_lang_by_index(const gr_face* pFace, gr_uint16 i); + +/** Destroy the given face and free its memory **/ +GR2_API void gr_face_destroy(gr_face *face); + +/** Returns the number of glyphs in the face **/ +GR2_API unsigned short gr_face_n_glyphs(const gr_face* pFace); + +/** Returns a faceinfo for the face and script **/ +GR2_API const gr_faceinfo *gr_face_info(const gr_face *pFace, gr_uint32 script); + +/** Returns whether the font supports a given Unicode character + * + * @return true if the character is supported. + * @param pFace face to test within + * @param usv Unicode Scalar Value of character to test + * @param script Tag of script for selecting which set of pseudo glyphs to test. May be NULL. + */ +GR2_API int gr_face_is_char_supported(const gr_face *pFace, gr_uint32 usv, gr_uint32 script); + +#ifndef GRAPHITE2_NFILEFACE +/** Create gr_face from a font file + * + * @return gr_face that accesses a font file directly. Returns NULL on failure. + * @param filename Full path and filename to font file + * @param faceOptions Bitfile from enum gr_face_options to control face options. + */ +GR2_API gr_face* gr_make_file_face(const char *filename, unsigned int faceOptions); + +/** @deprecated Since 1.3.7. This function is now an alias for gr_make_file_face(). + * + * Create gr_face from a font file, with subsegment caching support. + * + * @return gr_face that accesses a font file directly. Returns NULL on failure. + * @param filename Full path and filename to font file + * @param segCacheMaxSize Specifies how big to make the cache in segments. + * @param faceOptions Bitfield from enum gr_face_options to control face options. + */ +GR2_DEPRECATED_API gr_face* gr_make_file_face_with_seg_cache(const char *filename, unsigned int segCacheMaxSize, unsigned int faceOptions); +#endif // !GRAPHITE2_NFILEFACE + +/** Create a font from a face + * + * @return gr_font Call font_destroy to free this font + * @param ppm Resolution of the font in pixels per em + * @param face Face this font corresponds to. This must stay alive as long as the font is alive. + */ +GR2_API gr_font* gr_make_font(float ppm, const gr_face *face); + +/** query function to find the hinted advance of a glyph + * + * @param appFontHandle is the unique information passed to gr_make_font_with_advance() + * @param glyphid is the glyph to retireve the hinted advance for. + */ +typedef float (*gr_advance_fn)(const void* appFontHandle, gr_uint16 glyphid); + +/** struct housing function pointers to manage font hinted metrics for the + * graphite engine. */ +struct gr_font_ops +{ + /** size of the structure in bytes to allow for future extensibility */ + size_t size; + /** a pointer to a function to retrieve the hinted + * advance width of a glyph which the font cannot + * provide without client assistance. This can be + * NULL to signify no horizontal hinted metrics are necessary. */ + gr_advance_fn glyph_advance_x; + /** a pointer to a function to retrieve the hinted + * advance height of a glyph which the font cannot + * provide without client assistance. This can be + * NULL to signify no horizontal hinted metrics are necessary. */ + gr_advance_fn glyph_advance_y; +}; +typedef struct gr_font_ops gr_font_ops; + +/** Creates a font with hinted advance width query functions + * + * @return gr_font to be destroyed via font_destroy + * @param ppm size of font in pixels per em + * @param appFontHandle font specific information that must stay alive as long + * as the font does + * @param font_ops pointer font specific callback structure for hinted metrics. + * Need only stay alive for the duration of the call. + * @param face the face this font corresponds to. Must stay alive as long as + * the font does. + */ +GR2_API gr_font* gr_make_font_with_ops(float ppm, const void* appFontHandle, const gr_font_ops * font_ops, const gr_face *face); + +/** Creates a font with hinted advance width query function. + * This function is deprecated. Use gr_make_font_with_ops instead. + * + * @return gr_font to be destroyed via font_destroy + * @param ppm size of font in pixels per em + * @param appFontHandle font specific information that must stay alive as long + * as the font does + * @param getAdvance callback function reference that returns horizontal advance in pixels for a glyph. + * @param face the face this font corresponds to. Must stay alive as long as + * the font does. + */ +GR2_API gr_font* gr_make_font_with_advance_fn(float ppm, const void* appFontHandle, gr_advance_fn getAdvance, const gr_face *face); + +/** Free a font **/ +GR2_API void gr_font_destroy(gr_font *font); + +/** get a feature value + * + * @return value of specific feature or 0 if any problems. + * @param pfeatureref gr_feature_ref to the feature + * @param feats gr_feature_val containing all the values + */ +GR2_API gr_uint16 gr_fref_feature_value(const gr_feature_ref* pfeatureref, const gr_feature_val* feats); + +/** set a feature value + * + * @return false if there were any problems (value out of range, etc.) + * @param pfeatureref gr_feature_ref to the feature + * @param val value to set the feature to + * @param pDest the gr_feature_val containing all the values for all the features + */ +GR2_API int gr_fref_set_feature_value(const gr_feature_ref* pfeatureref, gr_uint16 val, gr_feature_val* pDest); + +/** Returns the id tag for a gr_feature_ref **/ +GR2_API gr_uint32 gr_fref_id(const gr_feature_ref* pfeatureref); + +/** Returns number of values a feature may take, given a gr_feature_ref **/ +GR2_API gr_uint16 gr_fref_n_values(const gr_feature_ref* pfeatureref); + +/** Returns the value associated with a particular value in a feature + * + * @return value + * @param pfeatureref gr_feature_ref of the feature of interest + * @param settingno Index up to the return value of gr_fref_n_values() of the value + */ +GR2_API gr_int16 gr_fref_value(const gr_feature_ref* pfeatureref, gr_uint16 settingno); + +/** Returns a string of the UI name of a feature + * + * @return string of the UI name, in the encoding form requested. Call gr_label_destroy() after use. + * @param pfeatureref gr_feature_ref of the feature + * @param langId This is a pointer since the face may not support a string in the requested + * language. The actual language of the string is returned in langId + * @param utf Encoding form for the string + * @param length Used to return the length of the string returned in bytes. + */ +GR2_API void* gr_fref_label(const gr_feature_ref* pfeatureref, gr_uint16 *langId, enum gr_encform utf, gr_uint32 *length); + +/** Return a UI string for a possible value of a feature + * + * @return string of the UI name, in the encoding form requested. nul terminated. Call gr_label_destroy() + * after use. + * @param pfeatureref gr_feature_ref of the feature + * @param settingno Value setting index + * @param langId This is a pointer to the requested language. The requested language id is + * replaced by the actual language id of the string returned. + * @param utf Encoding form for the string + * @param length Returns the length of the string returned in bytes. + */ +GR2_API void* gr_fref_value_label(const gr_feature_ref* pfeatureref, gr_uint16 settingno/*rather than a value*/, gr_uint16 *langId, enum gr_encform utf, gr_uint32 *length); + +/** Destroy a previously returned label string **/ +GR2_API void gr_label_destroy(void * label); + +/** Copies a gr_feature_val **/ +GR2_API gr_feature_val* gr_featureval_clone(const gr_feature_val* pfeatures); + +/** Destroys a gr_feature_val **/ +GR2_API void gr_featureval_destroy(gr_feature_val *pfeatures); + +#ifdef __cplusplus +} +#endif diff --git a/gfx/graphite2/include/graphite2/Log.h b/gfx/graphite2/include/graphite2/Log.h new file mode 100644 index 0000000000..a5a6947fab --- /dev/null +++ b/gfx/graphite2/include/graphite2/Log.h @@ -0,0 +1,85 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + + Alternatively, the contents of this file may be used under the terms + of the Mozilla Public License (http://mozilla.org/MPL) or the GNU + General Public License, as published by the Free Software Foundation, + either version 2 of the License or (at your option) any later version. +*/ +#pragma once + +#include <graphite2/Types.h> +#include <graphite2/Font.h> +#include <stdio.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** deprecated mechanism that doesn't do anything now. */ +typedef enum { + GRLOG_NONE = 0x0, + GRLOG_FACE = 0x01, + GRLOG_SEGMENT = 0x02, + GRLOG_PASS = 0x04, + GRLOG_CACHE = 0x08, + + GRLOG_OPCODE = 0x80, + GRLOG_ALL = 0xFF +} GrLogMask; + +/** Start logging all segment creation and updates on the provided face. This + * is logged to a JSON file, see "Segment JSON Schema.txt" for a precise + * definition of the file + * + * @return true if the file was successfully created and logging is correctly + * initialised. + * @param face the gr_face whose segments you want to log to the given file + * @param log_path a utf8 encoded file name and path to log to. + */ +GR2_API bool gr_start_logging(gr_face * face, const char *log_path); + + +/** Stop logging on the given face. This will close the log file created by + * gr_start_logging. + * + * @param face the gr_face whose segments you want to stop logging + */ +GR2_API void gr_stop_logging(gr_face * face); + +/** Start logging to a FILE object. + * This function is deprecated as of 1.2.0, use the _face versions instead. + * + * @return True on success + * @param logfile FILE reference to output logging to + * @param mask What aspects of logging to report (ignored) + */ +GR2_API bool graphite_start_logging(FILE * logFile, GrLogMask mask); //may not do anthing if disabled in the implementation of the engine. + +/** Stop logging to a FILE object. + * This function is deprecated as of 1.2.0, use the _face versions instead. + */ +GR2_API void graphite_stop_logging(); + +#ifdef __cplusplus +} +#endif diff --git a/gfx/graphite2/include/graphite2/Segment.h b/gfx/graphite2/include/graphite2/Segment.h new file mode 100644 index 0000000000..0e24f5d795 --- /dev/null +++ b/gfx/graphite2/include/graphite2/Segment.h @@ -0,0 +1,461 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + + Alternatively, the contents of this file may be used under the terms + of the Mozilla Public License (http://mozilla.org/MPL) or the GNU + General Public License, as published by the Free Software Foundation, + either version 2 of the License or (at your option) any later version. +*/ +#pragma once + +#include "graphite2/Types.h" +#include "graphite2/Font.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +enum gr_break_weight { + gr_breakNone = 0, + /* after break weights */ + gr_breakWhitespace = 10, + gr_breakWord = 15, + gr_breakIntra = 20, + gr_breakLetter = 30, + gr_breakClip = 40, + /* before break weights */ + gr_breakBeforeWhitespace = -10, + gr_breakBeforeWord = -15, + gr_breakBeforeIntra = -20, + gr_breakBeforeLetter = -30, + gr_breakBeforeClip = -40 +}; + +enum gr_justFlags { + /// Indicates that this segment is a complete line + gr_justCompleteLine = 0, + /// Indicates that the start of the slot list is not at the start of a line + gr_justStartInline = 1, + /// Indicates that the end of the slot list is not at the end of a line + gr_justEndInline = 2 +}; + +/** Used for looking up slot attributes. Most are already available in other functions **/ +enum gr_attrCode { + /// adjusted glyph advance in x direction in design units + gr_slatAdvX = 0, + /// adjusted glyph advance in y direction (usually 0) in design units + gr_slatAdvY, + /// returns 0. Deprecated. + gr_slatAttTo, + /// This slot attaches to its parent at the given design units in the x direction + gr_slatAttX, + /// This slot attaches to its parent at the given design units in the y direction + gr_slatAttY, + /// This slot attaches to its parent at the given glyph point (not implemented) + gr_slatAttGpt, + /// x-direction adjustment from the given glyph point (not implemented) + gr_slatAttXOff, + /// y-direction adjustment from the given glyph point (not implemented) + gr_slatAttYOff, + /// Where on this glyph should align with the attachment point on the parent glyph in the x-direction. + gr_slatAttWithX, + /// Where on this glyph should align with the attachment point on the parent glyph in the y-direction + gr_slatAttWithY, + /// Which glyph point on this glyph should align with the attachment point on the parent glyph (not implemented). + gr_slatWithGpt, + /// Adjustment to gr_slatWithGpt in x-direction (not implemented) + gr_slatAttWithXOff, + /// Adjustment to gr_slatWithGpt in y-direction (not implemented) + gr_slatAttWithYOff, + /// Attach at given nesting level (not implemented) + gr_slatAttLevel, + /// Line break breakweight for this glyph + gr_slatBreak, + /// Ligature component reference (not implemented) + gr_slatCompRef, + /// bidi directionality of this glyph (not implemented) + gr_slatDir, + /// Whether insertion is allowed before this glyph + gr_slatInsert, + /// Final positioned position of this glyph relative to its parent in x-direction in pixels + gr_slatPosX, + /// Final positioned position of this glyph relative to its parent in y-direction in pixels + gr_slatPosY, + /// Amount to shift glyph by in x-direction design units + gr_slatShiftX, + /// Amount to shift glyph by in y-direction design units + gr_slatShiftY, + /// attribute user1 + gr_slatUserDefnV1, + /// not implemented + gr_slatMeasureSol, + /// not implemented + gr_slatMeasureEol, + /// Amount this slot can stretch (not implemented) + gr_slatJStretch, + /// Amount this slot can shrink (not implemented) + gr_slatJShrink, + /// Granularity by which this slot can stretch or shrink (not implemented) + gr_slatJStep, + /// Justification weight for this glyph (not implemented) + gr_slatJWeight, + /// Amount this slot mush shrink or stretch in design units + gr_slatJWidth = 29, + /// SubSegment split point + gr_slatSegSplit = gr_slatJStretch + 29, + /// User defined attribute, see subattr for user attr number + gr_slatUserDefn, + /// Bidi level + gr_slatBidiLevel = 56, + /// Collision flags + gr_slatColFlags, + /// Collision constraint rectangle left (bl.x) + gr_slatColLimitblx, + /// Collision constraint rectangle lower (bl.y) + gr_slatColLimitbly, + /// Collision constraint rectangle right (tr.x) + gr_slatColLimittrx, + /// Collision constraint rectangle upper (tr.y) + gr_slatColLimittry, + /// Collision shift x + gr_slatColShiftx, + /// Collision shift y + gr_slatColShifty, + /// Collision margin + gr_slatColMargin, + /// Margin cost weight + gr_slatColMarginWt, + // Additional glyph that excludes movement near this one: + gr_slatColExclGlyph, + gr_slatColExclOffx, + gr_slatColExclOffy, + // Collision sequence enforcing attributes: + gr_slatSeqClass, + gr_slatSeqProxClass, + gr_slatSeqOrder, + gr_slatSeqAboveXoff, + gr_slatSeqAboveWt, + gr_slatSeqBelowXlim, + gr_slatSeqBelowWt, + gr_slatSeqValignHt, + gr_slatSeqValignWt, + + /// not implemented + gr_slatMax, + /// not implemented + gr_slatNoEffect = gr_slatMax + 1 +}; + +enum gr_bidirtl { + /// Underlying paragraph direction is RTL + gr_rtl = 1, + /// Set this to not run the bidi pass internally, even if the font asks for it. + /// This presumes that the segment is in a single direction. Most of the time + /// this bit should be set unless you know you are passing full paragraphs of text. + gr_nobidi = 2, + /// Disable auto mirroring for rtl text + gr_nomirror = 4 +}; + +typedef struct gr_char_info gr_char_info; +typedef struct gr_segment gr_segment; +typedef struct gr_slot gr_slot; + +/** Returns Unicode character for a charinfo. + * + * @param p Pointer to charinfo to return information on. + */ +GR2_API unsigned int gr_cinfo_unicode_char(const gr_char_info* p/*not NULL*/); + +/** Returns breakweight for a charinfo. + * + * @return Breakweight is a number between -50 and 50 indicating the cost of a + * break before or after this character. If the value < 0, the absolute value + * is this character's contribution to the overall breakweight before it. If the value + * > 0, then the value is this character's contribution to the overall breakweight after it. + * The overall breakweight between two characters is the maximum of the breakweight + * contributions from the characters either side of it. If a character makes no + * contribution to the breakweight on one side of it, the contribution is considered + * to be 0. + * @param p Pointer to charinfo to return information on. + */ +GR2_API int gr_cinfo_break_weight(const gr_char_info* p/*not NULL*/); + +/** Returns the slot index that after this character is after in the slot stream + * + * In effect each character is associated with a set of slots and this returns + * the index of the last slot in the segment this character is associated with. + * + * @return after slot index between 0 and gr_seg_n_slots() + * @param p Pointer to charinfo to return information on. + */ +GR2_API int gr_cinfo_after(const gr_char_info* p/*not NULL*/); + +/** Returns the slot index that before this character is before in the slot stream + * + * In effect each character is associated with a set of slots and this returns + * the index of the first slot in the segment this character is associated with. + * + * @return before slot index between 0 and gr_seg_n_slots() + * @param p Pointer to charinfo to return information on. + */ +GR2_API int gr_cinfo_before(const gr_char_info* p/*not NULL*/); + +/** Returns the code unit index of this character in the input string + * + * @return code unit index between 0 and the end of the string + * @param p Pointer to charinfo to return information on. + */ +GR2_API size_t gr_cinfo_base(const gr_char_info* p/*not NULL*/); + +/** Returns the number of unicode characters in a string. + * + * @return number of characters in the string + * @param enc Specifies the type of data in the string: utf8, utf16, utf32 + * @param buffer_begin The start of the string + * @param buffer_end Measure up to the first nul or when end is reached, whichever is earliest. + * This parameter may be NULL. + * @param pError If there is a structural fault in the string, the location is returned + * in this variable. If no error occurs, pError will contain NULL. NULL + * may be passed for pError if no such information is required. + */ +GR2_API size_t gr_count_unicode_characters(enum gr_encform enc, const void* buffer_begin, const void* buffer_end, const void** pError); + +/** Creates and returns a segment. + * + * @return a segment that needs seg_destroy called on it. May return NULL if bad problems + * in segment processing. + * @param font Gives the size of the font in pixels per em for final positioning. If + * NULL, positions are returned in design units, i.e. at a ppm of the upem + * of the face. + * @param face The face containing all the non-size dependent information. + * @param script This is a tag containing a script identifier that is used to choose + * which graphite table within the font to use. Maybe 0. Tag may be 4 chars + * NULL padded in LSBs or space padded in LSBs. + * @param pFeats Pointer to a feature values to be used for the segment. Only one + * feature values may be used for a segment. If NULL the default features + * for the font will be used. + * @param enc Specifies what encoding form the string is in (utf8, utf16, utf32) + * @param pStart Start of the string + * @param nChars Number of unicode characters to process in the string. The string will + * be processed either up to the first NULL or until nChars have been + * processed. nChars is also used to initialise the internal memory + * allocations of the segment. So it is wise not to make nChars too much + * greater than the actual number of characters being processed. + * @param dir Specifies whether the segment is processed right to left (1) or left to + * right (0) and whether to run the internal bidi pass, if a font requests it. + * See enum gr_bidirtl for details. + */ +GR2_API gr_segment* gr_make_seg(const gr_font* font, const gr_face* face, gr_uint32 script, const gr_feature_val* pFeats, enum gr_encform enc, const void* pStart, size_t nChars, int dir); + +/** Destroys a segment, freeing the memory. + * + * @param p The segment to destroy + */ +GR2_API void gr_seg_destroy(gr_segment* p); + +/** Returns the advance for the whole segment. + * + * Returns the width of the segment up to the next glyph origin after the segment + */ +GR2_API float gr_seg_advance_X(const gr_segment* pSeg/*not NULL*/); + +/** Returns the height advance for the segment. **/ +GR2_API float gr_seg_advance_Y(const gr_segment* pSeg/*not NULL*/); + +/** Returns the number of gr_char_infos in the segment. **/ +GR2_API unsigned int gr_seg_n_cinfo(const gr_segment* pSeg/*not NULL*/); + +/** Returns a gr_char_info at a given index in the segment. **/ +GR2_API const gr_char_info* gr_seg_cinfo(const gr_segment* pSeg/*not NULL*/, unsigned int index/*must be <number_of_CharInfo*/); + +/** Returns the number of glyph gr_slots in the segment. **/ +GR2_API unsigned int gr_seg_n_slots(const gr_segment* pSeg/*not NULL*/); //one slot per glyph + +/** Returns the first gr_slot in the segment. + * + * The first slot in a segment has a gr_slot_prev_in_segment() of NULL. Slots are owned + * by their segment and are destroyed along with the segment. + */ +GR2_API const gr_slot* gr_seg_first_slot(gr_segment* pSeg/*not NULL*/); //may give a base slot or a slot which is attached to another + +/** Returns the last gr_slot in the segment. + * + * The last slot in a segment has a gr_slot_next_in_segment() of NULL + */ +GR2_API const gr_slot* gr_seg_last_slot(gr_segment* pSeg/*not NULL*/); //may give a base slot or a slot which is attached to another + +/** Justifies a linked list of slots for a line to a given width + * + * Passed a pointer to the start of a linked list of slots corresponding to a line, as + * set up by gr_slot_linebreak_before, this function will position the glyphs in the line + * to take up the given width. It is possible to specify a subrange within the line to process. + * This allows skipping of line initial or final whitespace, for example. While this will ensure + * that the subrange fits width, the line will still be positioned with the first glyph of the + * line at 0. So the resulting positions may be beyond width. + * + * @return float The resulting width of the range of slots justified. + * @param pSeg Pointer to the segment + * @param pStart Pointer to the start of the line linked list (including skipped characters) + * @param pFont Font to use for positioning + * @param width Width in pixels in which to fit the line. If < 0. don't adjust natural width, just run justification passes + * to handle line end contextuals, if there are any. + * @param flags Indicates line ending types. Default is linked list is a full line + * @param pFirst If not NULL, the first slot in the list to be considered part of the line (so can skip) + * @param pLast If not NULL, the last slot to process in the line (allow say trailing whitespace to be skipped) + */ +GR2_API float gr_seg_justify(gr_segment* pSeg/*not NULL*/, const gr_slot* pStart/*not NULL*/, const gr_font *pFont, double width, enum gr_justFlags flags, const gr_slot* pFirst, const gr_slot* pLast); + +/** Returns the next slot along in the segment. + * + * Slots are held in a linked list. This returns the next in the linked list. The slot + * may or may not be attached to another slot. Returns NULL at the end of the segment. + */ +GR2_API const gr_slot* gr_slot_next_in_segment(const gr_slot* p); + +/** Returns the previous slot along in the segment. + * + * Slots are held in a doubly linked list. This returns the previos slot in the linked + * list. This slot may or may not be attached to it. Returns NULL at the start of the + * segment. + */ +GR2_API const gr_slot* gr_slot_prev_in_segment(const gr_slot* p); + +/** Returns the attachment parent slot of this slot. + * + * Attached slots form a tree. This returns the parent of this slot in that tree. A + * base glyph which is not attached to another glyph, always returns NULL. + */ +GR2_API const gr_slot* gr_slot_attached_to(const gr_slot* p); + +/** Returns the first slot attached to this slot. + * + * Attached slots form a singly linked list from the parent. This returns the first + * slot in that list. Note that this is a reference to another slot that is also in + * the main segment doubly linked list. + * + * if gr_slot_first_attachment(p) != NULL then gr_slot_attached_to(gr_slot_first_attachment(p)) == p. + */ +GR2_API const gr_slot* gr_slot_first_attachment(const gr_slot* p); + +/** Returns the next slot attached to our attachment parent. + * + * This returns the next slot in the singly linked list of slots attached to this + * slot's parent. If there are no more such slots, NULL is returned. If there is + * no parent, i.e. the passed slot is a cluster base, then the next cluster base + * in graphical order (ltr, even for rtl text) is returned. + * + * if gr_slot_next_sibling_attachment(p) != NULL then gr_slot_attached_to(gr_slot_next_sibling_attachment(p)) == gr_slot_attached_to(p). + */ +GR2_API const gr_slot* gr_slot_next_sibling_attachment(const gr_slot* p); + + +/** Returns glyph id of the slot + * + * Each slot has a glyphid which is rendered at the position given by the slot. This + * glyphid is the real glyph to be rendered and never a pseudo glyph. + */ +GR2_API unsigned short gr_slot_gid(const gr_slot* p); + +/** Returns X offset of glyph from start of segment **/ +GR2_API float gr_slot_origin_X(const gr_slot* p); + +/** Returns Y offset of glyph from start of segment **/ +GR2_API float gr_slot_origin_Y(const gr_slot* p); + +/** Returns the glyph advance for this glyph as adjusted for kerning + * + * @param p Slot to give results for + * @param face gr_face of the glyphs. May be NULL if unhinted advances used + * @param font gr_font to scale for pixel results. If NULL returns design + * units advance. If not NULL then returns pixel advance based + * on hinted or scaled glyph advances in the font. face must be + * passed for hinted advances to be used. + */ +GR2_API float gr_slot_advance_X(const gr_slot* p, const gr_face* face, const gr_font *font); + +/** Returns the vertical advance for the glyph in the slot adjusted for kerning + * + * Returns design units unless font is not NULL in which case the pixel value + * is returned scaled for the given font + */ +GR2_API float gr_slot_advance_Y(const gr_slot* p, const gr_face* face, const gr_font *font); + +/** Returns the gr_char_info index before us + * + * Returns the index of the gr_char_info that a cursor before this slot, would put + * an underlying cursor before. This may also be interpretted as each slot holding + * a set of char_infos that it is associated with and this function returning the + * index of the char_info with lowest index, from this set. + */ +GR2_API int gr_slot_before(const gr_slot* p/*not NULL*/); + +/** Returns the gr_char_info index after us + * + * Returns the index of the gr_char_info that a cursor after this slot would put an + * underlying cursor after. This may also be interpretted as each slot holding a set + * of char_infos that it is associated with and this function returning the index of + * the char_info with the highest index, from this set. + */ +GR2_API int gr_slot_after(const gr_slot* p/*not NULL*/); + +/** Returns the index of this slot in the segment + * + * Returns the index given to this slot during final positioning. This corresponds + * to the value returned br gr_cinfo_before() and gr_cinfo_after() + */ +GR2_API unsigned int gr_slot_index(const gr_slot* p/*not NULL*/); + +/** Return a slot attribute value + * + * Given a slot and an attribute along with a possible subattribute, return the + * corresponding value in the slot. See enum gr_attrCode for details of each attribute. + */ +GR2_API int gr_slot_attr(const gr_slot* p/*not NULL*/, const gr_segment* pSeg/*not NULL*/, enum gr_attrCode index, gr_uint8 subindex); //tbd - do we need to expose this? + +/** Returns whether text may be inserted before this glyph. + * + * This indicates whether a cursor can be put before this slot. It applies to + * base glyphs that have no parent as well as attached glyphs that have the + * .insert attribute explicitly set to true. This is the primary mechanism + * for identifying contiguous sequences of base plus diacritics. + */ +GR2_API int gr_slot_can_insert_before(const gr_slot* p); + +/** Returns the original gr_char_info index this slot refers to. + * + * Each Slot has a gr_char_info that it originates from. This is that gr_char_info. + * The index is passed to gr_seg_cinfo(). This information is useful for testing. + */ +GR2_API int gr_slot_original(const gr_slot* p/*not NULL*/); + +/** Breaks a segment into lines. + * + * Breaks the slot linked list at the given point in the linked list. It is up + * to the application to keep track of the first slot on each line. + */ +GR2_API void gr_slot_linebreak_before(gr_slot *p/*not NULL*/); + +#ifdef __cplusplus +} +#endif diff --git a/gfx/graphite2/include/graphite2/Types.h b/gfx/graphite2/include/graphite2/Types.h new file mode 100644 index 0000000000..916c91191b --- /dev/null +++ b/gfx/graphite2/include/graphite2/Types.h @@ -0,0 +1,79 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + + Alternatively, the contents of this file may be used under the terms + of the Mozilla Public License (http://mozilla.org/MPL) or the GNU + General Public License, as published by the Free Software Foundation, + either version 2 of the License or (at your option) any later version. +*/ +#pragma once + +#include <stddef.h> + +typedef unsigned char gr_uint8; +typedef gr_uint8 gr_byte; +typedef signed char gr_int8; +typedef unsigned short gr_uint16; +typedef short gr_int16; +typedef unsigned int gr_uint32; +typedef int gr_int32; + +enum gr_encform { + gr_utf8 = 1/*sizeof(uint8)*/, gr_utf16 = 2/*sizeof(uint16)*/, gr_utf32 = 4/*sizeof(uint32)*/ +}; + + +// Define API function declspec/attributes and how each supported compiler or OS +// allows us to specify them. +#if defined __GNUC__ + #define _gr2_and , + #define _gr2_tag_fn(a) __attribute__((a)) + #define _gr2_deprecated_flag deprecated + #define _gr2_export_flag visibility("default") + #define _gr2_import_flag visibility("default") + #define _gr2_static_flag visibility("hidden") +#endif + +#if defined _WIN32 || defined __CYGWIN__ + #if defined __GNUC__ // These three will be redefined for Windows + #undef _gr2_export_flag + #undef _gr2_import_flag + #undef _gr2_static_flag + #else // How MSVC sepcifies function level attributes adn deprecation + #define _gr2_and + #define _gr2_tag_fn(a) __declspec(a) + #define _gr2_deprecated_flag deprecated + #endif + #define _gr2_export_flag dllexport + #define _gr2_import_flag dllimport + #define _gr2_static_flag +#endif + +#if defined GRAPHITE2_STATIC + #define GR2_API _gr2_tag_fn(_gr2_static_flag) + #define GR2_DEPRECATED_API _gr2_tag_fn(_gr2_deprecated_flag _gr2_and _gr2_static_flag) +#elif defined GRAPHITE2_EXPORTING + #define GR2_API _gr2_tag_fn(_gr2_export_flag) + #define GR2_DEPRECATED_API _gr2_tag_fn(_gr2_deprecated_flag _gr2_and _gr2_export_flag) +#else + #define GR2_API _gr2_tag_fn(_gr2_import_flag) + #define GR2_DEPRECATED_API _gr2_tag_fn(_gr2_deprecated_flag _gr2_and _gr2_import_flag) +#endif diff --git a/gfx/graphite2/moz.yaml b/gfx/graphite2/moz.yaml new file mode 100644 index 0000000000..67c6db62ad --- /dev/null +++ b/gfx/graphite2/moz.yaml @@ -0,0 +1,38 @@ +schema: 1 + +bugzilla: + product: Core + component: "Graphics: Text" + +origin: + name: graphite2 + description: smart font system developed specifically to handle the complexities of lesser-known languages of the world + + url: https://graphite.sil.org/ + + release: 1.3.14 (2020-04-01T09:53:13+07:00). + revision: 1.3.14 + + license: LGPL-2.1 + license-file: LICENSE + +vendoring: + url: https://github.com/silnrsi/graphite + source-hosting: github + tracking: tag + + exclude: + - "**" + + include: + - ChangeLog + - COPYING + - LICENSE + - include + - README.md + - src + + keep: + - geckoextra + - src/MozGrMalloc.h + - src/sources.mozbuild diff --git a/gfx/graphite2/src/CMakeLists.txt b/gfx/graphite2/src/CMakeLists.txt new file mode 100644 index 0000000000..b6ac26bfc2 --- /dev/null +++ b/gfx/graphite2/src/CMakeLists.txt @@ -0,0 +1,159 @@ +# GRAPHITE2 LICENSING +# +# Copyright 2010, SIL International +# All rights reserved. +# +# This library is free software; you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published +# by the Free Software Foundation; either version 2.1 of 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 +# Lesser General Public License for more details. +# +# You should also have received a copy of the GNU Lesser General Public +# License along with this library in the file named "LICENSE". +# If not, write to the Free Software Foundation, 51 Franklin Street, +# Suite 500, Boston, MA 02110-1335, USA or visit their web page on the +# internet at http://www.fsf.org/licenses/lgpl.html. + +CMAKE_MINIMUM_REQUIRED(VERSION 2.8.0 FATAL_ERROR) +project(graphite2_core) +cmake_policy(SET CMP0012 NEW) +INCLUDE(CheckCXXSourceCompiles) + +set(GRAPHITE_API_CURRENT 3) +set(GRAPHITE_API_REVISION 2) +set(GRAPHITE_API_AGE 1) +set(GRAPHITE_VERSION ${GRAPHITE_API_CURRENT}.${GRAPHITE_API_REVISION}.${GRAPHITE_API_AGE}) +set(GRAPHITE_SO_VERSION ${GRAPHITE_API_CURRENT}) + +include(TestBigEndian) + +include_directories(${PROJECT_SOURCE_DIR}) + +set(FILEFACE FileFace.cpp) +if (GRAPHITE2_NFILEFACE) + add_definitions(-DGRAPHITE2_NFILEFACE) + set(FILEFACE) +endif() + +set(TRACING json.cpp) +if (GRAPHITE2_NTRACING) + add_definitions(-DGRAPHITE2_NTRACING) + set(TRACING) +endif() + +if (GRAPHITE2_TELEMETRY) + add_definitions(-DGRAPHITE2_TELEMETRY) +endif() + +if (NOT BUILD_SHARED_LIBS) + add_definitions(-DGRAPHITE2_STATIC) +endif() + +set(GRAPHITE_HEADERS + ../include/graphite2/Font.h + ../include/graphite2/Segment.h + ../include/graphite2/Types.h + ../include/graphite2/Log.h + ) + +file(GLOB PRIVATE_HEADERS inc/*.h) + +add_library(graphite2 + ${GRAPHITE2_VM_TYPE}_machine.cpp + gr_char_info.cpp + gr_features.cpp + gr_face.cpp + gr_font.cpp + gr_logging.cpp + gr_segment.cpp + gr_slot.cpp + CmapCache.cpp + Code.cpp + Collider.cpp + Decompressor.cpp + Face.cpp + FeatureMap.cpp + Font.cpp + GlyphFace.cpp + GlyphCache.cpp + Intervals.cpp + Justifier.cpp + NameTable.cpp + Pass.cpp + Position.cpp + Segment.cpp + Silf.cpp + Slot.cpp + Sparse.cpp + TtfUtil.cpp + UtfCodec.cpp + ${FILEFACE} + ${TRACING}) + +set_target_properties(graphite2 PROPERTIES PUBLIC_HEADER "${GRAPHITE_HEADERS}" + SOVERSION ${GRAPHITE_SO_VERSION} + VERSION ${GRAPHITE_VERSION} + LT_VERSION_CURRENT ${GRAPHITE_API_CURRENT} + LT_VERSION_REVISION ${GRAPHITE_API_REVISION} + LT_VERSION_AGE ${GRAPHITE_API_AGE}) + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux") + set_target_properties(graphite2 PROPERTIES + COMPILE_FLAGS "-Wall -Wextra -Wno-unknown-pragmas -Wendif-labels -Wshadow -Wctor-dtor-privacy -Wnon-virtual-dtor -fno-rtti -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden" + LINK_FLAGS "-nodefaultlibs ${GRAPHITE_LINK_FLAGS}" + LINKER_LANGUAGE C) + if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86|i.86") + add_definitions(-mfpmath=sse -msse2) + endif() + if (CMAKE_COMPILER_IS_GNUCXX) + add_definitions(-Wno-class-memaccess -Wdouble-promotion) + endif() + message(STATUS "Compiler ID is: ${CMAKE_CXX_COMPILER_ID}") + if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") + add_definitions(-Wimplicit-fallthrough -Wshorten-64-to-32) + endif() + if (${CMAKE_CXX_COMPILER} MATCHES ".*mingw.*") + target_link_libraries(graphite2 kernel32 msvcr90 mingw32 gcc user32) + else (${CMAKE_CXX_COMPILER} MATCHES ".*mingw.*") + if (GRAPHITE2_SANITIZERS) + target_link_libraries(graphite2 c gcc_s) + else () + target_link_libraries(graphite2 c gcc) + endif () + endif() + include(Graphite) + if (BUILD_SHARED_LIBS) + nolib_test(stdc++ $<TARGET_SONAME_FILE:graphite2>) + endif () + set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "") + CREATE_LIBTOOL_FILE(graphite2 "/lib${LIB_SUFFIX}") +endif() + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set_target_properties(graphite2 PROPERTIES + COMPILE_FLAGS "-Wall -Wextra -Wno-unknown-pragmas -Wimplicit-fallthrough -Wendif-labels -Wshadow -Wno-ctor-dtor-privacy -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden" + LINK_FLAGS "-nodefaultlibs" + LINKER_LANGUAGE C) + if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86|i.86") + add_definitions(-mfpmath=sse -msse2) + endif() + target_link_libraries(graphite2 c) + include(Graphite) + nolib_test(stdc++ $<TARGET_SONAME_FILE:graphite2>) + set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "") + CREATE_LIBTOOL_FILE(graphite2 "/lib${LIB_SUFFIX}") +endif() + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows") + set_target_properties(graphite2 PROPERTIES + COMPILE_DEFINITIONS "_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;UNICODE;GRAPHITE2_EXPORTING") +endif() + + +install(TARGETS graphite2 EXPORT graphite2 LIBRARY DESTINATION lib${LIB_SUFFIX} ARCHIVE DESTINATION lib${LIB_SUFFIX} PUBLIC_HEADER DESTINATION include/graphite2 RUNTIME DESTINATION bin) +install(EXPORT graphite2 DESTINATION share/graphite2 NAMESPACE gr2_) diff --git a/gfx/graphite2/src/CmapCache.cpp b/gfx/graphite2/src/CmapCache.cpp new file mode 100644 index 0000000000..d070019a34 --- /dev/null +++ b/gfx/graphite2/src/CmapCache.cpp @@ -0,0 +1,155 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +#include "inc/Main.h" +#include "inc/CmapCache.h" +#include "inc/Face.h" +#include "inc/TtfTypes.h" +#include "inc/TtfUtil.h" + + +using namespace graphite2; + +const void * bmp_subtable(const Face::Table & cmap) +{ + const void * stbl; + if (!cmap.size()) return 0; + if (TtfUtil::CheckCmapSubtable4(stbl = TtfUtil::FindCmapSubtable(cmap, 3, 1, cmap.size()), cmap + cmap.size()) + || TtfUtil::CheckCmapSubtable4(stbl = TtfUtil::FindCmapSubtable(cmap, 0, 3, cmap.size()), cmap + cmap.size()) + || TtfUtil::CheckCmapSubtable4(stbl = TtfUtil::FindCmapSubtable(cmap, 0, 2, cmap.size()), cmap + cmap.size()) + || TtfUtil::CheckCmapSubtable4(stbl = TtfUtil::FindCmapSubtable(cmap, 0, 1, cmap.size()), cmap + cmap.size()) + || TtfUtil::CheckCmapSubtable4(stbl = TtfUtil::FindCmapSubtable(cmap, 0, 0, cmap.size()), cmap + cmap.size())) + return stbl; + return 0; +} + +const void * smp_subtable(const Face::Table & cmap) +{ + const void * stbl; + if (!cmap.size()) return 0; + if (TtfUtil::CheckCmapSubtable12(stbl = TtfUtil::FindCmapSubtable(cmap, 3, 10, cmap.size()), cmap + cmap.size()) + || TtfUtil::CheckCmapSubtable12(stbl = TtfUtil::FindCmapSubtable(cmap, 0, 4, cmap.size()), cmap + cmap.size())) + return stbl; + return 0; +} + +template <unsigned int (*NextCodePoint)(const void *, unsigned int, int *), + uint16 (*LookupCodePoint)(const void *, unsigned int, int)> +bool cache_subtable(uint16 * blocks[], const void * cst, const unsigned int limit) +{ + int rangeKey = 0; + uint32 codePoint = NextCodePoint(cst, 0, &rangeKey), + prevCodePoint = 0; + while (codePoint < limit) + { + unsigned int block = codePoint >> 8; + if (!blocks[block]) + { + blocks[block] = grzeroalloc<uint16>(0x100); + if (!blocks[block]) + return false; + } + blocks[block][codePoint & 0xFF] = LookupCodePoint(cst, codePoint, rangeKey); + // prevent infinite loop + if (codePoint <= prevCodePoint) + codePoint = prevCodePoint + 1; + prevCodePoint = codePoint; + codePoint = NextCodePoint(cst, codePoint, &rangeKey); + } + return true; +} + + +CachedCmap::CachedCmap(const Face & face) +: m_isBmpOnly(true), + m_blocks(0) +{ + const Face::Table cmap(face, Tag::cmap); + if (!cmap) return; + + const void * bmp_cmap = bmp_subtable(cmap); + const void * smp_cmap = smp_subtable(cmap); + m_isBmpOnly = !smp_cmap; + + m_blocks = grzeroalloc<uint16 *>(m_isBmpOnly ? 0x100 : 0x1100); + if (m_blocks && smp_cmap) + { + if (!cache_subtable<TtfUtil::CmapSubtable12NextCodepoint, TtfUtil::CmapSubtable12Lookup>(m_blocks, smp_cmap, 0x10FFFF)) + return; + } + + if (m_blocks && bmp_cmap) + { + if (!cache_subtable<TtfUtil::CmapSubtable4NextCodepoint, TtfUtil::CmapSubtable4Lookup>(m_blocks, bmp_cmap, 0xFFFF)) + return; + } +} + +CachedCmap::~CachedCmap() throw() +{ + if (!m_blocks) return; + unsigned int numBlocks = (m_isBmpOnly)? 0x100 : 0x1100; + for (unsigned int i = 0; i < numBlocks; i++) + free(m_blocks[i]); + free(m_blocks); +} + +uint16 CachedCmap::operator [] (const uint32 usv) const throw() +{ + if ((m_isBmpOnly && usv > 0xFFFF) || (usv > 0x10FFFF)) + return 0; + const uint32 block = 0xFFFF & (usv >> 8); + if (m_blocks[block]) + return m_blocks[block][usv & 0xFF]; + return 0; +}; + +CachedCmap::operator bool() const throw() +{ + return m_blocks != 0; +} + + +DirectCmap::DirectCmap(const Face & face) +: _cmap(face, Tag::cmap), + _smp(smp_subtable(_cmap)), + _bmp(bmp_subtable(_cmap)) +{ +} + +uint16 DirectCmap::operator [] (const uint32 usv) const throw() +{ + return usv > 0xFFFF + ? (_smp ? TtfUtil::CmapSubtable12Lookup(_smp, usv, 0) : 0) + : TtfUtil::CmapSubtable4Lookup(_bmp, usv, 0); +} + +DirectCmap::operator bool () const throw() +{ + return _cmap && _bmp; +} + diff --git a/gfx/graphite2/src/Code.cpp b/gfx/graphite2/src/Code.cpp new file mode 100644 index 0000000000..ec5ab298ca --- /dev/null +++ b/gfx/graphite2/src/Code.cpp @@ -0,0 +1,782 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This class represents loaded graphite stack machine code. It performs +// basic sanity checks, on the incoming code to prevent more obvious problems +// from crashing graphite. +// Author: Tim Eves + +#include <cassert> +#include <cstddef> +#include <cstdlib> +#include <cstring> +#include "graphite2/Segment.h" +#include "inc/Code.h" +#include "inc/Face.h" +#include "inc/GlyphFace.h" +#include "inc/GlyphCache.h" +#include "inc/Machine.h" +#include "inc/Rule.h" +#include "inc/Silf.h" + +#include <cstdio> + +#ifdef NDEBUG +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif +#endif + + +using namespace graphite2; +using namespace vm; + +namespace { + +inline bool is_return(const instr i) { + const opcode_t * opmap = Machine::getOpcodeTable(); + const instr pop_ret = *opmap[POP_RET].impl, + ret_zero = *opmap[RET_ZERO].impl, + ret_true = *opmap[RET_TRUE].impl; + return i == pop_ret || i == ret_zero || i == ret_true; +} + +struct context +{ + context(uint8 ref=0) : codeRef(ref) {flags.changed=false; flags.referenced=false;} + struct { + uint8 changed:1, + referenced:1; + } flags; + uint8 codeRef; +}; + +} // end namespace + + +class Machine::Code::decoder +{ +public: + struct limits; + static const int NUMCONTEXTS = 256; + + decoder(limits & lims, Code &code, enum passtype pt) throw(); + + bool load(const byte * bc_begin, const byte * bc_end); + void apply_analysis(instr * const code, instr * code_end); + byte max_ref() { return _max_ref; } + int out_index() const { return _out_index; } + +private: + void set_ref(int index) throw(); + void set_noref(int index) throw(); + void set_changed(int index) throw(); + opcode fetch_opcode(const byte * bc); + void analyse_opcode(const opcode, const int8 * const dp) throw(); + bool emit_opcode(opcode opc, const byte * & bc); + bool validate_opcode(const byte opc, const byte * const bc); + bool valid_upto(const uint16 limit, const uint16 x) const throw(); + bool test_context() const throw(); + bool test_ref(int8 index) const throw(); + bool test_attr(attrCode attr) const throw(); + void failure(const status_t s) const throw() { _code.failure(s); } + + Code & _code; + int _out_index; + uint16 _out_length; + instr * _instr; + byte * _data; + limits & _max; + enum passtype _passtype; + int _stack_depth; + bool _in_ctxt_item; + int16 _slotref; + context _contexts[NUMCONTEXTS]; + byte _max_ref; +}; + + +struct Machine::Code::decoder::limits +{ + const byte * bytecode; + const uint8 pre_context; + const uint16 rule_length, + classes, + glyf_attrs, + features; + const byte attrid[gr_slatMax]; +}; + +inline Machine::Code::decoder::decoder(limits & lims, Code &code, enum passtype pt) throw() +: _code(code), + _out_index(code._constraint ? 0 : lims.pre_context), + _out_length(code._constraint ? 1 : lims.rule_length), + _instr(code._code), _data(code._data), _max(lims), _passtype(pt), + _stack_depth(0), + _in_ctxt_item(false), + _slotref(0), + _max_ref(0) +{ } + + + +Machine::Code::Code(bool is_constraint, const byte * bytecode_begin, const byte * const bytecode_end, + uint8 pre_context, uint16 rule_length, const Silf & silf, const Face & face, + enum passtype pt, byte * * const _out) + : _code(0), _data(0), _data_size(0), _instr_count(0), _max_ref(0), _status(loaded), + _constraint(is_constraint), _modify(false), _delete(false), _own(_out==0) +{ +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _code_cat(face.tele.code); +#endif + assert(bytecode_begin != 0); + if (bytecode_begin == bytecode_end) + { + // ::new (this) Code(); + return; + } + assert(bytecode_end > bytecode_begin); + const opcode_t * op_to_fn = Machine::getOpcodeTable(); + + // Allocate code and data target buffers, these sizes are a worst case + // estimate. Once we know their real sizes the we'll shrink them. + if (_out) _code = reinterpret_cast<instr *>(*_out); + else _code = static_cast<instr *>(malloc(estimateCodeDataOut(bytecode_end-bytecode_begin, 1, is_constraint ? 0 : rule_length))); + _data = reinterpret_cast<byte *>(_code + (bytecode_end - bytecode_begin)); + + if (!_code || !_data) { + failure(alloc_failed); + return; + } + + decoder::limits lims = { + bytecode_end, + pre_context, + rule_length, + silf.numClasses(), + face.glyphs().numAttrs(), + face.numFeatures(), + {1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,255, + 1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0, silf.numUser()} + }; + + decoder dec(lims, *this, pt); + if(!dec.load(bytecode_begin, bytecode_end)) + return; + + // Is this an empty program? + if (_instr_count == 0) + { + release_buffers(); + ::new (this) Code(); + return; + } + + // When we reach the end check we've terminated it correctly + if (!is_return(_code[_instr_count-1])) { + failure(missing_return); + return; + } + + assert((_constraint && immutable()) || !_constraint); + dec.apply_analysis(_code, _code + _instr_count); + _max_ref = dec.max_ref(); + + // Now we know exactly how much code and data the program really needs + // realloc the buffers to exactly the right size so we don't waste any + // memory. + assert((bytecode_end - bytecode_begin) >= ptrdiff_t(_instr_count)); + assert((bytecode_end - bytecode_begin) >= ptrdiff_t(_data_size)); + memmove(_code + (_instr_count+1), _data, _data_size*sizeof(byte)); + size_t const total_sz = ((_instr_count+1) + (_data_size + sizeof(instr)-1)/sizeof(instr))*sizeof(instr); + if (_out) + *_out += total_sz; + else + { + instr * const old_code = _code; + _code = static_cast<instr *>(realloc(_code, total_sz)); + if (!_code) free(old_code); + } + _data = reinterpret_cast<byte *>(_code + (_instr_count+1)); + + if (!_code) + { + failure(alloc_failed); + return; + } + + // Make this RET_ZERO, we should never reach this but just in case ... + _code[_instr_count] = op_to_fn[RET_ZERO].impl[_constraint]; + +#ifdef GRAPHITE2_TELEMETRY + telemetry::count_bytes(_data_size + (_instr_count+1)*sizeof(instr)); +#endif +} + +Machine::Code::~Code() throw () +{ + if (_own) + release_buffers(); +} + + +bool Machine::Code::decoder::load(const byte * bc, const byte * bc_end) +{ + _max.bytecode = bc_end; + while (bc < bc_end) + { + const opcode opc = fetch_opcode(bc++); + if (opc == vm::MAX_OPCODE) + return false; + + analyse_opcode(opc, reinterpret_cast<const int8 *>(bc)); + + if (!emit_opcode(opc, bc)) + return false; + } + + return bool(_code); +} + +// Validation check and fixups. +// + +opcode Machine::Code::decoder::fetch_opcode(const byte * bc) +{ + const byte opc = *bc++; + + // Do some basic sanity checks based on what we know about the opcode + if (!validate_opcode(opc, bc)) return MAX_OPCODE; + + // And check its arguments as far as possible + switch (opcode(opc)) + { + case NOP : + break; + case PUSH_BYTE : + case PUSH_BYTEU : + case PUSH_SHORT : + case PUSH_SHORTU : + case PUSH_LONG : + ++_stack_depth; + break; + case ADD : + case SUB : + case MUL : + case DIV : + case MIN_ : + case MAX_ : + case AND : + case OR : + case EQUAL : + case NOT_EQ : + case LESS : + case GTR : + case LESS_EQ : + case GTR_EQ : + case BITOR : + case BITAND : + if (--_stack_depth <= 0) + failure(underfull_stack); + break; + case NEG : + case TRUNC8 : + case TRUNC16 : + case NOT : + case BITNOT : + case BITSET : + if (_stack_depth <= 0) + failure(underfull_stack); + break; + case COND : + _stack_depth -= 2; + if (_stack_depth <= 0) + failure(underfull_stack); + break; + case NEXT_N : // runtime checked + break; + case NEXT : + case COPY_NEXT : + ++_out_index; + if (_out_index < -1 || _out_index > _out_length || _slotref > _max.rule_length) + failure(out_of_range_data); + break; + case PUT_GLYPH_8BIT_OBS : + valid_upto(_max.classes, bc[0]); + test_context(); + break; + case PUT_SUBS_8BIT_OBS : + test_ref(int8(bc[0])); + valid_upto(_max.classes, bc[1]); + valid_upto(_max.classes, bc[2]); + test_context(); + break; + case PUT_COPY : + test_ref(int8(bc[0])); + test_context(); + break; + case INSERT : + if (_passtype >= PASS_TYPE_POSITIONING) + failure(invalid_opcode); + ++_out_length; + if (_out_index < 0) ++_out_index; + if (_out_index < -1 || _out_index >= _out_length) + failure(out_of_range_data); + break; + case DELETE : + if (_passtype >= PASS_TYPE_POSITIONING) + failure(invalid_opcode); + if (_out_index < _max.pre_context) + failure(out_of_range_data); + --_out_index; + --_out_length; + if (_out_index < -1 || _out_index > _out_length) + failure(out_of_range_data); + break; + case ASSOC : + if (bc[0] == 0) + failure(out_of_range_data); + for (uint8 num = bc[0]; num; --num) + test_ref(int8(bc[num])); + test_context(); + break; + case CNTXT_ITEM : + valid_upto(_max.rule_length, _max.pre_context + int8(bc[0])); + if (bc + 2 + bc[1] >= _max.bytecode) failure(jump_past_end); + if (_in_ctxt_item) failure(nested_context_item); + break; + case ATTR_SET : + case ATTR_ADD : + case ATTR_SUB : + case ATTR_SET_SLOT : + if (--_stack_depth < 0) + failure(underfull_stack); + valid_upto(gr_slatMax, bc[0]); + if (attrCode(bc[0]) == gr_slatUserDefn) // use IATTR for user attributes + failure(out_of_range_data); + test_attr(attrCode(bc[0])); + test_context(); + break; + case IATTR_SET_SLOT : + if (--_stack_depth < 0) + failure(underfull_stack); + if (valid_upto(gr_slatMax, bc[0])) + valid_upto(_max.attrid[bc[0]], bc[1]); + test_attr(attrCode(bc[0])); + test_context(); + break; + case PUSH_SLOT_ATTR : + ++_stack_depth; + valid_upto(gr_slatMax, bc[0]); + test_ref(int8(bc[1])); + if (attrCode(bc[0]) == gr_slatUserDefn) // use IATTR for user attributes + failure(out_of_range_data); + test_attr(attrCode(bc[0])); + break; + case PUSH_GLYPH_ATTR_OBS : + case PUSH_ATT_TO_GATTR_OBS : + ++_stack_depth; + valid_upto(_max.glyf_attrs, bc[0]); + test_ref(int8(bc[1])); + break; + case PUSH_ATT_TO_GLYPH_METRIC : + case PUSH_GLYPH_METRIC : + ++_stack_depth; + valid_upto(kgmetDescent, bc[0]); + test_ref(int8(bc[1])); + // level: dp[2] no check necessary + break; + case PUSH_FEAT : + ++_stack_depth; + valid_upto(_max.features, bc[0]); + test_ref(int8(bc[1])); + break; + case PUSH_ISLOT_ATTR : + ++_stack_depth; + if (valid_upto(gr_slatMax, bc[0])) + { + test_ref(int8(bc[1])); + valid_upto(_max.attrid[bc[0]], bc[2]); + } + test_attr(attrCode(bc[0])); + break; + case PUSH_IGLYPH_ATTR :// not implemented + ++_stack_depth; + break; + case POP_RET : + if (--_stack_depth < 0) + failure(underfull_stack); + GR_FALLTHROUGH; + // no break + case RET_ZERO : + case RET_TRUE : + break; + case IATTR_SET : + case IATTR_ADD : + case IATTR_SUB : + if (--_stack_depth < 0) + failure(underfull_stack); + if (valid_upto(gr_slatMax, bc[0])) + valid_upto(_max.attrid[bc[0]], bc[1]); + test_attr(attrCode(bc[0])); + test_context(); + break; + case PUSH_PROC_STATE : // dummy: dp[0] no check necessary + case PUSH_VERSION : + ++_stack_depth; + break; + case PUT_SUBS : + test_ref(int8(bc[0])); + valid_upto(_max.classes, uint16(bc[1]<< 8) | bc[2]); + valid_upto(_max.classes, uint16(bc[3]<< 8) | bc[4]); + test_context(); + break; + case PUT_SUBS2 : // not implemented + case PUT_SUBS3 : // not implemented + break; + case PUT_GLYPH : + valid_upto(_max.classes, uint16(bc[0]<< 8) | bc[1]); + test_context(); + break; + case PUSH_GLYPH_ATTR : + case PUSH_ATT_TO_GLYPH_ATTR : + ++_stack_depth; + valid_upto(_max.glyf_attrs, uint16(bc[0]<< 8) | bc[1]); + test_ref(int8(bc[2])); + break; + case SET_FEAT : + valid_upto(_max.features, bc[0]); + test_ref(int8(bc[1])); + break; + default: + failure(invalid_opcode); + break; + } + + return bool(_code) ? opcode(opc) : MAX_OPCODE; +} + + +void Machine::Code::decoder::analyse_opcode(const opcode opc, const int8 * arg) throw() +{ + switch (opc) + { + case DELETE : + _code._delete = true; + break; + case ASSOC : + set_changed(0); +// for (uint8 num = arg[0]; num; --num) +// _analysis.set_noref(num); + break; + case PUT_GLYPH_8BIT_OBS : + case PUT_GLYPH : + _code._modify = true; + set_changed(0); + break; + case ATTR_SET : + case ATTR_ADD : + case ATTR_SUB : + case ATTR_SET_SLOT : + case IATTR_SET_SLOT : + case IATTR_SET : + case IATTR_ADD : + case IATTR_SUB : + set_noref(0); + break; + case NEXT : + case COPY_NEXT : + ++_slotref; + _contexts[_slotref] = context(uint8(_code._instr_count+1)); + // if (_analysis.slotref > _analysis.max_ref) _analysis.max_ref = _analysis.slotref; + break; + case INSERT : + if (_slotref >= 0) --_slotref; + _code._modify = true; + break; + case PUT_SUBS_8BIT_OBS : // slotref on 1st parameter + case PUT_SUBS : + _code._modify = true; + set_changed(0); + GR_FALLTHROUGH; + // no break + case PUT_COPY : + if (arg[0] != 0) { set_changed(0); _code._modify = true; } + set_ref(arg[0]); + break; + case PUSH_GLYPH_ATTR_OBS : + case PUSH_SLOT_ATTR : + case PUSH_GLYPH_METRIC : + case PUSH_ATT_TO_GATTR_OBS : + case PUSH_ATT_TO_GLYPH_METRIC : + case PUSH_ISLOT_ATTR : + case PUSH_FEAT : + case SET_FEAT : + set_ref(arg[1]); + break; + case PUSH_ATT_TO_GLYPH_ATTR : + case PUSH_GLYPH_ATTR : + set_ref(arg[2]); + break; + default: + break; + } +} + + +bool Machine::Code::decoder::emit_opcode(opcode opc, const byte * & bc) +{ + const opcode_t * op_to_fn = Machine::getOpcodeTable(); + const opcode_t & op = op_to_fn[opc]; + if (op.impl[_code._constraint] == 0) + { + failure(unimplemented_opcode_used); + return false; + } + + const size_t param_sz = op.param_sz == VARARGS ? bc[0] + 1 : op.param_sz; + + // Add this instruction + *_instr++ = op.impl[_code._constraint]; + ++_code._instr_count; + + // Grab the parameters + if (param_sz) { + memcpy(_data, bc, param_sz * sizeof(byte)); + bc += param_sz; + _data += param_sz; + _code._data_size += param_sz; + } + + // recursively decode a context item so we can split the skip into + // instruction and data portions. + if (opc == CNTXT_ITEM) + { + assert(_out_index == 0); + _in_ctxt_item = true; + _out_index = _max.pre_context + int8(_data[-2]); + _slotref = int8(_data[-2]); + _out_length = _max.rule_length; + + const size_t ctxt_start = _code._instr_count; + byte & instr_skip = _data[-1]; + byte & data_skip = *_data++; + ++_code._data_size; + const byte *curr_end = _max.bytecode; + + if (load(bc, bc + instr_skip)) + { + bc += instr_skip; + data_skip = instr_skip - byte(_code._instr_count - ctxt_start); + instr_skip = byte(_code._instr_count - ctxt_start); + _max.bytecode = curr_end; + + _out_length = 1; + _out_index = 0; + _slotref = 0; + _in_ctxt_item = false; + } + else + { + _out_index = 0; + _slotref = 0; + return false; + } + } + + return bool(_code); +} + + +void Machine::Code::decoder::apply_analysis(instr * const code, instr * code_end) +{ + // insert TEMP_COPY commands for slots that need them (that change and are referenced later) + int tempcount = 0; + if (_code._constraint) return; + + const instr temp_copy = Machine::getOpcodeTable()[TEMP_COPY].impl[0]; + for (const context * c = _contexts, * const ce = c + _slotref; c < ce; ++c) + { + if (!c->flags.referenced || !c->flags.changed) continue; + + instr * const tip = code + c->codeRef + tempcount; + memmove(tip+1, tip, (code_end - tip) * sizeof(instr)); + *tip = temp_copy; + ++code_end; + ++tempcount; + _code._delete = true; + } + + _code._instr_count = code_end - code; +} + + +inline +bool Machine::Code::decoder::validate_opcode(const byte opc, const byte * const bc) +{ + if (opc >= MAX_OPCODE) + { + failure(invalid_opcode); + return false; + } + const opcode_t & op = Machine::getOpcodeTable()[opc]; + if (op.impl[_code._constraint] == 0) + { + failure(unimplemented_opcode_used); + return false; + } + if (op.param_sz == VARARGS && bc >= _max.bytecode) + { + failure(arguments_exhausted); + return false; + } + const size_t param_sz = op.param_sz == VARARGS ? bc[0] + 1 : op.param_sz; + if (bc - 1 + param_sz >= _max.bytecode) + { + failure(arguments_exhausted); + return false; + } + return true; +} + + +bool Machine::Code::decoder::valid_upto(const uint16 limit, const uint16 x) const throw() +{ + const bool t = (limit != 0) && (x < limit); + if (!t) failure(out_of_range_data); + return t; +} + +inline +bool Machine::Code::decoder::test_ref(int8 index) const throw() +{ + if (_code._constraint && !_in_ctxt_item) + { + if (index > 0 || -index > _max.pre_context) + { + failure(out_of_range_data); + return false; + } + } + else + { + if (_max.rule_length == 0 + || (_slotref + _max.pre_context + index >= _max.rule_length) + || (_slotref + _max.pre_context + index < 0)) + { + failure(out_of_range_data); + return false; + } + } + return true; +} + +bool Machine::Code::decoder::test_context() const throw() +{ + if (_out_index >= _out_length || _out_index < 0 || _slotref >= NUMCONTEXTS - 1) + { + failure(out_of_range_data); + return false; + } + return true; +} + +bool Machine::Code::decoder::test_attr(attrCode) const throw() +{ +#if 0 // This code is coming but causes backward compatibility problems. + if (_passtype < PASS_TYPE_POSITIONING) + { + if (attr != gr_slatBreak && attr != gr_slatDir && attr != gr_slatUserDefn + && attr != gr_slatCompRef) + { + failure(out_of_range_data); + return false; + } + } +#endif + return true; +} + +inline +void Machine::Code::failure(const status_t s) throw() { + release_buffers(); + _status = s; +} + + +inline +void Machine::Code::decoder::set_ref(int index) throw() { + if (index + _slotref < 0 || index + _slotref >= NUMCONTEXTS) return; + _contexts[index + _slotref].flags.referenced = true; + if (index + _slotref > _max_ref) _max_ref = index + _slotref; +} + + +inline +void Machine::Code::decoder::set_noref(int index) throw() { + if (index + _slotref < 0 || index + _slotref >= NUMCONTEXTS) return; + if (index + _slotref > _max_ref) _max_ref = index + _slotref; +} + + +inline +void Machine::Code::decoder::set_changed(int index) throw() { + if (index + _slotref < 0 || index + _slotref >= NUMCONTEXTS) return; + _contexts[index + _slotref].flags.changed= true; + if (index + _slotref > _max_ref) _max_ref = index + _slotref; +} + + +void Machine::Code::release_buffers() throw() +{ + if (_own) + free(_code); + _code = 0; + _data = 0; + _own = false; +} + + +int32 Machine::Code::run(Machine & m, slotref * & map) const +{ +// assert(_own); + assert(*this); // Check we are actually runnable + + if (m.slotMap().size() <= size_t(_max_ref + m.slotMap().context()) + || m.slotMap()[_max_ref + m.slotMap().context()] == 0) + { + m._status = Machine::slot_offset_out_bounds; + return 1; +// return m.run(_code, _data, map); + } + + return m.run(_code, _data, map); +} diff --git a/gfx/graphite2/src/Collider.cpp b/gfx/graphite2/src/Collider.cpp new file mode 100644 index 0000000000..1929b39a58 --- /dev/null +++ b/gfx/graphite2/src/Collider.cpp @@ -0,0 +1,1115 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <algorithm> +#include <limits> +#include <cmath> +#include <string> +#include <functional> +#include "inc/Collider.h" +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/GlyphCache.h" +#include "inc/Sparse.h" + +#define ISQRT2 0.707106781f + +// Possible rounding error for subbox boundaries: 0.016 = 1/64 = 1/256 * 4 +// (values in font range from 0..256) +// #define SUBBOX_RND_ERR 0.016 + +using namespace graphite2; + +//// SHIFT-COLLIDER //// + +// Initialize the Collider to hold the basic movement limits for the +// target slot, the one we are focusing on fixing. +bool ShiftCollider::initSlot(Segment *seg, Slot *aSlot, const Rect &limit, float margin, float marginWeight, + const Position &currShift, const Position &currOffset, int dir, GR_MAYBE_UNUSED json * const dbgout) +{ + int i; + float mx, mn; + float a, shift; + const GlyphCache &gc = seg->getFace()->glyphs(); + unsigned short gid = aSlot->gid(); + if (!gc.check(gid)) + return false; + const BBox &bb = gc.getBoundingBBox(gid); + const SlantBox &sb = gc.getBoundingSlantBox(gid); + //float sx = aSlot->origin().x + currShift.x; + //float sy = aSlot->origin().y + currShift.y; + if (currOffset.x != 0.f || currOffset.y != 0.f) + _limit = Rect(limit.bl - currOffset, limit.tr - currOffset); + else + _limit = limit; + // For a ShiftCollider, these indices indicate which vector we are moving by: + // each _ranges represents absolute space with respect to the origin of the slot. Thus take into account true origins but subtract the vmin for the slot + for (i = 0; i < 4; ++i) + { + switch (i) { + case 0 : // x direction + mn = _limit.bl.x + currOffset.x; + mx = _limit.tr.x + currOffset.x; + _len[i] = bb.xa - bb.xi; + a = currOffset.y + currShift.y; + _ranges[i].initialise<XY>(mn, mx, margin, marginWeight, a); + break; + case 1 : // y direction + mn = _limit.bl.y + currOffset.y; + mx = _limit.tr.y + currOffset.y; + _len[i] = bb.ya - bb.yi; + a = currOffset.x + currShift.x; + _ranges[i].initialise<XY>(mn, mx, margin, marginWeight, a); + break; + case 2 : // sum (negatively sloped diagonal boundaries) + // pick closest x,y limit boundaries in s direction + shift = currOffset.x + currOffset.y + currShift.x + currShift.y; + mn = -2 * min(currShift.x - _limit.bl.x, currShift.y - _limit.bl.y) + shift; + mx = 2 * min(_limit.tr.x - currShift.x, _limit.tr.y - currShift.y) + shift; + _len[i] = sb.sa - sb.si; + a = currOffset.x - currOffset.y + currShift.x - currShift.y; + _ranges[i].initialise<SD>(mn, mx, margin / ISQRT2, marginWeight, a); + break; + case 3 : // diff (positively sloped diagonal boundaries) + // pick closest x,y limit boundaries in d direction + shift = currOffset.x - currOffset.y + currShift.x - currShift.y; + mn = -2 * min(currShift.x - _limit.bl.x, _limit.tr.y - currShift.y) + shift; + mx = 2 * min(_limit.tr.x - currShift.x, currShift.y - _limit.bl.y) + shift; + _len[i] = sb.da - sb.di; + a = currOffset.x + currOffset.y + currShift.x + currShift.y; + _ranges[i].initialise<SD>(mn, mx, margin / ISQRT2, marginWeight, a); + break; + } + } + + _target = aSlot; + if ((dir & 1) == 0) + { + // For LTR, switch and negate x limits. + _limit.bl.x = -1 * limit.tr.x; + //_limit.tr.x = -1 * limit.bl.x; + } + _currOffset = currOffset; + _currShift = currShift; + _origin = aSlot->origin() - currOffset; // the original anchor position of the glyph + + _margin = margin; + _marginWt = marginWeight; + + SlotCollision *c = seg->collisionInfo(aSlot); + _seqClass = c->seqClass(); + _seqProxClass = c->seqProxClass(); + _seqOrder = c->seqOrder(); + return true; +} + +template <class O> +float sdm(float vi, float va, float mx, float my, O op) +{ + float res = 2 * mx - vi; + if (op(res, vi + 2 * my)) + { + res = va + 2 * my; + if (op(res, 2 * mx - va)) + res = mx + my; + } + return res; +} + +// Mark an area with a cost that can vary along the x or y axis. The region is expressed in terms of the centre of the target glyph in each axis +void ShiftCollider::addBox_slope(bool isx, const Rect &box, const BBox &bb, const SlantBox &sb, const Position &org, float weight, float m, bool minright, int axis) +{ + float a, c; + switch (axis) { + case 0 : + if (box.bl.y < org.y + bb.ya && box.tr.y > org.y + bb.yi && box.width() > 0) + { + a = org.y + 0.5f * (bb.yi + bb.ya); + c = 0.5f * (bb.xi + bb.xa); + if (isx) + _ranges[axis].weighted<XY>(box.bl.x - c, box.tr.x - c, weight, a, m, + (minright ? box.tr.x : box.bl.x) - c, a, 0, false); + else + _ranges[axis].weighted<XY>(box.bl.x - c, box.tr.x - c, weight, a, 0, 0, org.y, + m * (a * a + sqr((minright ? box.tr.y : box.bl.y) - 0.5f * (bb.yi + bb.ya))), false); + } + break; + case 1 : + if (box.bl.x < org.x + bb.xa && box.tr.x > org.x + bb.xi && box.height() > 0) + { + a = org.x + 0.5f * (bb.xi + bb.xa); + c = 0.5f * (bb.yi + bb.ya); + if (isx) + _ranges[axis].weighted<XY>(box.bl.y - c, box.tr.y - c, weight, a, 0, 0, org.x, + m * (a * a + sqr((minright ? box.tr.x : box.bl.x) - 0.5f * (bb.xi + bb.xa))), false); + else + _ranges[axis].weighted<XY>(box.bl.y - c, box.tr.y - c, weight, a, m, + (minright ? box.tr.y : box.bl.y) - c, a, 0, false); + } + break; + case 2 : + if (box.bl.x - box.tr.y < org.x - org.y + sb.da && box.tr.x - box.bl.y > org.x - org.y + sb.di) + { + float d = org.x - org.y + 0.5f * (sb.di + sb.da); + c = 0.5f * (sb.si + sb.sa); + float smax = min(2 * box.tr.x - d, 2 * box.tr.y + d); + float smin = max(2 * box.bl.x - d, 2 * box.bl.y + d); + if (smin > smax) return; + float si; + a = d; + if (isx) + si = 2 * (minright ? box.tr.x : box.bl.x) - a; + else + si = 2 * (minright ? box.tr.y : box.bl.y) + a; + _ranges[axis].weighted<SD>(smin - c, smax - c, weight / 2, a, m / 2, si, 0, 0, isx); + } + break; + case 3 : + if (box.bl.x + box.bl.y < org.x + org.y + sb.sa && box.tr.x + box.tr.y > org.x + org.y + sb.si) + { + float s = org.x + org.y + 0.5f * (sb.si + sb.sa); + c = 0.5f * (sb.di + sb.da); + float dmax = min(2 * box.tr.x - s, s - 2 * box.bl.y); + float dmin = max(2 * box.bl.x - s, s - 2 * box.tr.y); + if (dmin > dmax) return; + float di; + a = s; + if (isx) + di = 2 * (minright ? box.tr.x : box.bl.x) - a; + else + di = 2 * (minright ? box.tr.y : box.bl.y) + a; + _ranges[axis].weighted<SD>(dmin - c, dmax - c, weight / 2, a, m / 2, di, 0, 0, !isx); + } + break; + default : + break; + } + return; +} + +// Mark an area with an absolute cost, making it completely inaccessible. +inline void ShiftCollider::removeBox(const Rect &box, const BBox &bb, const SlantBox &sb, const Position &org, int axis) +{ + float c; + switch (axis) { + case 0 : + if (box.bl.y < org.y + bb.ya && box.tr.y > org.y + bb.yi && box.width() > 0) + { + c = 0.5f * (bb.xi + bb.xa); + _ranges[axis].exclude(box.bl.x - c, box.tr.x - c); + } + break; + case 1 : + if (box.bl.x < org.x + bb.xa && box.tr.x > org.x + bb.xi && box.height() > 0) + { + c = 0.5f * (bb.yi + bb.ya); + _ranges[axis].exclude(box.bl.y - c, box.tr.y - c); + } + break; + case 2 : + if (box.bl.x - box.tr.y < org.x - org.y + sb.da && box.tr.x - box.bl.y > org.x - org.y + sb.di + && box.width() > 0 && box.height() > 0) + { + float di = org.x - org.y + sb.di; + float da = org.x - org.y + sb.da; + float smax = sdm(di, da, box.tr.x, box.tr.y, std::greater<float>()); + float smin = sdm(da, di, box.bl.x, box.bl.y, std::less<float>()); + c = 0.5f * (sb.si + sb.sa); + _ranges[axis].exclude(smin - c, smax - c); + } + break; + case 3 : + if (box.bl.x + box.bl.y < org.x + org.y + sb.sa && box.tr.x + box.tr.y > org.x + org.y + sb.si + && box.width() > 0 && box.height() > 0) + { + float si = org.x + org.y + sb.si; + float sa = org.x + org.y + sb.sa; + float dmax = sdm(si, sa, box.tr.x, -box.bl.y, std::greater<float>()); + float dmin = sdm(sa, si, box.bl.x, -box.tr.y, std::less<float>()); + c = 0.5f * (sb.di + sb.da); + _ranges[axis].exclude(dmin - c, dmax - c); + } + break; + default : + break; + } + return; +} + +// Adjust the movement limits for the target to avoid having it collide +// with the given neighbor slot. Also determine if there is in fact a collision +// between the target and the given slot. +bool ShiftCollider::mergeSlot(Segment *seg, Slot *slot, const SlotCollision *cslot, const Position &currShift, + bool isAfter, // slot is logically after _target + bool sameCluster, bool &hasCol, bool isExclusion, + GR_MAYBE_UNUSED json * const dbgout ) +{ + bool isCol = false; + const float sx = slot->origin().x - _origin.x + currShift.x; + const float sy = slot->origin().y - _origin.y + currShift.y; + const float sd = sx - sy; + const float ss = sx + sy; + float vmin, vmax; + float omin, omax, otmin, otmax; + float cmin, cmax; // target limits + float torg; + const GlyphCache &gc = seg->getFace()->glyphs(); + const unsigned short gid = slot->gid(); + if (!gc.check(gid)) + return false; + const BBox &bb = gc.getBoundingBBox(gid); + + // SlotCollision * cslot = seg->collisionInfo(slot); + int orderFlags = 0; + bool sameClass = _seqProxClass == 0 && cslot->seqClass() == _seqClass; + if (sameCluster && _seqClass + && (sameClass || (_seqProxClass != 0 && cslot->seqClass() == _seqProxClass))) + // Force the target glyph to be in the specified direction from the slot we're testing. + orderFlags = _seqOrder; + + // short circuit if only interested in direct collision and we are out of range + if (orderFlags || (sx + bb.xa + _margin >= _limit.bl.x && sx + bb.xi - _margin <= _limit.tr.x) + || (sy + bb.ya + _margin >= _limit.bl.y && sy + bb.yi - _margin <= _limit.tr.y)) + + { + const float tx = _currOffset.x + _currShift.x; + const float ty = _currOffset.y + _currShift.y; + const float td = tx - ty; + const float ts = tx + ty; + const SlantBox &sb = gc.getBoundingSlantBox(gid); + const unsigned short tgid = _target->gid(); + const BBox &tbb = gc.getBoundingBBox(tgid); + const SlantBox &tsb = gc.getBoundingSlantBox(tgid); + float seq_above_wt = cslot->seqAboveWt(); + float seq_below_wt = cslot->seqBelowWt(); + float seq_valign_wt = cslot->seqValignWt(); + float lmargin; + // if isAfter, invert orderFlags for diagonal orders. + if (isAfter) + { + // invert appropriate bits + orderFlags ^= (sameClass ? 0x3F : 0x3); + // consider 2 bits at a time, non overlapping. If both bits set, clear them + orderFlags = orderFlags ^ ((((orderFlags >> 1) & orderFlags) & 0x15) * 3); + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + dbgout->setenv(0, slot); +#endif + + // Process main bounding octabox. + for (int i = 0; i < 4; ++i) + { + switch (i) { + case 0 : // x direction + vmin = max(max(bb.xi - tbb.xa + sx, sb.di - tsb.da + ty + sd), sb.si - tsb.sa - ty + ss); + vmax = min(min(bb.xa - tbb.xi + sx, sb.da - tsb.di + ty + sd), sb.sa - tsb.si - ty + ss); + otmin = tbb.yi + ty; + otmax = tbb.ya + ty; + omin = bb.yi + sy; + omax = bb.ya + sy; + torg = _currOffset.x; + cmin = _limit.bl.x + torg; + cmax = _limit.tr.x - tbb.xi + tbb.xa + torg; + lmargin = _margin; + break; + case 1 : // y direction + vmin = max(max(bb.yi - tbb.ya + sy, tsb.di - sb.da + tx - sd), sb.si - tsb.sa - tx + ss); + vmax = min(min(bb.ya - tbb.yi + sy, tsb.da - sb.di + tx - sd), sb.sa - tsb.si - tx + ss); + otmin = tbb.xi + tx; + otmax = tbb.xa + tx; + omin = bb.xi + sx; + omax = bb.xa + sx; + torg = _currOffset.y; + cmin = _limit.bl.y + torg; + cmax = _limit.tr.y - tbb.yi + tbb.ya + torg; + lmargin = _margin; + break; + case 2 : // sum - moving along the positively-sloped vector, so the boundaries are the + // negatively-sloped boundaries. + vmin = max(max(sb.si - tsb.sa + ss, 2 * (bb.yi - tbb.ya + sy) + td), 2 * (bb.xi - tbb.xa + sx) - td); + vmax = min(min(sb.sa - tsb.si + ss, 2 * (bb.ya - tbb.yi + sy) + td), 2 * (bb.xa - tbb.xi + sx) - td); + otmin = tsb.di + td; + otmax = tsb.da + td; + omin = sb.di + sd; + omax = sb.da + sd; + torg = _currOffset.x + _currOffset.y; + cmin = _limit.bl.x + _limit.bl.y + torg; + cmax = _limit.tr.x + _limit.tr.y - tsb.si + tsb.sa + torg; + lmargin = _margin / ISQRT2; + break; + case 3 : // diff - moving along the negatively-sloped vector, so the boundaries are the + // positively-sloped boundaries. + vmin = max(max(sb.di - tsb.da + sd, 2 * (bb.xi - tbb.xa + sx) - ts), -2 * (bb.ya - tbb.yi + sy) + ts); + vmax = min(min(sb.da - tsb.di + sd, 2 * (bb.xa - tbb.xi + sx) - ts), -2 * (bb.yi - tbb.ya + sy) + ts); + otmin = tsb.si + ts; + otmax = tsb.sa + ts; + omin = sb.si + ss; + omax = sb.sa + ss; + torg = _currOffset.x - _currOffset.y; + cmin = _limit.bl.x - _limit.tr.y + torg; + cmax = _limit.tr.x - _limit.bl.y - tsb.di + tsb.da + torg; + lmargin = _margin / ISQRT2; + break; + default : + continue; + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + dbgout->setenv(1, reinterpret_cast<void *>(-1)); +#define DBGTAG(x) if (dbgout) dbgout->setenv(1, reinterpret_cast<void *>(-x)); +#else +#define DBGTAG(x) +#endif + + if (orderFlags) + { + Position org(tx, ty); + float xminf = _limit.bl.x + _currOffset.x + tbb.xi; + float xpinf = _limit.tr.x + _currOffset.x + tbb.xa; + float ypinf = _limit.tr.y + _currOffset.y + tbb.ya; + float yminf = _limit.bl.y + _currOffset.y + tbb.yi; + switch (orderFlags) { + case SlotCollision::SEQ_ORDER_RIGHTUP : + { + float r1Xedge = cslot->seqAboveXoff() + 0.5f * (bb.xi + bb.xa) + sx; + float r3Xedge = cslot->seqBelowXlim() + bb.xa + sx + 0.5f * (tbb.xa - tbb.xi); + float r2Yedge = 0.5f * (bb.yi + bb.ya) + sy; + + // DBGTAG(1x) means the regions are up and right + // region 1 + DBGTAG(11) + addBox_slope(true, Rect(Position(xminf, r2Yedge), Position(r1Xedge, ypinf)), + tbb, tsb, org, 0, seq_above_wt, true, i); + // region 2 + DBGTAG(12) + removeBox(Rect(Position(xminf, yminf), Position(r3Xedge, r2Yedge)), tbb, tsb, org, i); + // region 3, which end is zero is irrelevant since m weight is 0 + DBGTAG(13) + addBox_slope(true, Rect(Position(r3Xedge, yminf), Position(xpinf, r2Yedge - cslot->seqValignHt())), + tbb, tsb, org, seq_below_wt, 0, true, i); + // region 4 + DBGTAG(14) + addBox_slope(false, Rect(Position(sx + bb.xi, r2Yedge), Position(xpinf, r2Yedge + cslot->seqValignHt())), + tbb, tsb, org, 0, seq_valign_wt, true, i); + // region 5 + DBGTAG(15) + addBox_slope(false, Rect(Position(sx + bb.xi, r2Yedge - cslot->seqValignHt()), Position(xpinf, r2Yedge)), + tbb, tsb, org, seq_below_wt, seq_valign_wt, false, i); + break; + } + case SlotCollision::SEQ_ORDER_LEFTDOWN : + { + float r1Xedge = 0.5f * (bb.xi + bb.xa) + cslot->seqAboveXoff() + sx; + float r3Xedge = bb.xi - cslot->seqBelowXlim() + sx - 0.5f * (tbb.xa - tbb.xi); + float r2Yedge = 0.5f * (bb.yi + bb.ya) + sy; + // DBGTAG(2x) means the regions are up and right + // region 1 + DBGTAG(21) + addBox_slope(true, Rect(Position(r1Xedge, yminf), Position(xpinf, r2Yedge)), + tbb, tsb, org, 0, seq_above_wt, false, i); + // region 2 + DBGTAG(22) + removeBox(Rect(Position(r3Xedge, r2Yedge), Position(xpinf, ypinf)), tbb, tsb, org, i); + // region 3 + DBGTAG(23) + addBox_slope(true, Rect(Position(xminf, r2Yedge - cslot->seqValignHt()), Position(r3Xedge, ypinf)), + tbb, tsb, org, seq_below_wt, 0, false, i); + // region 4 + DBGTAG(24) + addBox_slope(false, Rect(Position(xminf, r2Yedge), Position(sx + bb.xa, r2Yedge + cslot->seqValignHt())), + tbb, tsb, org, 0, seq_valign_wt, true, i); + // region 5 + DBGTAG(25) + addBox_slope(false, Rect(Position(xminf, r2Yedge - cslot->seqValignHt()), + Position(sx + bb.xa, r2Yedge)), tbb, tsb, org, seq_below_wt, seq_valign_wt, false, i); + break; + } + case SlotCollision::SEQ_ORDER_NOABOVE : // enforce neighboring glyph being above + DBGTAG(31); + removeBox(Rect(Position(bb.xi - tbb.xa + sx, sy + bb.ya), + Position(bb.xa - tbb.xi + sx, ypinf)), tbb, tsb, org, i); + break; + case SlotCollision::SEQ_ORDER_NOBELOW : // enforce neighboring glyph being below + DBGTAG(32); + removeBox(Rect(Position(bb.xi - tbb.xa + sx, yminf), + Position(bb.xa - tbb.xi + sx, sy + bb.yi)), tbb, tsb, org, i); + break; + case SlotCollision::SEQ_ORDER_NOLEFT : // enforce neighboring glyph being to the left + DBGTAG(33) + removeBox(Rect(Position(xminf, bb.yi - tbb.ya + sy), + Position(bb.xi - tbb.xa + sx, bb.ya - tbb.yi + sy)), tbb, tsb, org, i); + break; + case SlotCollision::SEQ_ORDER_NORIGHT : // enforce neighboring glyph being to the right + DBGTAG(34) + removeBox(Rect(Position(bb.xa - tbb.xi + sx, bb.yi - tbb.ya + sy), + Position(xpinf, bb.ya - tbb.yi + sy)), tbb, tsb, org, i); + break; + default : + break; + } + } + + if (vmax < cmin - lmargin || vmin > cmax + lmargin || omax < otmin - lmargin || omin > otmax + lmargin) + continue; + + // Process sub-boxes that are defined for this glyph. + // We only need to do this if there was in fact a collision with the main octabox. + uint8 numsub = gc.numSubBounds(gid); + if (numsub > 0) + { + bool anyhits = false; + for (int j = 0; j < numsub; ++j) + { + const BBox &sbb = gc.getSubBoundingBBox(gid, j); + const SlantBox &ssb = gc.getSubBoundingSlantBox(gid, j); + switch (i) { + case 0 : // x + vmin = max(max(sbb.xi-tbb.xa+sx, ssb.di-tsb.da+sd+ty), ssb.si-tsb.sa+ss-ty); + vmax = min(min(sbb.xa-tbb.xi+sx, ssb.da-tsb.di+sd+ty), ssb.sa-tsb.si+ss-ty); + omin = sbb.yi + sy; + omax = sbb.ya + sy; + break; + case 1 : // y + vmin = max(max(sbb.yi-tbb.ya+sy, tsb.di-ssb.da-sd+tx), ssb.si-tsb.sa+ss-tx); + vmax = min(min(sbb.ya-tbb.yi+sy, tsb.da-ssb.di-sd+tx), ssb.sa-tsb.si+ss-tx); + omin = sbb.xi + sx; + omax = sbb.xa + sx; + break; + case 2 : // sum + vmin = max(max(ssb.si-tsb.sa+ss, 2*(sbb.yi-tbb.ya+sy)+td), 2*(sbb.xi-tbb.xa+sx)-td); + vmax = min(min(ssb.sa-tsb.si+ss, 2*(sbb.ya-tbb.yi+sy)+td), 2*(sbb.xa-tbb.xi+sx)-td); + omin = ssb.di + sd; + omax = ssb.da + sd; + break; + case 3 : // diff + vmin = max(max(ssb.di-tsb.da+sd, 2*(sbb.xi-tbb.xa+sx)-ts), -2*(sbb.ya-tbb.yi+sy)+ts); + vmax = min(min(ssb.da-tsb.di+sd, 2*(sbb.xa-tbb.xi+sx)-ts), -2*(sbb.yi-tbb.ya+sy)+ts); + omin = ssb.si + ss; + omax = ssb.sa + ss; + break; + } + if (vmax < cmin - lmargin || vmin > cmax + lmargin || omax < otmin - lmargin || omin > otmax + lmargin) + continue; + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + dbgout->setenv(1, reinterpret_cast<void *>(j)); +#endif + if (omin > otmax) + _ranges[i].weightedAxis(i, vmin - lmargin, vmax + lmargin, 0, 0, 0, 0, 0, + sqr(lmargin - omin + otmax) * _marginWt, false); + else if (omax < otmin) + _ranges[i].weightedAxis(i, vmin - lmargin, vmax + lmargin, 0, 0, 0, 0, 0, + sqr(lmargin - otmin + omax) * _marginWt, false); + else + _ranges[i].exclude_with_margins(vmin, vmax, i); + anyhits = true; + } + if (anyhits) + isCol = true; + } + else // no sub-boxes + { +#if !defined GRAPHITE2_NTRACING + if (dbgout) + dbgout->setenv(1, reinterpret_cast<void *>(-1)); +#endif + isCol = true; + if (omin > otmax) + _ranges[i].weightedAxis(i, vmin - lmargin, vmax + lmargin, 0, 0, 0, 0, 0, + sqr(lmargin - omin + otmax) * _marginWt, false); + else if (omax < otmin) + _ranges[i].weightedAxis(i, vmin - lmargin, vmax + lmargin, 0, 0, 0, 0, 0, + sqr(lmargin - otmin + omax) * _marginWt, false); + else + _ranges[i].exclude_with_margins(vmin, vmax, i); + + } + } + } + bool res = true; + if (cslot->exclGlyph() > 0 && gc.check(cslot->exclGlyph()) && !isExclusion) + { + // Set up the bogus slot representing the exclusion glyph. + Slot *exclSlot = seg->newSlot(); + if (!exclSlot) + return res; + exclSlot->setGlyph(seg, cslot->exclGlyph()); + Position exclOrigin(slot->origin() + cslot->exclOffset()); + exclSlot->origin(exclOrigin); + SlotCollision exclInfo(seg, exclSlot); + res &= mergeSlot(seg, exclSlot, &exclInfo, currShift, isAfter, sameCluster, isCol, true, dbgout ); + seg->freeSlot(exclSlot); + } + hasCol |= isCol; + return res; + +} // end of ShiftCollider::mergeSlot + + +// Figure out where to move the target glyph to, and return the amount to shift by. +Position ShiftCollider::resolve(GR_MAYBE_UNUSED Segment *seg, bool &isCol, GR_MAYBE_UNUSED json * const dbgout) +{ + float tbase; + float totalCost = (float)(std::numeric_limits<float>::max() / 2); + Position resultPos = Position(0, 0); +#if !defined GRAPHITE2_NTRACING + int bestAxis = -1; + if (dbgout) + { + outputJsonDbgStartSlot(dbgout, seg); + *dbgout << "vectors" << json::array; + } +#endif + isCol = true; + for (int i = 0; i < 4; ++i) + { + float bestCost = -1; + float bestPos; + // Calculate the margin depending on whether we are moving diagonally or not: + switch (i) { + case 0 : // x direction + tbase = _currOffset.x; + break; + case 1 : // y direction + tbase = _currOffset.y; + break; + case 2 : // sum (negatively-sloped diagonals) + tbase = _currOffset.x + _currOffset.y; + break; + case 3 : // diff (positively-sloped diagonals) + tbase = _currOffset.x - _currOffset.y; + break; + } + Position testp; + bestPos = _ranges[i].closest(0, bestCost) - tbase; // Get the best relative position +#if !defined GRAPHITE2_NTRACING + if (dbgout) + outputJsonDbgOneVector(dbgout, seg, i, tbase, bestCost, bestPos) ; +#endif + if (bestCost >= 0.0f) + { + isCol = false; + switch (i) { + case 0 : testp = Position(bestPos, _currShift.y); break; + case 1 : testp = Position(_currShift.x, bestPos); break; + case 2 : testp = Position(0.5f * (_currShift.x - _currShift.y + bestPos), 0.5f * (_currShift.y - _currShift.x + bestPos)); break; + case 3 : testp = Position(0.5f * (_currShift.x + _currShift.y + bestPos), 0.5f * (_currShift.x + _currShift.y - bestPos)); break; + } + if (bestCost < totalCost - 0.01f) + { + totalCost = bestCost; + resultPos = testp; +#if !defined GRAPHITE2_NTRACING + bestAxis = i; +#endif + } + } + } // end of loop over 4 directions + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + outputJsonDbgEndSlot(dbgout, resultPos, bestAxis, isCol); +#endif + + return resultPos; + +} // end of ShiftCollider::resolve + + +#if !defined GRAPHITE2_NTRACING + +void ShiftCollider::outputJsonDbg(json * const dbgout, Segment *seg, int axis) +{ + int axisMax = axis; + if (axis < 0) // output all axes + { + *dbgout << "gid" << _target->gid() + << "limit" << _limit + << "target" << json::object + << "origin" << _target->origin() + << "margin" << _margin + << "bbox" << seg->theGlyphBBoxTemporary(_target->gid()) + << "slantbox" << seg->getFace()->glyphs().slant(_target->gid()) + << json::close; // target object + *dbgout << "ranges" << json::array; + axis = 0; + axisMax = 3; + } + for (int iAxis = axis; iAxis <= axisMax; ++iAxis) + { + *dbgout << json::flat << json::array << _ranges[iAxis].position(); + for (Zones::const_iterator s = _ranges[iAxis].begin(), e = _ranges[iAxis].end(); s != e; ++s) + *dbgout << json::flat << json::array + << Position(s->x, s->xm) << s->sm << s->smx << s->c + << json::close; + *dbgout << json::close; + } + if (axis < axisMax) // looped through the _ranges array for all axes + *dbgout << json::close; // ranges array +} + +void ShiftCollider::outputJsonDbgStartSlot(json * const dbgout, Segment *seg) +{ + *dbgout << json::object // slot - not closed till the end of the caller method + << "slot" << objectid(dslot(seg, _target)) + << "gid" << _target->gid() + << "limit" << _limit + << "target" << json::object + << "origin" << _origin + << "currShift" << _currShift + << "currOffset" << seg->collisionInfo(_target)->offset() + << "bbox" << seg->theGlyphBBoxTemporary(_target->gid()) + << "slantBox" << seg->getFace()->glyphs().slant(_target->gid()) + << "fix" << "shift"; + *dbgout << json::close; // target object +} + +void ShiftCollider::outputJsonDbgEndSlot(GR_MAYBE_UNUSED json * const dbgout, + Position resultPos, int bestAxis, bool isCol) +{ + *dbgout << json::close // vectors array + << "result" << resultPos + //<< "scraping" << _scraping[bestAxis] + << "bestAxis" << bestAxis + << "stillBad" << isCol + << json::close; // slot object +} + +void ShiftCollider::outputJsonDbgOneVector(json * const dbgout, Segment *seg, int axis, + float tleft, float bestCost, float bestVal) +{ + const char * label; + switch (axis) + { + case 0: label = "x"; break; + case 1: label = "y"; break; + case 2: label = "sum (NE-SW)"; break; + case 3: label = "diff (NW-SE)"; break; + default: label = "???"; break; + } + + *dbgout << json::object // vector + << "direction" << label + << "targetMin" << tleft; + + outputJsonDbgRemovals(dbgout, axis, seg); + + *dbgout << "ranges"; + outputJsonDbg(dbgout, seg, axis); + + *dbgout << "bestCost" << bestCost + << "bestVal" << bestVal + tleft + << json::close; // vectors object +} + +void ShiftCollider::outputJsonDbgRemovals(json * const dbgout, int axis, Segment *seg) +{ + *dbgout << "removals" << json::array; + _ranges[axis].jsonDbgOut(seg); + *dbgout << json::close; // removals array +} + +#endif // !defined GRAPHITE2_NTRACING + + +//// KERN-COLLIDER //// + +inline +static float localmax (float al, float au, float bl, float bu, float x) +{ + if (al < bl) + { if (au < bu) return au < x ? au : x; } + else if (au > bu) return bl < x ? bl : x; + return x; +} + +inline +static float localmin(float al, float au, float bl, float bu, float x) +{ + if (bl > al) + { if (bu > au) return bl > x ? bl : x; } + else if (au > bu) return al > x ? al : x; + return x; +} + +// Return the given edge of the glyph at height y, taking any slant box into account. +static float get_edge(Segment *seg, const Slot *s, const Position &shift, float y, float width, float margin, bool isRight) +{ + const GlyphCache &gc = seg->getFace()->glyphs(); + unsigned short gid = s->gid(); + float sx = s->origin().x + shift.x; + float sy = s->origin().y + shift.y; + uint8 numsub = gc.numSubBounds(gid); + float res = isRight ? (float)-1e38 : (float)1e38; + + if (numsub > 0) + { + for (int i = 0; i < numsub; ++i) + { + const BBox &sbb = gc.getSubBoundingBBox(gid, i); + const SlantBox &ssb = gc.getSubBoundingSlantBox(gid, i); + if (sy + sbb.yi - margin > y + width / 2 || sy + sbb.ya + margin < y - width / 2) + continue; + if (isRight) + { + float x = sx + sbb.xa + margin; + if (x > res) + { + float td = sx - sy + ssb.da + margin + y; + float ts = sx + sy + ssb.sa + margin - y; + x = localmax(td - width / 2, td + width / 2, ts - width / 2, ts + width / 2, x); + if (x > res) + res = x; + } + } + else + { + float x = sx + sbb.xi - margin; + if (x < res) + { + float td = sx - sy + ssb.di - margin + y; + float ts = sx + sy + ssb.si - margin - y; + x = localmin(td - width / 2, td + width / 2, ts - width / 2, ts + width / 2, x); + if (x < res) + res = x; + } + } + } + } + else + { + const BBox &bb = gc.getBoundingBBox(gid); + const SlantBox &sb = gc.getBoundingSlantBox(gid); + if (sy + bb.yi - margin > y + width / 2 || sy + bb.ya + margin < y - width / 2) + return res; + float td = sx - sy + y; + float ts = sx + sy - y; + if (isRight) + res = localmax(td + sb.da - width / 2, td + sb.da + width / 2, ts + sb.sa - width / 2, ts + sb.sa + width / 2, sx + bb.xa) + margin; + else + res = localmin(td + sb.di - width / 2, td + sb.di + width / 2, ts + sb.si - width / 2, ts + sb.si + width / 2, sx + bb.xi) - margin; + } + return res; +} + + +bool KernCollider::initSlot(Segment *seg, Slot *aSlot, const Rect &limit, float margin, + const Position &currShift, const Position &offsetPrev, int dir, + float ymin, float ymax, GR_MAYBE_UNUSED json * const dbgout) +{ + const GlyphCache &gc = seg->getFace()->glyphs(); + const Slot *base = aSlot; + // const Slot *last = aSlot; + const Slot *s; + int numSlices; + while (base->attachedTo()) + base = base->attachedTo(); + if (margin < 10) margin = 10; + + _limit = limit; + _offsetPrev = offsetPrev; // kern from a previous pass + + // Calculate the height of the glyph and how many horizontal slices to use. + if (_maxy >= 1e37f) + { + _sliceWidth = margin / 1.5f; + _maxy = ymax + margin; + _miny = ymin - margin; + numSlices = int((_maxy - _miny + 2) / (_sliceWidth / 1.5f) + 1.f); // +2 helps with rounding errors + _edges.clear(); + _edges.insert(_edges.begin(), numSlices, (dir & 1) ? 1e38f : -1e38f); + _xbound = (dir & 1) ? (float)1e38f : (float)-1e38f; + } + else if (_maxy != ymax || _miny != ymin) + { + if (_miny != ymin) + { + numSlices = int((ymin - margin - _miny) / _sliceWidth - 1); + _miny += numSlices * _sliceWidth; + if (numSlices < 0) + _edges.insert(_edges.begin(), -numSlices, (dir & 1) ? 1e38f : -1e38f); + else if ((unsigned)numSlices < _edges.size()) // this shouldn't fire since we always grow the range + { + Vector<float>::iterator e = _edges.begin(); + while (numSlices--) + ++e; + _edges.erase(_edges.begin(), e); + } + } + if (_maxy != ymax) + { + numSlices = int((ymax + margin - _miny) / _sliceWidth + 1); + _maxy = numSlices * _sliceWidth + _miny; + if (numSlices > (int)_edges.size()) + _edges.insert(_edges.end(), numSlices - _edges.size(), (dir & 1) ? 1e38f : -1e38f); + else if (numSlices < (int)_edges.size()) // this shouldn't fire since we always grow the range + { + while ((int)_edges.size() > numSlices) + _edges.pop_back(); + } + } + goto done; + } + numSlices = int(_edges.size()); + +#if !defined GRAPHITE2_NTRACING + // Debugging + _seg = seg; + _slotNear.clear(); + _slotNear.insert(_slotNear.begin(), numSlices, NULL); + _nearEdges.clear(); + _nearEdges.insert(_nearEdges.begin(), numSlices, (dir & 1) ? -1e38f : +1e38f); +#endif + + // Determine the trailing edge of each slice (ie, left edge for a RTL glyph). + for (s = base; s; s = s->nextInCluster(s)) + { + SlotCollision *c = seg->collisionInfo(s); + if (!gc.check(s->gid())) + return false; + const BBox &bs = gc.getBoundingBBox(s->gid()); + float x = s->origin().x + c->shift().x + ((dir & 1) ? bs.xi : bs.xa); + // Loop over slices. + // Note smin might not be zero if glyph s is not at the bottom of the cluster; similarly for smax. + float toffset = c->shift().y - _miny + 1 + s->origin().y; + int smin = max(0, int((bs.yi + toffset) / _sliceWidth)); + int smax = min(numSlices - 1, int((bs.ya + toffset) / _sliceWidth + 1)); + for (int i = smin; i <= smax; ++i) + { + float t; + float y = _miny - 1 + (i + .5f) * _sliceWidth; // vertical center of slice + if ((dir & 1) && x < _edges[i]) + { + t = get_edge(seg, s, c->shift(), y, _sliceWidth, margin, false); + if (t < _edges[i]) + { + _edges[i] = t; + if (t < _xbound) + _xbound = t; + } + } + else if (!(dir & 1) && x > _edges[i]) + { + t = get_edge(seg, s, c->shift(), y, _sliceWidth, margin, true); + if (t > _edges[i]) + { + _edges[i] = t; + if (t > _xbound) + _xbound = t; + } + } + } + } + done: + _mingap = (float)1e37; // less than 1e38 s.t. 1e38-_mingap is really big + _target = aSlot; + _margin = margin; + _currShift = currShift; + return true; +} // end of KernCollider::initSlot + + +// Determine how much the target slot needs to kern away from the given slot. +// In other words, merge information from given slot's position with what the target slot knows +// about how it can kern. +// Return false if we know there is no collision, true if we think there might be one. +bool KernCollider::mergeSlot(Segment *seg, Slot *slot, const Position &currShift, float currSpace, int dir, GR_MAYBE_UNUSED json * const dbgout) +{ + int rtl = (dir & 1) * 2 - 1; + if (!seg->getFace()->glyphs().check(slot->gid())) + return false; + const Rect &bb = seg->theGlyphBBoxTemporary(slot->gid()); + const float sx = slot->origin().x + currShift.x; + float x = (sx + (rtl > 0 ? bb.tr.x : bb.bl.x)) * rtl; + // this isn't going to reduce _mingap so skip + if (_hit && x < rtl * (_xbound - _mingap - currSpace)) + return false; + + const float sy = slot->origin().y + currShift.y; + int smin = max(1, int((bb.bl.y + (1 - _miny + sy)) / _sliceWidth + 1)) - 1; + int smax = min((int)_edges.size() - 2, int((bb.tr.y + (1 - _miny + sy)) / _sliceWidth + 1)) + 1; + if (smin > smax) + return false; + bool collides = false; + bool nooverlap = true; + + for (int i = smin; i <= smax; ++i) + { + float here = _edges[i] * rtl; + if (here > (float)9e37) + continue; + if (!_hit || x > here - _mingap - currSpace) + { + float y = (float)(_miny - 1 + (i + .5f) * _sliceWidth); // vertical center of slice + // 2 * currSpace to account for the space that is already separating them and the space we want to add + float m = get_edge(seg, slot, currShift, y, _sliceWidth, 0., rtl > 0) * rtl + 2 * currSpace; + if (m < (float)-8e37) // only true if the glyph has a gap in it + continue; + nooverlap = false; + float t = here - m; + // _mingap is positive to shrink + if (t < _mingap || (!_hit && !collides)) + { + _mingap = t; + collides = true; + } +#if !defined GRAPHITE2_NTRACING + // Debugging - remember the closest neighboring edge for this slice. + if (m > rtl * _nearEdges[i]) + { + _slotNear[i] = slot; + _nearEdges[i] = m * rtl; + } +#endif + } + else + nooverlap = false; + } + if (nooverlap) + _mingap = max(_mingap, _xbound - rtl * (currSpace + _margin + x)); + if (collides && !nooverlap) + _hit = true; + return collides | nooverlap; // note that true is not a necessarily reliable value + +} // end of KernCollider::mergeSlot + + +// Return the amount to kern by. +Position KernCollider::resolve(GR_MAYBE_UNUSED Segment *seg, GR_MAYBE_UNUSED Slot *slot, + int dir, GR_MAYBE_UNUSED json * const dbgout) +{ + float resultNeeded = (1 - 2 * (dir & 1)) * _mingap; + // float resultNeeded = (1 - 2 * (dir & 1)) * (_mingap - margin); + float result = min(_limit.tr.x - _offsetPrev.x, max(resultNeeded, _limit.bl.x - _offsetPrev.x)); + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + { + *dbgout << json::object // slot + << "slot" << objectid(dslot(seg, _target)) + << "gid" << _target->gid() + << "limit" << _limit + << "miny" << _miny + << "maxy" << _maxy + << "slicewidth" << _sliceWidth + << "target" << json::object + << "origin" << _target->origin() + //<< "currShift" << _currShift + << "offsetPrev" << _offsetPrev + << "bbox" << seg->theGlyphBBoxTemporary(_target->gid()) + << "slantBox" << seg->getFace()->glyphs().slant(_target->gid()) + << "fix" << "kern" + << json::close; // target object + + *dbgout << "slices" << json::array; + for (int is = 0; is < (int)_edges.size(); is++) + { + *dbgout << json::flat << json::object + << "i" << is + << "targetEdge" << _edges[is] + << "neighbor" << objectid(dslot(seg, _slotNear[is])) + << "nearEdge" << _nearEdges[is] + << json::close; + } + *dbgout << json::close; // slices array + + *dbgout + << "xbound" << _xbound + << "minGap" << _mingap + << "needed" << resultNeeded + << "result" << result + << "stillBad" << (result != resultNeeded) + << json::close; // slot object + } +#endif + + return Position(result, 0.); + +} // end of KernCollider::resolve + +void KernCollider::shift(const Position &mv, int dir) +{ + for (Vector<float>::iterator e = _edges.begin(); e != _edges.end(); ++e) + *e += mv.x; + _xbound += (1 - 2 * (dir & 1)) * mv.x; +} + +//// SLOT-COLLISION //// + +// Initialize the collision attributes for the given slot. +SlotCollision::SlotCollision(Segment *seg, Slot *slot) +{ + initFromSlot(seg, slot); +} + +void SlotCollision::initFromSlot(Segment *seg, Slot *slot) +{ + // Initialize slot attributes from glyph attributes. + // The order here must match the order in the grcompiler code, + // GrcSymbolTable::AssignInternalGlyphAttrIDs. + uint16 gid = slot->gid(); + uint16 aCol = seg->silf()->aCollision(); // flags attr ID + const GlyphFace * glyphFace = seg->getFace()->glyphs().glyphSafe(gid); + if (!glyphFace) + return; + const sparse &p = glyphFace->attrs(); + _flags = p[aCol]; + _limit = Rect(Position(int16(p[aCol+1]), int16(p[aCol+2])), + Position(int16(p[aCol+3]), int16(p[aCol+4]))); + _margin = p[aCol+5]; + _marginWt = p[aCol+6]; + + _seqClass = p[aCol+7]; + _seqProxClass = p[aCol+8]; + _seqOrder = p[aCol+9]; + _seqAboveXoff = p[aCol+10]; + _seqAboveWt = p[aCol+11]; + _seqBelowXlim = p[aCol+12]; + _seqBelowWt = p[aCol+13]; + _seqValignHt = p[aCol+14]; + _seqValignWt = p[aCol+15]; + + // These attributes do not have corresponding glyph attribute: + _exclGlyph = 0; + _exclOffset = Position(0, 0); +} + +float SlotCollision::getKern(int dir) const +{ + if ((_flags & SlotCollision::COLL_KERN) != 0) + return float(_shift.x * ((dir & 1) ? -1 : 1)); + else + return 0; +} + +bool SlotCollision::ignore() const +{ + return ((flags() & SlotCollision::COLL_IGNORE) || (flags() & SlotCollision::COLL_ISSPACE)); +} diff --git a/gfx/graphite2/src/Decompressor.cpp b/gfx/graphite2/src/Decompressor.cpp new file mode 100644 index 0000000000..42dc9113e5 --- /dev/null +++ b/gfx/graphite2/src/Decompressor.cpp @@ -0,0 +1,125 @@ +/* GRAPHITE2 LICENSING + + Copyright 2015, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cassert> + +#include "inc/Decompressor.h" +#include "inc/Compression.h" + +using namespace lz4; + +namespace { + +inline +u32 read_literal(u8 const * &s, u8 const * const e, u32 l) { + if (l == 15 && s != e) + { + u8 b = 0; + do { l += b = *s++; } while(b==0xff && s != e); + } + return l; +} + +bool read_sequence(u8 const * &src, u8 const * const end, u8 const * &literal, + u32 & literal_len, u32 & match_len, u32 & match_dist) +{ + u8 const token = *src++; + + literal_len = read_literal(src, end, token >> 4); + literal = src; + src += literal_len; + + // Normal exit for end of stream, wrap arround check and parital match check. + if (src > end - sizeof(u16) || src < literal) + return false; + + match_dist = *src++; + match_dist |= *src++ << 8; + match_len = read_literal(src, end, token & 0xf) + MINMATCH; + + // Malformed stream check. + return src <= end-MINCODA; +} + +} + +int lz4::decompress(void const *in, size_t in_size, void *out, size_t out_size) +{ + if (out_size <= in_size || in_size < MINSRCSIZE) + return -1; + + u8 const * src = static_cast<u8 const *>(in), + * literal = 0, + * const src_end = src + in_size; + + u8 * dst = static_cast<u8*>(out), + * const dst_end = dst + out_size; + + // Check the in and out size hasn't wrapped around. + if (src >= src_end || dst >= dst_end) + return -1; + + u32 literal_len = 0, + match_len = 0, + match_dist = 0; + + while (read_sequence(src, src_end, literal, literal_len, match_len, + match_dist)) + { + if (literal_len != 0) + { + // Copy in literal. At this point the a minimal literal + minminal + // match plus the coda (1 + 2 + 5) must be 8 bytes or more allowing + // us to remain within the src buffer for an overrun_copy on + // machines upto 64 bits. + if (align(literal_len) > out_size) + return -1; + dst = overrun_copy(dst, literal, literal_len); + out_size -= literal_len; + } + + // Copy, possibly repeating, match from earlier in the + // decoded output. + u8 const * const pcpy = dst - match_dist; + if (pcpy < static_cast<u8*>(out) + || match_len > unsigned(out_size - LASTLITERALS) + // Wrap around checks: + || out_size < LASTLITERALS || pcpy >= dst) + return -1; + if (dst > pcpy+sizeof(unsigned long) + && align(match_len) <= out_size) + dst = overrun_copy(dst, pcpy, match_len); + else + dst = safe_copy(dst, pcpy, match_len); + out_size -= match_len; + } + + if (literal > src_end - literal_len || literal_len > out_size) + return -1; + dst = fast_copy(dst, literal, literal_len); + + return int(dst - (u8*)out); +} diff --git a/gfx/graphite2/src/Face.cpp b/gfx/graphite2/src/Face.cpp new file mode 100644 index 0000000000..3e106050d7 --- /dev/null +++ b/gfx/graphite2/src/Face.cpp @@ -0,0 +1,366 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cstring> +#include "graphite2/Segment.h" +#include "inc/CmapCache.h" +#include "inc/debug.h" +#include "inc/Decompressor.h" +#include "inc/Endian.h" +#include "inc/Face.h" +#include "inc/FileFace.h" +#include "inc/GlyphFace.h" +#include "inc/json.h" +#include "inc/Segment.h" +#include "inc/NameTable.h" +#include "inc/Error.h" + +using namespace graphite2; + +namespace +{ +enum compression +{ + NONE, + LZ4 +}; + +} + +Face::Face(const void* appFaceHandle/*non-NULL*/, const gr_face_ops & ops) +: m_appFaceHandle(appFaceHandle), + m_pFileFace(NULL), + m_pGlyphFaceCache(NULL), + m_cmap(NULL), + m_pNames(NULL), + m_logger(NULL), + m_error(0), m_errcntxt(0), + m_silfs(NULL), + m_numSilf(0), + m_ascent(0), + m_descent(0) +{ + memset(&m_ops, 0, sizeof m_ops); + memcpy(&m_ops, &ops, min(sizeof m_ops, ops.size)); +} + + +Face::~Face() +{ + setLogger(0); + delete m_pGlyphFaceCache; + delete m_cmap; + delete[] m_silfs; +#ifndef GRAPHITE2_NFILEFACE + delete m_pFileFace; +#endif + delete m_pNames; +} + +float Face::default_glyph_advance(const void* font_ptr, gr_uint16 glyphid) +{ + const Font & font = *reinterpret_cast<const Font *>(font_ptr); + + return font.face().glyphs().glyph(glyphid)->theAdvance().x * font.scale(); +} + +bool Face::readGlyphs(uint32 faceOptions) +{ + Error e; +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _glyph_cat(tele.glyph); +#endif + error_context(EC_READGLYPHS); + m_pGlyphFaceCache = new GlyphCache(*this, faceOptions); + + if (e.test(!m_pGlyphFaceCache, E_OUTOFMEM) + || e.test(m_pGlyphFaceCache->numGlyphs() == 0, E_NOGLYPHS) + || e.test(m_pGlyphFaceCache->unitsPerEm() == 0, E_BADUPEM)) + { + return error(e); + } + + if (faceOptions & gr_face_cacheCmap) + m_cmap = new CachedCmap(*this); + else + m_cmap = new DirectCmap(*this); + if (e.test(!m_cmap, E_OUTOFMEM) || e.test(!*m_cmap, E_BADCMAP)) + return error(e); + + if (faceOptions & gr_face_preloadGlyphs) + nameTable(); // preload the name table along with the glyphs. + + return true; +} + +bool Face::readGraphite(const Table & silf) +{ +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _silf_cat(tele.silf); +#endif + Error e; + error_context(EC_READSILF); + const byte * p = silf; + if (e.test(!p, E_NOSILF) || e.test(silf.size() < 20, E_BADSIZE)) return error(e); + + const uint32 version = be::read<uint32>(p); + if (e.test(version < 0x00020000, E_TOOOLD)) return error(e); + if (version >= 0x00030000) + be::skip<uint32>(p); // compilerVersion + m_numSilf = be::read<uint16>(p); + + be::skip<uint16>(p); // reserved + + bool havePasses = false; + m_silfs = new Silf[m_numSilf]; + if (e.test(!m_silfs, E_OUTOFMEM)) return error(e); + for (int i = 0; i < m_numSilf; i++) + { + error_context(EC_ASILF + (i << 8)); + const uint32 offset = be::read<uint32>(p), + next = i == m_numSilf - 1 ? uint32(silf.size()) : be::peek<uint32>(p); + if (e.test(next > silf.size() || offset >= next, E_BADSIZE)) + return error(e); + + if (!m_silfs[i].readGraphite(silf + offset, next - offset, *this, version)) + return false; + + if (m_silfs[i].numPasses()) + havePasses = true; + } + + return havePasses; +} + +bool Face::readFeatures() +{ + return m_Sill.readFace(*this); +} + +bool Face::runGraphite(Segment *seg, const Silf *aSilf) const +{ +#if !defined GRAPHITE2_NTRACING + json * dbgout = logger(); + if (dbgout) + { + *dbgout << json::object + << "id" << objectid(seg) + << "passes" << json::array; + } +#endif + +// if ((seg->dir() & 1) != aSilf->dir()) +// seg->reverseSlots(); + if ((seg->dir() & 3) == 3 && aSilf->bidiPass() == 0xFF) + seg->doMirror(aSilf->aMirror()); + bool res = aSilf->runGraphite(seg, 0, aSilf->positionPass(), true); + if (res) + { + seg->associateChars(0, seg->charInfoCount()); + if (aSilf->flags() & 0x20) + res &= seg->initCollisions(); + if (res) + res &= aSilf->runGraphite(seg, aSilf->positionPass(), aSilf->numPasses(), false); + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) +{ + seg->positionSlots(0, 0, 0, seg->currdir()); + *dbgout << json::item + << json::close // Close up the passes array + << "outputdir" << (seg->currdir() ? "rtl" : "ltr") + << "output" << json::array; + for(Slot * s = seg->first(); s; s = s->next()) + *dbgout << dslot(seg, s); + *dbgout << json::close + << "advance" << seg->advance() + << "chars" << json::array; + for(size_t i = 0, n = seg->charInfoCount(); i != n; ++i) + *dbgout << json::flat << *seg->charinfo(int(i)); + *dbgout << json::close // Close up the chars array + << json::close; // Close up the segment object + } +#endif + + return res; +} + +void Face::setLogger(FILE * log_file GR_MAYBE_UNUSED) +{ +#if !defined GRAPHITE2_NTRACING + delete m_logger; + m_logger = log_file ? new json(log_file) : 0; +#endif +} + +const Silf *Face::chooseSilf(uint32 script) const +{ + if (m_numSilf == 0) + return NULL; + else if (m_numSilf == 1 || script == 0) + return m_silfs; + else // do more work here + return m_silfs; +} + +uint16 Face::findPseudo(uint32 uid) const +{ + return (m_numSilf) ? m_silfs[0].findPseudo(uid) : 0; +} + +int32 Face::getGlyphMetric(uint16 gid, uint8 metric) const +{ + switch (metrics(metric)) + { + case kgmetAscent : return m_ascent; + case kgmetDescent : return m_descent; + default: + if (gid >= glyphs().numGlyphs()) return 0; + return glyphs().glyph(gid)->getMetric(metric); + } +} + +void Face::takeFileFace(FileFace* pFileFace GR_MAYBE_UNUSED/*takes ownership*/) +{ +#ifndef GRAPHITE2_NFILEFACE + if (m_pFileFace==pFileFace) + return; + + delete m_pFileFace; + m_pFileFace = pFileFace; +#endif +} + +NameTable * Face::nameTable() const +{ + if (m_pNames) return m_pNames; + const Table name(*this, Tag::name); + if (name) + m_pNames = new NameTable(name, name.size()); + return m_pNames; +} + +uint16 Face::languageForLocale(const char * locale) const +{ + nameTable(); + if (m_pNames) + return m_pNames->getLanguageId(locale); + return 0; +} + + + +Face::Table::Table(const Face & face, const Tag n, uint32 version) throw() +: _f(&face), _sz(0), _compressed(false) +{ + _p = static_cast<const byte *>((*_f->m_ops.get_table)(_f->m_appFaceHandle, n, &_sz)); + + if (!TtfUtil::CheckTable(n, _p, _sz)) + { + release(); // Make sure we release the table buffer even if the table failed its checks + return; + } + + if (be::peek<uint32>(_p) >= version) + decompress(); +} + +void Face::Table::release() +{ + if (_compressed) + free(const_cast<byte *>(_p)); + else if (_p && _f->m_ops.release_table) + (*_f->m_ops.release_table)(_f->m_appFaceHandle, _p); + _p = 0; _sz = 0; +} + +Face::Table & Face::Table::operator = (const Table && rhs) throw() +{ + if (this == &rhs) return *this; + release(); + new (this) Table(std::move(rhs)); + return *this; +} + +Error Face::Table::decompress() +{ + Error e; + if (e.test(_sz < 5 * sizeof(uint32), E_BADSIZE)) + return e; + byte * uncompressed_table = 0; + size_t uncompressed_size = 0; + + const byte * p = _p; + const uint32 version = be::read<uint32>(p); // Table version number. + + // The scheme is in the top 5 bits of the 1st uint32. + const uint32 hdr = be::read<uint32>(p); + switch(compression(hdr >> 27)) + { + case NONE: return e; + + case LZ4: + { + uncompressed_size = hdr & 0x07ffffff; + uncompressed_table = gralloc<byte>(uncompressed_size); + if (!e.test(!uncompressed_table || uncompressed_size < 4, E_OUTOFMEM)) + { + memset(uncompressed_table, 0, 4); // make sure version number is initialised + // coverity[forward_null : FALSE] - uncompressed_table has been checked so can't be null + // coverity[checked_return : FALSE] - we test e later + e.test(lz4::decompress(p, _sz - 2*sizeof(uint32), uncompressed_table, uncompressed_size) != signed(uncompressed_size), E_SHRINKERFAILED); + } + break; + } + + default: + e.error(E_BADSCHEME); + }; + + // Check the uncompressed version number against the original. + if (!e) + // coverity[forward_null : FALSE] - uncompressed_table has already been tested so can't be null + // coverity[checked_return : FALSE] - we test e later + e.test(be::peek<uint32>(uncompressed_table) != version, E_SHRINKERFAILED); + + // Tell the provider to release the compressed form since were replacing + // it anyway. + release(); + + if (e) + { + free(uncompressed_table); + uncompressed_table = 0; + uncompressed_size = 0; + } + + _p = uncompressed_table; + _sz = uncompressed_size; + _compressed = true; + + return e; +} diff --git a/gfx/graphite2/src/FeatureMap.cpp b/gfx/graphite2/src/FeatureMap.cpp new file mode 100644 index 0000000000..014a88fd08 --- /dev/null +++ b/gfx/graphite2/src/FeatureMap.cpp @@ -0,0 +1,293 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cstring> + +#include "inc/Main.h" +#include "inc/bits.h" +#include "inc/Endian.h" +#include "inc/FeatureMap.h" +#include "inc/FeatureVal.h" +#include "graphite2/Font.h" +#include "inc/TtfUtil.h" +#include <cstdlib> +#include "inc/Face.h" + + +using namespace graphite2; + +namespace +{ + static int cmpNameAndFeatures(const void *ap, const void *bp) + { + const NameAndFeatureRef & a = *static_cast<const NameAndFeatureRef *>(ap), + & b = *static_cast<const NameAndFeatureRef *>(bp); + return (a < b ? -1 : (b < a ? 1 : 0)); + } + + const size_t FEAT_HEADER = sizeof(uint32) + 2*sizeof(uint16) + sizeof(uint32), + FEATURE_SIZE = sizeof(uint32) + + 2*sizeof(uint16) + + sizeof(uint32) + + 2*sizeof(uint16), + FEATURE_SETTING_SIZE = sizeof(int16) + sizeof(uint16); + + uint16 readFeatureSettings(const byte * p, FeatureSetting * s, size_t num_settings) + { + uint16 max_val = 0; + for (FeatureSetting * const end = s + num_settings; s != end; ++s) + { + const int16 value = be::read<int16>(p); + ::new (s) FeatureSetting(value, be::read<uint16>(p)); + if (uint16(value) > max_val) max_val = value; + } + + return max_val; + } +} + +FeatureRef::FeatureRef(const Face & face, + unsigned short & bits_offset, uint32 max_val, + uint32 name, uint16 uiName, flags_t flags, + FeatureSetting *settings, uint16 num_set) throw() +: m_face(&face), + m_nameValues(settings), + m_mask(mask_over_val(max_val)), + m_max(max_val), + m_id(name), + m_nameid(uiName), + m_numSet(num_set), + m_flags(flags) +{ + const uint8 need_bits = bit_set_count(m_mask); + m_index = (bits_offset + need_bits) / SIZEOF_CHUNK; + if (m_index > bits_offset / SIZEOF_CHUNK) + bits_offset = m_index*SIZEOF_CHUNK; + m_bits = bits_offset % SIZEOF_CHUNK; + bits_offset += need_bits; + m_mask <<= m_bits; +} + +FeatureRef::~FeatureRef() throw() +{ + free(m_nameValues); +} + +bool FeatureMap::readFeats(const Face & face) +{ + const Face::Table feat(face, TtfUtil::Tag::Feat); + const byte * p = feat; + if (!p) return true; + if (feat.size() < FEAT_HEADER) return false; + + const byte *const feat_start = p, + *const feat_end = p + feat.size(); + + const uint32 version = be::read<uint32>(p); + m_numFeats = be::read<uint16>(p); + be::skip<uint16>(p); + be::skip<uint32>(p); + + // Sanity checks + if (m_numFeats == 0) return true; + if (version < 0x00010000 || + p + m_numFeats*FEATURE_SIZE > feat_end) + { //defensive + m_numFeats = 0; + return false; + } + + m_feats = new FeatureRef [m_numFeats]; + uint16 * const defVals = gralloc<uint16>(m_numFeats); + if (!defVals || !m_feats) return false; + unsigned short bits = 0; //to cause overflow on first Feature + + for (int i = 0, ie = m_numFeats; i != ie; i++) + { + const uint32 label = version < 0x00020000 ? be::read<uint16>(p) : be::read<uint32>(p); + const uint16 num_settings = be::read<uint16>(p); + if (version >= 0x00020000) + be::skip<uint16>(p); + const uint32 settings_offset = be::read<uint32>(p); + const uint16 flags = be::read<uint16>(p), + uiName = be::read<uint16>(p); + + if (settings_offset > size_t(feat_end - feat_start) + || settings_offset + num_settings * FEATURE_SETTING_SIZE > size_t(feat_end - feat_start)) + { + free(defVals); + return false; + } + + FeatureSetting *uiSet; + uint32 maxVal; + if (num_settings != 0) + { + uiSet = gralloc<FeatureSetting>(num_settings); + if (!uiSet) + { + free(defVals); + return false; + } + maxVal = readFeatureSettings(feat_start + settings_offset, uiSet, num_settings); + defVals[i] = uiSet[0].value(); + } + else + { + uiSet = 0; + maxVal = 0xffffffff; + defVals[i] = 0; + } + + ::new (m_feats + i) FeatureRef (face, bits, maxVal, + label, uiName, + FeatureRef::flags_t(flags), + uiSet, num_settings); + } + new (&m_defaultFeatures) Features(bits/(sizeof(uint32)*8) + 1, *this); + m_pNamedFeats = new NameAndFeatureRef[m_numFeats]; + if (!m_pNamedFeats) + { + free(defVals); + return false; + } + for (int i = 0; i < m_numFeats; ++i) + { + m_feats[i].applyValToFeature(defVals[i], m_defaultFeatures); + m_pNamedFeats[i] = m_feats[i]; + } + + free(defVals); + + qsort(m_pNamedFeats, m_numFeats, sizeof(NameAndFeatureRef), &cmpNameAndFeatures); + + return true; +} + +bool SillMap::readFace(const Face & face) +{ + if (!m_FeatureMap.readFeats(face)) return false; + if (!readSill(face)) return false; + return true; +} + + +bool SillMap::readSill(const Face & face) +{ + const Face::Table sill(face, TtfUtil::Tag::Sill); + const byte *p = sill; + + if (!p) return true; + if (sill.size() < 12) return false; + if (be::read<uint32>(p) != 0x00010000UL) return false; + m_numLanguages = be::read<uint16>(p); + m_langFeats = new LangFeaturePair[m_numLanguages]; + if (!m_langFeats || !m_FeatureMap.m_numFeats) { m_numLanguages = 0; return true; } //defensive + + p += 6; // skip the fast search + if (sill.size() < m_numLanguages * 8U + 12) return false; + + for (int i = 0; i < m_numLanguages; i++) + { + uint32 langid = be::read<uint32>(p); + uint16 numSettings = be::read<uint16>(p); + uint16 offset = be::read<uint16>(p); + if (offset + 8U * numSettings > sill.size() && numSettings > 0) return false; + Features* feats = new Features(m_FeatureMap.m_defaultFeatures); + if (!feats) return false; + const byte *pLSet = sill + offset; + + // Apply langauge specific settings + for (int j = 0; j < numSettings; j++) + { + uint32 name = be::read<uint32>(pLSet); + uint16 val = be::read<uint16>(pLSet); + pLSet += 2; + const FeatureRef* pRef = m_FeatureMap.findFeatureRef(name); + if (pRef) pRef->applyValToFeature(val, *feats); + } + // Add the language id feature which is always feature id 1 + const FeatureRef* pRef = m_FeatureMap.findFeatureRef(1); + if (pRef) pRef->applyValToFeature(langid, *feats); + + m_langFeats[i].m_lang = langid; + m_langFeats[i].m_pFeatures = feats; + } + return true; +} + + +Features* SillMap::cloneFeatures(uint32 langname/*0 means default*/) const +{ + if (langname) + { + // the number of languages in a font is usually small e.g. 8 in Doulos + // so this loop is not very expensive + for (uint16 i = 0; i < m_numLanguages; i++) + { + if (m_langFeats[i].m_lang == langname) + return new Features(*m_langFeats[i].m_pFeatures); + } + } + return new Features (m_FeatureMap.m_defaultFeatures); +} + + + +const FeatureRef *FeatureMap::findFeatureRef(uint32 name) const +{ + NameAndFeatureRef *it; + + for (it = m_pNamedFeats; it < m_pNamedFeats + m_numFeats; ++it) + if (it->m_name == name) + return it->m_pFRef; + return NULL; +} + +bool FeatureRef::applyValToFeature(uint32 val, Features & pDest) const +{ + if (val>maxVal() || !m_face) + return false; + if (pDest.m_pMap==NULL) + pDest.m_pMap = &m_face->theSill().theFeatureMap(); + else + if (pDest.m_pMap!=&m_face->theSill().theFeatureMap()) + return false; //incompatible + if (m_index >= pDest.size()) + pDest.resize(m_index+1); + pDest[m_index] &= ~m_mask; + pDest[m_index] |= (uint32(val) << m_bits); + return true; +} + +uint32 FeatureRef::getFeatureVal(const Features& feats) const +{ + if (m_index < feats.size() && m_face + && &m_face->theSill().theFeatureMap()==feats.m_pMap) + return (feats[m_index] & m_mask) >> m_bits; + else + return 0; +} diff --git a/gfx/graphite2/src/FileFace.cpp b/gfx/graphite2/src/FileFace.cpp new file mode 100644 index 0000000000..7e663876a7 --- /dev/null +++ b/gfx/graphite2/src/FileFace.cpp @@ -0,0 +1,115 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cstring> +#include "inc/FileFace.h" + + +#ifndef GRAPHITE2_NFILEFACE + +using namespace graphite2; + +FileFace::FileFace(const char *filename) +: _file(fopen(filename, "rb")), + _file_len(0), + _header_tbl(NULL), + _table_dir(NULL) +{ + if (!_file) return; + + if (fseek(_file, 0, SEEK_END)) return; + _file_len = ftell(_file); + if (fseek(_file, 0, SEEK_SET)) return; + + size_t tbl_offset, tbl_len; + + // Get the header. + if (!TtfUtil::GetHeaderInfo(tbl_offset, tbl_len)) return; + if (fseek(_file, long(tbl_offset), SEEK_SET)) return; + _header_tbl = (TtfUtil::Sfnt::OffsetSubTable*)gralloc<char>(tbl_len); + if (_header_tbl) + { + if (fread(_header_tbl, 1, tbl_len, _file) != tbl_len) return; + if (!TtfUtil::CheckHeader(_header_tbl)) return; + } + + // Get the table directory + if (!TtfUtil::GetTableDirInfo(_header_tbl, tbl_offset, tbl_len)) return; + _table_dir = (TtfUtil::Sfnt::OffsetSubTable::Entry*)gralloc<char>(tbl_len); + if (fseek(_file, long(tbl_offset), SEEK_SET)) return; + if (_table_dir && fread(_table_dir, 1, tbl_len, _file) != tbl_len) + { + free(_table_dir); + _table_dir = NULL; + } + return; +} + +FileFace::~FileFace() +{ + free(_table_dir); + free(_header_tbl); + if (_file) + fclose(_file); +} + + +const void *FileFace::get_table_fn(const void* appFaceHandle, unsigned int name, size_t *len) +{ + if (appFaceHandle == 0) return 0; + const FileFace & file_face = *static_cast<const FileFace *>(appFaceHandle); + + void *tbl; + size_t tbl_offset, tbl_len; + if (!TtfUtil::GetTableInfo(name, file_face._header_tbl, file_face._table_dir, tbl_offset, tbl_len)) + return 0; + + if (tbl_offset > file_face._file_len || tbl_len > file_face._file_len - tbl_offset + || fseek(file_face._file, long(tbl_offset), SEEK_SET) != 0) + return 0; + + tbl = malloc(tbl_len); + if (!tbl || fread(tbl, 1, tbl_len, file_face._file) != tbl_len) + { + free(tbl); + return 0; + } + + if (len) *len = tbl_len; + return tbl; +} + +void FileFace::rel_table_fn(const void* appFaceHandle, const void *table_buffer) +{ + if (appFaceHandle == 0) return; + + free(const_cast<void *>(table_buffer)); +} + +const gr_face_ops FileFace::ops = { sizeof FileFace::ops, &FileFace::get_table_fn, &FileFace::rel_table_fn }; + + +#endif //!GRAPHITE2_NFILEFACE diff --git a/gfx/graphite2/src/Font.cpp b/gfx/graphite2/src/Font.cpp new file mode 100644 index 0000000000..faf3715f9d --- /dev/null +++ b/gfx/graphite2/src/Font.cpp @@ -0,0 +1,58 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/Face.h" +#include "inc/Font.h" +#include "inc/GlyphCache.h" + +using namespace graphite2; + +Font::Font(float ppm, const Face & f, const void * appFontHandle, const gr_font_ops * ops) +: m_appFontHandle(appFontHandle ? appFontHandle : this), + m_face(f), + m_scale(ppm / f.glyphs().unitsPerEm()), + m_hinted(appFontHandle && ops && (ops->glyph_advance_x || ops->glyph_advance_y)) +{ + memset(&m_ops, 0, sizeof m_ops); + if (m_hinted && ops) + memcpy(&m_ops, ops, min(sizeof m_ops, ops->size)); + else + m_ops.glyph_advance_x = &Face::default_glyph_advance; + + size_t nGlyphs = f.glyphs().numGlyphs(); + m_advances = gralloc<float>(nGlyphs); + if (m_advances) + { + for (float *advp = m_advances; nGlyphs; --nGlyphs, ++advp) + *advp = INVALID_ADVANCE; + } +} + + +/*virtual*/ Font::~Font() +{ + free(m_advances); +} diff --git a/gfx/graphite2/src/GlyphCache.cpp b/gfx/graphite2/src/GlyphCache.cpp new file mode 100644 index 0000000000..282bdc18fd --- /dev/null +++ b/gfx/graphite2/src/GlyphCache.cpp @@ -0,0 +1,492 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Font.h" + +#include "inc/Main.h" +#include "inc/Face.h" //for the tags +#include "inc/GlyphCache.h" +#include "inc/GlyphFace.h" +#include "inc/Endian.h" +#include "inc/bits.h" + +using namespace graphite2; + +namespace +{ + // Iterator over version 1 or 2 glat entries which consist of a series of + // +-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+ + // v1 |k|n|v1 |v2 |...|vN | or v2 | k | n |v1 |v2 |...|vN | + // +-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+ + // variable length structures. + + template<typename W> + class _glat_iterator : public std::iterator<std::input_iterator_tag, std::pair<sparse::key_type, sparse::mapped_type> > + { + unsigned short key() const { return uint16(be::peek<W>(_e) + _n); } + unsigned int run() const { return be::peek<W>(_e+sizeof(W)); } + void advance_entry() { _n = 0; _e = _v; be::skip<W>(_v,2); } + public: + _glat_iterator(const void * glat=0) : _e(reinterpret_cast<const byte *>(glat)), _v(_e+2*sizeof(W)), _n(0) {} + + _glat_iterator<W> & operator ++ () { + ++_n; be::skip<uint16>(_v); + if (_n == run()) advance_entry(); + return *this; + } + _glat_iterator<W> operator ++ (int) { _glat_iterator<W> tmp(*this); operator++(); return tmp; } + + // This is strictly a >= operator. A true == operator could be + // implemented that test for overlap but it would be more expensive a + // test. + bool operator == (const _glat_iterator<W> & rhs) { return _v >= rhs._e - 1; } + bool operator != (const _glat_iterator<W> & rhs) { return !operator==(rhs); } + + value_type operator * () const { + return value_type(key(), be::peek<uint16>(_v)); + } + + protected: + const byte * _e, * _v; + size_t _n; + }; + + typedef _glat_iterator<uint8> glat_iterator; + typedef _glat_iterator<uint16> glat2_iterator; +} + +const SlantBox SlantBox::empty = {0,0,0,0}; + + +class GlyphCache::Loader +{ +public: + Loader(const Face & face); //return result indicates success. Do not use if failed. + + operator bool () const throw(); + unsigned short int units_per_em() const throw(); + unsigned short int num_glyphs() const throw(); + unsigned short int num_attrs() const throw(); + bool has_boxes() const throw(); + + const GlyphFace * read_glyph(unsigned short gid, GlyphFace &, int *numsubs) const throw(); + GlyphBox * read_box(uint16 gid, GlyphBox *curr, const GlyphFace & face) const throw(); + + CLASS_NEW_DELETE; +private: + Face::Table _head, + _hhea, + _hmtx, + _glyf, + _loca, + m_pGlat, + m_pGloc; + + bool _long_fmt; + bool _has_boxes; + unsigned short _num_glyphs_graphics, //i.e. boundary box and advance + _num_glyphs_attributes, + _num_attrs; // number of glyph attributes per glyph +}; + + + +GlyphCache::GlyphCache(const Face & face, const uint32 face_options) +: _glyph_loader(new Loader(face)), + _glyphs(_glyph_loader && *_glyph_loader && _glyph_loader->num_glyphs() + ? grzeroalloc<const GlyphFace *>(_glyph_loader->num_glyphs()) : 0), + _boxes(_glyph_loader && _glyph_loader->has_boxes() && _glyph_loader->num_glyphs() + ? grzeroalloc<GlyphBox *>(_glyph_loader->num_glyphs()) : 0), + _num_glyphs(_glyphs ? _glyph_loader->num_glyphs() : 0), + _num_attrs(_glyphs ? _glyph_loader->num_attrs() : 0), + _upem(_glyphs ? _glyph_loader->units_per_em() : 0) +{ + if ((face_options & gr_face_preloadGlyphs) && _glyph_loader && _glyphs) + { + int numsubs = 0; + GlyphFace * const glyphs = new GlyphFace [_num_glyphs]; + if (!glyphs) + return; + + // The 0 glyph is definately required. + _glyphs[0] = _glyph_loader->read_glyph(0, glyphs[0], &numsubs); + + // glyphs[0] has the same address as the glyphs array just allocated, + // thus assigning the &glyphs[0] to _glyphs[0] means _glyphs[0] points + // to the entire array. + const GlyphFace * loaded = _glyphs[0]; + for (uint16 gid = 1; loaded && gid != _num_glyphs; ++gid) + _glyphs[gid] = loaded = _glyph_loader->read_glyph(gid, glyphs[gid], &numsubs); + + if (!loaded) + { + _glyphs[0] = 0; + delete [] glyphs; + } + else if (numsubs > 0 && _boxes) + { + GlyphBox * boxes = (GlyphBox *)gralloc<char>(_num_glyphs * sizeof(GlyphBox) + numsubs * 8 * sizeof(float)); + GlyphBox * currbox = boxes; + + for (uint16 gid = 0; currbox && gid != _num_glyphs; ++gid) + { + _boxes[gid] = currbox; + currbox = _glyph_loader->read_box(gid, currbox, *_glyphs[gid]); + } + if (!currbox) + { + free(boxes); + _boxes[0] = 0; + } + } + delete _glyph_loader; + _glyph_loader = 0; + // coverity[leaked_storage : FALSE] - calling read_glyph on index 0 saved + // glyphs as _glyphs[0]. Setting _glyph_loader to nullptr here flags that + // the dtor needs to call delete[] on _glyphs[0] to release what was allocated + // as glyphs + } + + if (_glyphs && glyph(0) == 0) + { + free(_glyphs); + _glyphs = 0; + if (_boxes) + { + free(_boxes); + _boxes = 0; + } + _num_glyphs = _num_attrs = _upem = 0; + } +} + + +GlyphCache::~GlyphCache() +{ + if (_glyphs) + { + if (_glyph_loader) + { + const GlyphFace * * g = _glyphs; + for(unsigned short n = _num_glyphs; n; --n, ++g) + delete *g; + } + else + delete [] _glyphs[0]; + free(_glyphs); + } + if (_boxes) + { + if (_glyph_loader) + { + GlyphBox * * g = _boxes; + for (uint16 n = _num_glyphs; n; --n, ++g) + free(*g); + } + else + free(_boxes[0]); + free(_boxes); + } + delete _glyph_loader; +} + +const GlyphFace *GlyphCache::glyph(unsigned short glyphid) const //result may be changed by subsequent call with a different glyphid +{ + if (glyphid >= numGlyphs()) + return _glyphs[0]; + const GlyphFace * & p = _glyphs[glyphid]; + if (p == 0 && _glyph_loader) + { + int numsubs = 0; + GlyphFace * g = new GlyphFace(); + if (g) p = _glyph_loader->read_glyph(glyphid, *g, &numsubs); + if (!p) + { + delete g; + return *_glyphs; + } + if (_boxes) + { + _boxes[glyphid] = (GlyphBox *)gralloc<char>(sizeof(GlyphBox) + 8 * numsubs * sizeof(float)); + if (!_glyph_loader->read_box(glyphid, _boxes[glyphid], *_glyphs[glyphid])) + { + free(_boxes[glyphid]); + _boxes[glyphid] = 0; + } + } + } + return p; +} + + + +GlyphCache::Loader::Loader(const Face & face) +: _head(face, Tag::head), + _hhea(face, Tag::hhea), + _hmtx(face, Tag::hmtx), + _glyf(face, Tag::glyf), + _loca(face, Tag::loca), + _long_fmt(false), + _has_boxes(false), + _num_glyphs_graphics(0), + _num_glyphs_attributes(0), + _num_attrs(0) +{ + if (!operator bool()) + return; + + const Face::Table maxp = Face::Table(face, Tag::maxp); + if (!maxp) { _head = Face::Table(); return; } + + _num_glyphs_graphics = static_cast<unsigned short>(TtfUtil::GlyphCount(maxp)); + // This will fail if the number of glyphs is wildly out of range. + if (_glyf && TtfUtil::LocaLookup(_num_glyphs_graphics-1, _loca, _loca.size(), _head) == size_t(-2)) + { + _head = Face::Table(); + return; + } + + if ((m_pGlat = Face::Table(face, Tag::Glat, 0x00030000)) == NULL + || (m_pGloc = Face::Table(face, Tag::Gloc)) == NULL + || m_pGloc.size() < 8) + { + _head = Face::Table(); + return; + } + const byte * p = m_pGloc; + int version = be::read<uint32>(p); + const uint16 flags = be::read<uint16>(p); + _num_attrs = be::read<uint16>(p); + // We can accurately calculate the number of attributed glyphs by + // subtracting the length of the attribids array (numAttribs long if present) + // and dividing by either 2 or 4 depending on shor or lonf format + _long_fmt = flags & 1; + ptrdiff_t tmpnumgattrs = (m_pGloc.size() + - (p - m_pGloc) + - sizeof(uint16)*(flags & 0x2 ? _num_attrs : 0)) + / (_long_fmt ? sizeof(uint32) : sizeof(uint16)) - 1; + + if (version >= 0x00020000 || tmpnumgattrs < 0 || tmpnumgattrs > 65535 + || _num_attrs == 0 || _num_attrs > 0x3000 // is this hard limit appropriate? + || _num_glyphs_graphics > tmpnumgattrs + || m_pGlat.size() < 4) + { + _head = Face::Table(); + return; + } + + _num_glyphs_attributes = static_cast<unsigned short>(tmpnumgattrs); + p = m_pGlat; + version = be::read<uint32>(p); + if (version >= 0x00040000 || (version >= 0x00030000 && m_pGlat.size() < 8)) // reject Glat tables that are too new + { + _head = Face::Table(); + return; + } + else if (version >= 0x00030000) + { + unsigned int glatflags = be::read<uint32>(p); + _has_boxes = glatflags & 1; + // delete this once the compiler is fixed + _has_boxes = true; + } +} + +inline +GlyphCache::Loader::operator bool () const throw() +{ + return _head && _hhea && _hmtx && !(bool(_glyf) != bool(_loca)); +} + +inline +unsigned short int GlyphCache::Loader::units_per_em() const throw() +{ + return _head ? TtfUtil::DesignUnits(_head) : 0; +} + +inline +unsigned short int GlyphCache::Loader::num_glyphs() const throw() +{ + return max(_num_glyphs_graphics, _num_glyphs_attributes); +} + +inline +unsigned short int GlyphCache::Loader::num_attrs() const throw() +{ + return _num_attrs; +} + +inline +bool GlyphCache::Loader::has_boxes () const throw() +{ + return _has_boxes; +} + +const GlyphFace * GlyphCache::Loader::read_glyph(unsigned short glyphid, GlyphFace & glyph, int *numsubs) const throw() +{ + Rect bbox; + Position advance; + + if (glyphid < _num_glyphs_graphics) + { + int nLsb; + unsigned int nAdvWid; + if (_glyf) + { + int xMin, yMin, xMax, yMax; + size_t locidx = TtfUtil::LocaLookup(glyphid, _loca, _loca.size(), _head); + void *pGlyph = TtfUtil::GlyfLookup(_glyf, locidx, _glyf.size()); + + if (pGlyph && TtfUtil::GlyfBox(pGlyph, xMin, yMin, xMax, yMax)) + { + if ((xMin > xMax) || (yMin > yMax)) + return 0; + bbox = Rect(Position(static_cast<float>(xMin), static_cast<float>(yMin)), + Position(static_cast<float>(xMax), static_cast<float>(yMax))); + } + } + if (TtfUtil::HorMetrics(glyphid, _hmtx, _hmtx.size(), _hhea, nLsb, nAdvWid)) + advance = Position(static_cast<float>(nAdvWid), 0); + } + + if (glyphid < _num_glyphs_attributes) + { + const byte * gloc = m_pGloc; + size_t glocs = 0, gloce = 0; + + be::skip<uint32>(gloc); + be::skip<uint16>(gloc,2); + if (_long_fmt) + { + if (8 + glyphid * sizeof(uint32) > m_pGloc.size()) + return 0; + be::skip<uint32>(gloc, glyphid); + glocs = be::read<uint32>(gloc); + gloce = be::peek<uint32>(gloc); + } + else + { + if (8 + glyphid * sizeof(uint16) > m_pGloc.size()) + return 0; + be::skip<uint16>(gloc, glyphid); + glocs = be::read<uint16>(gloc); + gloce = be::peek<uint16>(gloc); + } + + if (glocs >= m_pGlat.size() - 1 || gloce > m_pGlat.size()) + return 0; + + const uint32 glat_version = be::peek<uint32>(m_pGlat); + if (glat_version >= 0x00030000) + { + if (glocs >= gloce) + return 0; + const byte * p = m_pGlat + glocs; + uint16 bmap = be::read<uint16>(p); + int num = bit_set_count((uint32)bmap); + if (numsubs) *numsubs += num; + glocs += 6 + 8 * num; + if (glocs > gloce) + return 0; + } + if (glat_version < 0x00020000) + { + if (gloce - glocs < 2*sizeof(byte)+sizeof(uint16) + || gloce - glocs > _num_attrs*(2*sizeof(byte)+sizeof(uint16))) + return 0; + new (&glyph) GlyphFace(bbox, advance, glat_iterator(m_pGlat + glocs), glat_iterator(m_pGlat + gloce)); + } + else + { + if (gloce - glocs < 3*sizeof(uint16) // can a glyph have no attributes? why not? + || gloce - glocs > _num_attrs*3*sizeof(uint16) + || glocs > m_pGlat.size() - 2*sizeof(uint16)) + return 0; + new (&glyph) GlyphFace(bbox, advance, glat2_iterator(m_pGlat + glocs), glat2_iterator(m_pGlat + gloce)); + } + if (!glyph.attrs() || glyph.attrs().capacity() > _num_attrs) + return 0; + } + return &glyph; +} + +inline float scale_to(uint8 t, float zmin, float zmax) +{ + return (zmin + t * (zmax - zmin) / 255); +} + +Rect readbox(Rect &b, uint8 zxmin, uint8 zymin, uint8 zxmax, uint8 zymax) +{ + return Rect(Position(scale_to(zxmin, b.bl.x, b.tr.x), scale_to(zymin, b.bl.y, b.tr.y)), + Position(scale_to(zxmax, b.bl.x, b.tr.x), scale_to(zymax, b.bl.y, b.tr.y))); +} + +GlyphBox * GlyphCache::Loader::read_box(uint16 gid, GlyphBox *curr, const GlyphFace & glyph) const throw() +{ + if (gid >= _num_glyphs_attributes) return 0; + + const byte * gloc = m_pGloc; + size_t glocs = 0, gloce = 0; + + be::skip<uint32>(gloc); + be::skip<uint16>(gloc,2); + if (_long_fmt) + { + be::skip<uint32>(gloc, gid); + glocs = be::read<uint32>(gloc); + gloce = be::peek<uint32>(gloc); + } + else + { + be::skip<uint16>(gloc, gid); + glocs = be::read<uint16>(gloc); + gloce = be::peek<uint16>(gloc); + } + + if (gloce > m_pGlat.size() || glocs + 6 >= gloce) + return 0; + + const byte * p = m_pGlat + glocs; + uint16 bmap = be::read<uint16>(p); + int num = bit_set_count((uint32)bmap); + + Rect bbox = glyph.theBBox(); + Rect diamax(Position(bbox.bl.x + bbox.bl.y, bbox.bl.x - bbox.tr.y), + Position(bbox.tr.x + bbox.tr.y, bbox.tr.x - bbox.bl.y)); + Rect diabound = readbox(diamax, p[0], p[2], p[1], p[3]); + ::new (curr) GlyphBox(num, bmap, &diabound); + be::skip<uint8>(p, 4); + if (glocs + 6 + num * 8 >= gloce) + return 0; + + for (int i = 0; i < num * 2; ++i) + { + Rect box = readbox((i & 1) ? diamax : bbox, p[0], p[2], p[1], p[3]); + curr->addSubBox(i >> 1, i & 1, &box); + be::skip<uint8>(p, 4); + } + return (GlyphBox *)((char *)(curr) + sizeof(GlyphBox) + 2 * num * sizeof(Rect)); +} diff --git a/gfx/graphite2/src/GlyphFace.cpp b/gfx/graphite2/src/GlyphFace.cpp new file mode 100644 index 0000000000..bc5e63a9f0 --- /dev/null +++ b/gfx/graphite2/src/GlyphFace.cpp @@ -0,0 +1,48 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/GlyphFace.h" + + +using namespace graphite2; + +int32 GlyphFace::getMetric(uint8 metric) const +{ + switch (metrics(metric)) + { + case kgmetLsb : return int32(m_bbox.bl.x); + case kgmetRsb : return int32(m_advance.x - m_bbox.tr.x); + case kgmetBbTop : return int32(m_bbox.tr.y); + case kgmetBbBottom : return int32(m_bbox.bl.y); + case kgmetBbLeft : return int32(m_bbox.bl.x); + case kgmetBbRight : return int32(m_bbox.tr.x); + case kgmetBbHeight : return int32(m_bbox.tr.y - m_bbox.bl.y); + case kgmetBbWidth : return int32(m_bbox.tr.x - m_bbox.bl.x); + case kgmetAdvWidth : return int32(m_advance.x); + case kgmetAdvHeight : return int32(m_advance.y); + default : return 0; + } +} diff --git a/gfx/graphite2/src/Intervals.cpp b/gfx/graphite2/src/Intervals.cpp new file mode 100644 index 0000000000..0fe99a127a --- /dev/null +++ b/gfx/graphite2/src/Intervals.cpp @@ -0,0 +1,298 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <algorithm> +#include <cmath> +#include <limits> + +#include "inc/Intervals.h" +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/debug.h" +#include "inc/bits.h" + +using namespace graphite2; + +#include <cmath> + +inline +Zones::Exclusion Zones::Exclusion::split_at(float p) { + Exclusion r(*this); + r.xm = x = p; + return r; +} + +inline +void Zones::Exclusion::left_trim(float p) { + x = p; +} + +inline +Zones::Exclusion & Zones::Exclusion::operator += (Exclusion const & rhs) { + c += rhs.c; sm += rhs.sm; smx += rhs.smx; open = false; + return *this; +} + +inline +uint8 Zones::Exclusion::outcode(float val) const { + float p = val; + //float d = std::numeric_limits<float>::epsilon(); + float d = 0.; + return ((p - xm >= d) << 1) | (x - p > d); +} + +void Zones::exclude_with_margins(float xmin, float xmax, int axis) { + remove(xmin, xmax); + weightedAxis(axis, xmin-_margin_len, xmin, 0, 0, _margin_weight, xmin-_margin_len, 0, 0, false); + weightedAxis(axis, xmax, xmax+_margin_len, 0, 0, _margin_weight, xmax+_margin_len, 0, 0, false); +} + +namespace +{ + +inline +bool separated(float a, float b) { + return a != b; + //int exp; + //float res = frexpf(fabs(a - b), &exp); + //return (*(unsigned int *)(&res) > 4); + //return std::fabs(a-b) > std::numeric_limits<float>::epsilon(); // std::epsilon may not work. but 0.5 fails exising 64 bit tests + //return std::fabs(a-b) > 0.5f; +} + +} + +void Zones::insert(Exclusion e) +{ +#if !defined GRAPHITE2_NTRACING + addDebug(&e); +#endif + e.x = max(e.x, _pos); + e.xm = min(e.xm, _posm); + if (e.x >= e.xm) return; + + for (iterator i = _exclusions.begin(), ie = _exclusions.end(); i != ie && e.x < e.xm; ++i) + { + const uint8 oca = e.outcode(i->x), + ocb = e.outcode(i->xm); + if ((oca & ocb) != 0) continue; + + switch (oca ^ ocb) // What kind of overlap? + { + case 0: // e completely covers i + // split e at i.x into e1,e2 + // split e2 at i.mx into e2,e3 + // drop e1 ,i+e2, e=e3 + *i += e; + e.left_trim(i->xm); + break; + case 1: // e overlaps on the rhs of i + // split i at e->x into i1,i2 + // split e at i.mx into e1,e2 + // trim i1, insert i2+e1, e=e2 + if (!separated(i->xm, e.x)) break; + if (separated(i->x,e.x)) { i = _exclusions.insert(i,i->split_at(e.x)); ++i; } + *i += e; + e.left_trim(i->xm); + break; + case 2: // e overlaps on the lhs of i + // split e at i->x into e1,e2 + // split i at e.mx into i1,i2 + // drop e1, insert e2+i1, trim i2 + if (!separated(e.xm, i->x)) return; + if (separated(e.xm, i->xm)) i = _exclusions.insert(i,i->split_at(e.xm)); + *i += e; + return; + case 3: // i completely covers e + // split i at e.x into i1,i2 + // split i2 at e.mx into i2,i3 + // insert i1, insert e+i2 + if (separated(e.xm, i->xm)) i = _exclusions.insert(i,i->split_at(e.xm)); + i = _exclusions.insert(i, i->split_at(e.x)); + *++i += e; + return; + } + + ie = _exclusions.end(); + } +} + + +void Zones::remove(float x, float xm) +{ +#if !defined GRAPHITE2_NTRACING + removeDebug(x, xm); +#endif + x = max(x, _pos); + xm = min(xm, _posm); + if (x >= xm) return; + + for (iterator i = _exclusions.begin(), ie = _exclusions.end(); i != ie; ++i) + { + const uint8 oca = i->outcode(x), + ocb = i->outcode(xm); + if ((oca & ocb) != 0) continue; + + switch (oca ^ ocb) // What kind of overlap? + { + case 0: // i completely covers e + if (separated(i->x, x)) { i = _exclusions.insert(i,i->split_at(x)); ++i; } + GR_FALLTHROUGH; + // no break + case 1: // i overlaps on the rhs of e + i->left_trim(xm); + return; + case 2: // i overlaps on the lhs of e + i->xm = x; + if (separated(i->x, i->xm)) break; + GR_FALLTHROUGH; + // no break + case 3: // e completely covers i + i = _exclusions.erase(i); + --i; + break; + } + + ie = _exclusions.end(); + } +} + + +Zones::const_iterator Zones::find_exclusion_under(float x) const +{ + size_t l = 0, h = _exclusions.size(); + + while (l < h) + { + size_t const p = (l+h) >> 1; + switch (_exclusions[p].outcode(x)) + { + case 0 : return _exclusions.begin()+p; + case 1 : h = p; break; + case 2 : + case 3 : l = p+1; break; + } + } + + return _exclusions.begin()+l; +} + + +float Zones::closest(float origin, float & cost) const +{ + float best_c = std::numeric_limits<float>::max(), + best_x = 0; + + const const_iterator start = find_exclusion_under(origin); + + // Forward scan looking for lowest cost + for (const_iterator i = start, ie = _exclusions.end(); i != ie; ++i) + if (i->track_cost(best_c, best_x, origin)) break; + + // Backward scan looking for lowest cost + // We start from the exclusion to the immediate left of start since we've + // already tested start with the right most scan above. + for (const_iterator i = start-1, ie = _exclusions.begin()-1; i != ie; --i) + if (i->track_cost(best_c, best_x, origin)) break; + + cost = (best_c == std::numeric_limits<float>::max() ? -1 : best_c); + return best_x; +} + + +// Cost and test position functions + +bool Zones::Exclusion::track_cost(float & best_cost, float & best_pos, float origin) const { + const float p = test_position(origin), + localc = cost(p - origin); + if (open && localc > best_cost) return true; + + if (localc < best_cost) + { + best_cost = localc; + best_pos = p; + } + return false; +} + +inline +float Zones::Exclusion::cost(float p) const { + return (sm * p - 2 * smx) * p + c; +} + + +float Zones::Exclusion::test_position(float origin) const { + if (sm < 0) + { + // sigh, test both ends and perhaps the middle too! + float res = x; + float cl = cost(x); + if (x < origin && xm > origin) + { + float co = cost(origin); + if (co < cl) + { + cl = co; + res = origin; + } + } + float cr = cost(xm); + return cl > cr ? xm : res; + } + else + { + float zerox = smx / sm + origin; + if (zerox < x) return x; + else if (zerox > xm) return xm; + else return zerox; + } +} + + +#if !defined GRAPHITE2_NTRACING + +void Zones::jsonDbgOut(Segment *seg) const { + + if (_dbg) + { + for (Zones::idebugs s = dbgs_begin(), e = dbgs_end(); s != e; ++s) + { + *_dbg << json::flat << json::array + << objectid(dslot(seg, (Slot *)(s->_env[0]))) + << reinterpret_cast<ptrdiff_t>(s->_env[1]); + if (s->_isdel) + *_dbg << "remove" << Position(s->_excl.x, s->_excl.xm); + else + *_dbg << "exclude" << json::flat << json::array + << s->_excl.x << s->_excl.xm + << s->_excl.sm << s->_excl.smx << s->_excl.c + << json::close; + *_dbg << json::close; + } + } +} + +#endif diff --git a/gfx/graphite2/src/Justifier.cpp b/gfx/graphite2/src/Justifier.cpp new file mode 100644 index 0000000000..78c11e6a51 --- /dev/null +++ b/gfx/graphite2/src/Justifier.cpp @@ -0,0 +1,282 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +#include "inc/Segment.h" +#include "graphite2/Font.h" +#include "inc/debug.h" +#include "inc/CharInfo.h" +#include "inc/Slot.h" +#include "inc/Main.h" +#include <cmath> + +using namespace graphite2; + +class JustifyTotal { +public: + JustifyTotal() : m_numGlyphs(0), m_tStretch(0), m_tShrink(0), m_tStep(0), m_tWeight(0) {} + void accumulate(Slot *s, Segment *seg, int level); + int weight() const { return m_tWeight; } + + CLASS_NEW_DELETE + +private: + int m_numGlyphs; + int m_tStretch; + int m_tShrink; + int m_tStep; + int m_tWeight; +}; + +void JustifyTotal::accumulate(Slot *s, Segment *seg, int level) +{ + ++m_numGlyphs; + m_tStretch += s->getJustify(seg, level, 0); + m_tShrink += s->getJustify(seg, level, 1); + m_tStep += s->getJustify(seg, level, 2); + m_tWeight += s->getJustify(seg, level, 3); +} + +float Segment::justify(Slot *pSlot, const Font *font, float width, GR_MAYBE_UNUSED justFlags jflags, Slot *pFirst, Slot *pLast) +{ + Slot *end = last(); + float currWidth = 0.0; + const float scale = font ? font->scale() : 1.0f; + Position res; + + if (width < 0 && !(silf()->flags())) + return width; + + if ((m_dir & 1) != m_silf->dir() && m_silf->bidiPass() != m_silf->numPasses()) + { + reverseSlots(); + std::swap(pFirst, pLast); + } + if (!pFirst) pFirst = pSlot; + while (!pFirst->isBase()) pFirst = pFirst->attachedTo(); + if (!pLast) pLast = last(); + while (!pLast->isBase()) pLast = pLast->attachedTo(); + const float base = pFirst->origin().x / scale; + width = width / scale; + if ((jflags & gr_justEndInline) == 0) + { + while (pLast != pFirst && pLast) + { + Rect bbox = theGlyphBBoxTemporary(pLast->glyph()); + if (bbox.bl.x != 0.f || bbox.bl.y != 0.f || bbox.tr.x != 0.f || bbox.tr.y == 0.f) + break; + pLast = pLast->prev(); + } + } + + if (pLast) + end = pLast->nextSibling(); + if (pFirst) + pFirst = pFirst->nextSibling(); + + int icount = 0; + int numLevels = silf()->numJustLevels(); + if (!numLevels) + { + for (Slot *s = pSlot; s && s != end; s = s->nextSibling()) + { + CharInfo *c = charinfo(s->before()); + if (isWhitespace(c->unicodeChar())) + { + s->setJustify(this, 0, 3, 1); + s->setJustify(this, 0, 2, 1); + s->setJustify(this, 0, 0, -1); + ++icount; + } + } + if (!icount) + { + for (Slot *s = pSlot; s && s != end; s = s->nextSibling()) + { + s->setJustify(this, 0, 3, 1); + s->setJustify(this, 0, 2, 1); + s->setJustify(this, 0, 0, -1); + } + } + ++numLevels; + } + + Vector<JustifyTotal> stats(numLevels); + for (Slot *s = pFirst; s && s != end; s = s->nextSibling()) + { + float w = s->origin().x / scale + s->advance() - base; + if (w > currWidth) currWidth = w; + for (int j = 0; j < numLevels; ++j) + stats[j].accumulate(s, this, j); + s->just(0); + } + + for (int i = (width < 0.0f) ? -1 : numLevels - 1; i >= 0; --i) + { + float diff; + float error = 0.; + float diffpw; + int tWeight = stats[i].weight(); + if (tWeight == 0) continue; + + do { + error = 0.; + diff = width - currWidth; + diffpw = diff / tWeight; + tWeight = 0; + for (Slot *s = pFirst; s && s != end; s = s->nextSibling()) // don't include final glyph + { + int w = s->getJustify(this, i, 3); + float pref = diffpw * w + error; + int step = s->getJustify(this, i, 2); + if (!step) step = 1; // handle lazy font developers + if (pref > 0) + { + float max = uint16(s->getJustify(this, i, 0)); + if (i == 0) max -= s->just(); + if (pref > max) pref = max; + else tWeight += w; + } + else + { + float max = uint16(s->getJustify(this, i, 1)); + if (i == 0) max += s->just(); + if (-pref > max) pref = -max; + else tWeight += w; + } + int actual = int(pref / step) * step; + + if (actual) + { + error += diffpw * w - actual; + if (i == 0) + s->just(s->just() + actual); + else + s->setJustify(this, i, 4, actual); + } + } + currWidth += diff - error; + } while (i == 0 && int(std::abs(error)) > 0 && tWeight); + } + + Slot *oldFirst = m_first; + Slot *oldLast = m_last; + if (silf()->flags() & 1) + { + m_first = pSlot = addLineEnd(pSlot); + m_last = pLast = addLineEnd(end); + if (!m_first || !m_last) return -1.0; + } + else + { + m_first = pSlot; + m_last = pLast; + } + + // run justification passes here +#if !defined GRAPHITE2_NTRACING + json * const dbgout = m_face->logger(); + if (dbgout) + *dbgout << json::object + << "justifies" << objectid(this) + << "passes" << json::array; +#endif + + if (m_silf->justificationPass() != m_silf->positionPass() && (width >= 0.f || (silf()->flags() & 1))) + m_silf->runGraphite(this, m_silf->justificationPass(), m_silf->positionPass()); + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + { + *dbgout << json::item << json::close; // Close up the passes array + positionSlots(NULL, pSlot, pLast, m_dir); + Slot *lEnd = pLast->nextSibling(); + *dbgout << "output" << json::array; + for(Slot * t = pSlot; t != lEnd; t = t->next()) + *dbgout << dslot(this, t); + *dbgout << json::close << json::close; + } +#endif + + res = positionSlots(font, pSlot, pLast, m_dir); + + if (silf()->flags() & 1) + { + if (m_first) + delLineEnd(m_first); + if (m_last) + delLineEnd(m_last); + } + m_first = oldFirst; + m_last = oldLast; + + if ((m_dir & 1) != m_silf->dir() && m_silf->bidiPass() != m_silf->numPasses()) + reverseSlots(); + return res.x; +} + +Slot *Segment::addLineEnd(Slot *nSlot) +{ + Slot *eSlot = newSlot(); + if (!eSlot) return NULL; + const uint16 gid = silf()->endLineGlyphid(); + const GlyphFace * theGlyph = m_face->glyphs().glyphSafe(gid); + eSlot->setGlyph(this, gid, theGlyph); + if (nSlot) + { + eSlot->next(nSlot); + eSlot->prev(nSlot->prev()); + nSlot->prev(eSlot); + eSlot->before(nSlot->before()); + if (eSlot->prev()) + eSlot->after(eSlot->prev()->after()); + else + eSlot->after(nSlot->before()); + } + else + { + nSlot = m_last; + eSlot->prev(nSlot); + nSlot->next(eSlot); + eSlot->after(eSlot->prev()->after()); + eSlot->before(nSlot->after()); + } + return eSlot; +} + +void Segment::delLineEnd(Slot *s) +{ + Slot *nSlot = s->next(); + if (nSlot) + { + nSlot->prev(s->prev()); + if (s->prev()) + s->prev()->next(nSlot); + } + else + s->prev()->next(NULL); + freeSlot(s); +} diff --git a/gfx/graphite2/src/MozGrMalloc.h b/gfx/graphite2/src/MozGrMalloc.h new file mode 100755 index 0000000000..5d6a9f3910 --- /dev/null +++ b/gfx/graphite2/src/MozGrMalloc.h @@ -0,0 +1,44 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef MOZ_GR_MALLOC_H +#define MOZ_GR_MALLOC_H + +// Override malloc() and friends to call moz_xmalloc() etc, so that we get +// predictable, safe OOM crashes rather than relying on the code to handle +// allocation failures reliably. + +#include "mozilla/mozalloc.h" + +#if defined(XP_LINUX) + +#define malloc moz_xmalloc +#define calloc moz_xcalloc +#define realloc moz_xrealloc + +#else + +// extern "C" is needed for the Solaris build, while the inline +// functions are needed for the MinGW build. They break gcc 5.4.0 +// on Linux however, so keep the old #define's above for Linux + +extern "C" inline void* malloc(size_t size) +{ + return moz_xmalloc(size); +} + +extern "C" inline void* calloc(size_t nmemb, size_t size) +{ + return moz_xcalloc(nmemb, size); +} + +extern "C" inline void* realloc(void *ptr, size_t size) +{ + return moz_xrealloc(ptr, size); +} + +#endif // defined(XP_LINUX) + +#endif // MOZ_GR_MALLOC_H diff --git a/gfx/graphite2/src/NameTable.cpp b/gfx/graphite2/src/NameTable.cpp new file mode 100644 index 0000000000..d42b7f95bd --- /dev/null +++ b/gfx/graphite2/src/NameTable.cpp @@ -0,0 +1,254 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/Main.h" +#include "inc/Endian.h" + +#include "inc/NameTable.h" +#include "inc/UtfCodec.h" + +using namespace graphite2; + +NameTable::NameTable(const void* data, size_t length, uint16 platformId, uint16 encodingID) + : m_platformId(0), m_encodingId(0), m_languageCount(0), + m_platformOffset(0), m_platformLastRecord(0), m_nameDataLength(0), + m_table(0), m_nameData(NULL) +{ + void *pdata = gralloc<byte>(length); + if (!pdata) return; + memcpy(pdata, data, length); + m_table = reinterpret_cast<const TtfUtil::Sfnt::FontNames*>(pdata); + + if ((length > sizeof(TtfUtil::Sfnt::FontNames)) && + (length > sizeof(TtfUtil::Sfnt::FontNames) + + sizeof(TtfUtil::Sfnt::NameRecord) * ( be::swap<uint16>(m_table->count) - 1))) + { + uint16 offset = be::swap<uint16>(m_table->string_offset); + if (offset < length) + { + m_nameData = reinterpret_cast<const uint8*>(pdata) + offset; + setPlatformEncoding(platformId, encodingID); + m_nameDataLength = uint16(length - offset); + return; + } + } + free(const_cast<TtfUtil::Sfnt::FontNames*>(m_table)); + m_table = NULL; +} + +uint16 NameTable::setPlatformEncoding(uint16 platformId, uint16 encodingID) +{ + if (!m_nameData) return 0; + uint16 i = 0; + uint16 count = be::swap<uint16>(m_table->count); + for (; i < count; i++) + { + if (be::swap<uint16>(m_table->name_record[i].platform_id) == platformId && + be::swap<uint16>(m_table->name_record[i].platform_specific_id) == encodingID) + { + m_platformOffset = i; + break; + } + } + while ((++i < count) && + (be::swap<uint16>(m_table->name_record[i].platform_id) == platformId) && + (be::swap<uint16>(m_table->name_record[i].platform_specific_id) == encodingID)) + { + m_platformLastRecord = i; + } + m_encodingId = encodingID; + m_platformId = platformId; + return 0; +} + +void* NameTable::getName(uint16& languageId, uint16 nameId, gr_encform enc, uint32& length) +{ + uint16 anyLang = 0; + uint16 enUSLang = 0; + uint16 bestLang = 0; + if (!m_table) + { + languageId = 0; + length = 0; + return NULL; + } + for (uint16 i = m_platformOffset; i <= m_platformLastRecord; i++) + { + if (be::swap<uint16>(m_table->name_record[i].name_id) == nameId) + { + uint16 langId = be::swap<uint16>(m_table->name_record[i].language_id); + if (langId == languageId) + { + bestLang = i; + break; + } + // MS language tags have the language in the lower byte, region in the higher + else if ((langId & 0xFF) == (languageId & 0xFF)) + { + bestLang = i; + } + else if (langId == 0x409) + { + enUSLang = i; + } + else + { + anyLang = i; + } + } + } + if (!bestLang) + { + if (enUSLang) bestLang = enUSLang; + else + { + bestLang = anyLang; + if (!anyLang) + { + languageId = 0; + length = 0; + return NULL; + } + } + } + const TtfUtil::Sfnt::NameRecord & nameRecord = m_table->name_record[bestLang]; + languageId = be::swap<uint16>(nameRecord.language_id); + uint16 utf16Length = be::swap<uint16>(nameRecord.length); + uint16 offset = be::swap<uint16>(nameRecord.offset); + if(offset + utf16Length > m_nameDataLength) + { + languageId = 0; + length = 0; + return NULL; + } + utf16Length >>= 1; // in utf16 units + utf16::codeunit_t * utf16Name = gralloc<utf16::codeunit_t>(utf16Length + 1); + if (!utf16Name) + { + languageId = 0; + length = 0; + return NULL; + } + const uint8* pName = m_nameData + offset; + for (size_t i = 0; i < utf16Length; i++) + { + utf16Name[i] = be::read<uint16>(pName); + } + utf16Name[utf16Length] = 0; + if (!utf16::validate(utf16Name, utf16Name + utf16Length)) + { + free(utf16Name); + languageId = 0; + length = 0; + return NULL; + } + switch (enc) + { + case gr_utf8: + { + utf8::codeunit_t* uniBuffer = gralloc<utf8::codeunit_t>(3 * utf16Length + 1); + if (!uniBuffer) + { + free(utf16Name); + languageId = 0; + length = 0; + return NULL; + } + utf8::iterator d = uniBuffer; + for (utf16::const_iterator s = utf16Name, e = utf16Name + utf16Length; s != e; ++s, ++d) + *d = *s; + length = uint32(d - uniBuffer); + uniBuffer[length] = 0; + free(utf16Name); + return uniBuffer; + } + case gr_utf16: + length = utf16Length; + return utf16Name; + case gr_utf32: + { + utf32::codeunit_t * uniBuffer = gralloc<utf32::codeunit_t>(utf16Length + 1); + if (!uniBuffer) + { + free(utf16Name); + languageId = 0; + length = 0; + return NULL; + } + utf32::iterator d = uniBuffer; + for (utf16::const_iterator s = utf16Name, e = utf16Name + utf16Length; s != e; ++s, ++d) + *d = *s; + length = uint32(d - uniBuffer); + uniBuffer[length] = 0; + free(utf16Name); + return uniBuffer; + } + } + free(utf16Name); + languageId = 0; + length = 0; + return NULL; +} + +uint16 NameTable::getLanguageId(const char * bcp47Locale) +{ + size_t localeLength = strlen(bcp47Locale); + uint16 localeId = m_locale2Lang.getMsId(bcp47Locale); + if (m_table && (be::swap<uint16>(m_table->format) == 1)) + { + const uint8 * pLangEntries = reinterpret_cast<const uint8*>(m_table) + + sizeof(TtfUtil::Sfnt::FontNames) + + sizeof(TtfUtil::Sfnt::NameRecord) * ( be::swap<uint16>(m_table->count) - 1); + uint16 numLangEntries = be::read<uint16>(pLangEntries); + const TtfUtil::Sfnt::LangTagRecord * langTag = + reinterpret_cast<const TtfUtil::Sfnt::LangTagRecord*>(pLangEntries); + if (pLangEntries + numLangEntries * sizeof(TtfUtil::Sfnt::LangTagRecord) <= m_nameData) + { + for (uint16 i = 0; i < numLangEntries; i++) + { + uint16 offset = be::swap<uint16>(langTag[i].offset); + uint16 length = be::swap<uint16>(langTag[i].length); + if ((offset + length <= m_nameDataLength) && (length == 2 * localeLength)) + { + const uint8* pName = m_nameData + offset; + bool match = true; + for (size_t j = 0; j < localeLength; j++) + { + uint16 code = be::read<uint16>(pName); + if ((code > 0x7F) || (code != bcp47Locale[j])) + { + match = false; + break; + } + } + if (match) + return 0x8000 + i; + } + } + } + } + return localeId; +} diff --git a/gfx/graphite2/src/Pass.cpp b/gfx/graphite2/src/Pass.cpp new file mode 100644 index 0000000000..db31c22d46 --- /dev/null +++ b/gfx/graphite2/src/Pass.cpp @@ -0,0 +1,1107 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/Main.h" +#include "inc/debug.h" +#include "inc/Endian.h" +#include "inc/Pass.h" +#include <cstring> +#include <cstdlib> +#include <cassert> +#include <cmath> +#include "inc/Segment.h" +#include "inc/Code.h" +#include "inc/Rule.h" +#include "inc/Error.h" +#include "inc/Collider.h" + +using namespace graphite2; +using vm::Machine; +typedef Machine::Code Code; + +enum KernCollison +{ + None = 0, + CrossSpace = 1, + InWord = 2, + reserved = 3 +}; + +Pass::Pass() +: m_silf(0), + m_cols(0), + m_rules(0), + m_ruleMap(0), + m_startStates(0), + m_transitions(0), + m_states(0), + m_codes(0), + m_progs(0), + m_numCollRuns(0), + m_kernColls(0), + m_iMaxLoop(0), + m_numGlyphs(0), + m_numRules(0), + m_numStates(0), + m_numTransition(0), + m_numSuccess(0), + m_successStart(0), + m_numColumns(0), + m_minPreCtxt(0), + m_maxPreCtxt(0), + m_colThreshold(0), + m_isReverseDir(false) +{ +} + +Pass::~Pass() +{ + free(m_cols); + free(m_startStates); + free(m_transitions); + free(m_states); + free(m_ruleMap); + + if (m_rules) delete [] m_rules; + if (m_codes) delete [] m_codes; + free(m_progs); +} + +bool Pass::readPass(const byte * const pass_start, size_t pass_length, size_t subtable_base, + GR_MAYBE_UNUSED Face & face, passtype pt, GR_MAYBE_UNUSED uint32 version, Error &e) +{ + const byte * p = pass_start, + * const pass_end = p + pass_length; + size_t numRanges; + + if (e.test(pass_length < 40, E_BADPASSLENGTH)) return face.error(e); + // Read in basic values + const byte flags = be::read<byte>(p); + if (e.test((flags & 0x1f) && + (pt < PASS_TYPE_POSITIONING || !m_silf->aCollision() || !face.glyphs().hasBoxes() || !(m_silf->flags() & 0x20)), + E_BADCOLLISIONPASS)) + return face.error(e); + m_numCollRuns = flags & 0x7; + m_kernColls = (flags >> 3) & 0x3; + m_isReverseDir = (flags >> 5) & 0x1; + m_iMaxLoop = be::read<byte>(p); + if (m_iMaxLoop < 1) m_iMaxLoop = 1; + be::skip<byte>(p,2); // skip maxContext & maxBackup + m_numRules = be::read<uint16>(p); + if (e.test(!m_numRules && m_numCollRuns == 0, E_BADEMPTYPASS)) return face.error(e); + be::skip<uint16>(p); // fsmOffset - not sure why we would want this + const byte * const pcCode = pass_start + be::read<uint32>(p) - subtable_base, + * const rcCode = pass_start + be::read<uint32>(p) - subtable_base, + * const aCode = pass_start + be::read<uint32>(p) - subtable_base; + be::skip<uint32>(p); + m_numStates = be::read<uint16>(p); + m_numTransition = be::read<uint16>(p); + m_numSuccess = be::read<uint16>(p); + m_numColumns = be::read<uint16>(p); + numRanges = be::read<uint16>(p); + be::skip<uint16>(p, 3); // skip searchRange, entrySelector & rangeShift. + assert(p - pass_start == 40); + // Perform some sanity checks. + if ( e.test(m_numTransition > m_numStates, E_BADNUMTRANS) + || e.test(m_numSuccess > m_numStates, E_BADNUMSUCCESS) + || e.test(m_numSuccess + m_numTransition < m_numStates, E_BADNUMSTATES) + || e.test(m_numRules && numRanges == 0, E_NORANGES) + || e.test(m_numColumns > 0x7FFF, E_BADNUMCOLUMNS)) + return face.error(e); + + m_successStart = m_numStates - m_numSuccess; + // test for beyond end - 1 to account for reading uint16 + if (e.test(p + numRanges * 6 - 2 > pass_end, E_BADPASSLENGTH)) return face.error(e); + m_numGlyphs = be::peek<uint16>(p + numRanges * 6 - 4) + 1; + // Calculate the start of various arrays. + const byte * const ranges = p; + be::skip<uint16>(p, numRanges*3); + const byte * const o_rule_map = p; + be::skip<uint16>(p, m_numSuccess + 1); + + // More sanity checks + if (e.test(reinterpret_cast<const byte *>(o_rule_map + m_numSuccess*sizeof(uint16)) > pass_end + || p > pass_end, E_BADRULEMAPLEN)) + return face.error(e); + const size_t numEntries = be::peek<uint16>(o_rule_map + m_numSuccess*sizeof(uint16)); + const byte * const rule_map = p; + be::skip<uint16>(p, numEntries); + + if (e.test(p + 2*sizeof(uint8) > pass_end, E_BADPASSLENGTH)) return face.error(e); + m_minPreCtxt = be::read<uint8>(p); + m_maxPreCtxt = be::read<uint8>(p); + if (e.test(m_minPreCtxt > m_maxPreCtxt, E_BADCTXTLENBOUNDS)) return face.error(e); + const byte * const start_states = p; + be::skip<int16>(p, m_maxPreCtxt - m_minPreCtxt + 1); + const uint16 * const sort_keys = reinterpret_cast<const uint16 *>(p); + be::skip<uint16>(p, m_numRules); + const byte * const precontext = p; + be::skip<byte>(p, m_numRules); + + if (e.test(p + sizeof(uint16) + sizeof(uint8) > pass_end, E_BADCTXTLENS)) return face.error(e); + m_colThreshold = be::read<uint8>(p); + if (m_colThreshold == 0) m_colThreshold = 10; // A default + const size_t pass_constraint_len = be::read<uint16>(p); + + const uint16 * const o_constraint = reinterpret_cast<const uint16 *>(p); + be::skip<uint16>(p, m_numRules + 1); + const uint16 * const o_actions = reinterpret_cast<const uint16 *>(p); + be::skip<uint16>(p, m_numRules + 1); + const byte * const states = p; + if (e.test(2u*m_numTransition*m_numColumns >= (unsigned)(pass_end - p), E_BADPASSLENGTH) + || e.test(p >= pass_end, E_BADPASSLENGTH)) + return face.error(e); + be::skip<int16>(p, m_numTransition*m_numColumns); + be::skip<uint8>(p); + if (e.test(p != pcCode, E_BADPASSCCODEPTR)) return face.error(e); + be::skip<byte>(p, pass_constraint_len); + if (e.test(p != rcCode, E_BADRULECCODEPTR) + || e.test(size_t(rcCode - pcCode) != pass_constraint_len, E_BADCCODELEN)) return face.error(e); + be::skip<byte>(p, be::peek<uint16>(o_constraint + m_numRules)); + if (e.test(p != aCode, E_BADACTIONCODEPTR)) return face.error(e); + be::skip<byte>(p, be::peek<uint16>(o_actions + m_numRules)); + + // We should be at the end or within the pass + if (e.test(p > pass_end, E_BADPASSLENGTH)) return face.error(e); + + // Load the pass constraint if there is one. + if (pass_constraint_len) + { + face.error_context(face.error_context() + 1); + m_cPConstraint = vm::Machine::Code(true, pcCode, pcCode + pass_constraint_len, + precontext[0], be::peek<uint16>(sort_keys), *m_silf, face, PASS_TYPE_UNKNOWN); + if (e.test(!m_cPConstraint, E_OUTOFMEM) + || e.test(m_cPConstraint.status() != Code::loaded, m_cPConstraint.status() + E_CODEFAILURE)) + return face.error(e); + face.error_context(face.error_context() - 1); + } + if (m_numRules) + { + if (!readRanges(ranges, numRanges, e)) return face.error(e); + if (!readRules(rule_map, numEntries, precontext, sort_keys, + o_constraint, rcCode, o_actions, aCode, face, pt, e)) return false; + } +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _states_cat(face.tele.states); +#endif + return m_numRules ? readStates(start_states, states, o_rule_map, face, e) : true; +} + + +bool Pass::readRules(const byte * rule_map, const size_t num_entries, + const byte *precontext, const uint16 * sort_key, + const uint16 * o_constraint, const byte *rc_data, + const uint16 * o_action, const byte * ac_data, + Face & face, passtype pt, Error &e) +{ + const byte * const ac_data_end = ac_data + be::peek<uint16>(o_action + m_numRules); + const byte * const rc_data_end = rc_data + be::peek<uint16>(o_constraint + m_numRules); + + precontext += m_numRules; + sort_key += m_numRules; + o_constraint += m_numRules; + o_action += m_numRules; + + // Load rules. + const byte * ac_begin = 0, * rc_begin = 0, + * ac_end = ac_data + be::peek<uint16>(o_action), + * rc_end = rc_data + be::peek<uint16>(o_constraint); + + // Allocate pools + m_rules = new Rule [m_numRules]; + m_codes = new Code [m_numRules*2]; + int totalSlots = 0; + const uint16 *tsort = sort_key; + for (int i = 0; i < m_numRules; ++i) + totalSlots += be::peek<uint16>(--tsort); + const size_t prog_pool_sz = vm::Machine::Code::estimateCodeDataOut(ac_end - ac_data + rc_end - rc_data, 2 * m_numRules, totalSlots); + m_progs = gralloc<byte>(prog_pool_sz); + byte * prog_pool_free = m_progs, + * prog_pool_end = m_progs + prog_pool_sz; + if (e.test(!(m_rules && m_codes && m_progs), E_OUTOFMEM)) return face.error(e); + + Rule * r = m_rules + m_numRules - 1; + for (size_t n = m_numRules; r >= m_rules; --n, --r, ac_end = ac_begin, rc_end = rc_begin) + { + face.error_context((face.error_context() & 0xFFFF00) + EC_ARULE + int((n - 1) << 24)); + r->preContext = *--precontext; + r->sort = be::peek<uint16>(--sort_key); +#ifndef NDEBUG + r->rule_idx = uint16(n - 1); +#endif + if (r->sort > 63 || r->preContext >= r->sort || r->preContext > m_maxPreCtxt || r->preContext < m_minPreCtxt) + return false; + ac_begin = ac_data + be::peek<uint16>(--o_action); + --o_constraint; + rc_begin = be::peek<uint16>(o_constraint) ? rc_data + be::peek<uint16>(o_constraint) : rc_end; + + if (ac_begin > ac_end || ac_begin > ac_data_end || ac_end > ac_data_end + || rc_begin > rc_end || rc_begin > rc_data_end || rc_end > rc_data_end + || vm::Machine::Code::estimateCodeDataOut(ac_end - ac_begin + rc_end - rc_begin, 2, r->sort) > size_t(prog_pool_end - prog_pool_free)) + return false; + r->action = new (m_codes+n*2-2) vm::Machine::Code(false, ac_begin, ac_end, r->preContext, r->sort, *m_silf, face, pt, &prog_pool_free); + r->constraint = new (m_codes+n*2-1) vm::Machine::Code(true, rc_begin, rc_end, r->preContext, r->sort, *m_silf, face, pt, &prog_pool_free); + + if (e.test(!r->action || !r->constraint, E_OUTOFMEM) + || e.test(r->action->status() != Code::loaded, r->action->status() + E_CODEFAILURE) + || e.test(r->constraint->status() != Code::loaded, r->constraint->status() + E_CODEFAILURE) + || e.test(!r->constraint->immutable(), E_MUTABLECCODE)) + return face.error(e); + } + + byte * const moved_progs = prog_pool_free > m_progs ? static_cast<byte *>(realloc(m_progs, prog_pool_free - m_progs)) : 0; + if (e.test(!moved_progs, E_OUTOFMEM)) + { + free(m_progs); + m_progs = 0; + return face.error(e); + } + + if (moved_progs != m_progs) + { + for (Code * c = m_codes, * const ce = c + m_numRules*2; c != ce; ++c) + { + c->externalProgramMoved(moved_progs - m_progs); + } + m_progs = moved_progs; + } + + // Load the rule entries map + face.error_context((face.error_context() & 0xFFFF00) + EC_APASS); + //TODO: Coverity: 1315804: FORWARD_NULL + RuleEntry * re = m_ruleMap = gralloc<RuleEntry>(num_entries); + if (e.test(!re, E_OUTOFMEM)) return face.error(e); + for (size_t n = num_entries; n; --n, ++re) + { + const ptrdiff_t rn = be::read<uint16>(rule_map); + if (e.test(rn >= m_numRules, E_BADRULENUM)) return face.error(e); + re->rule = m_rules + rn; + } + + return true; +} + +static int cmpRuleEntry(const void *a, const void *b) { return (*(RuleEntry *)a < *(RuleEntry *)b ? -1 : + (*(RuleEntry *)b < *(RuleEntry *)a ? 1 : 0)); } + +bool Pass::readStates(const byte * starts, const byte *states, const byte * o_rule_map, GR_MAYBE_UNUSED Face & face, Error &e) +{ +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _states_cat(face.tele.starts); +#endif + m_startStates = gralloc<uint16>(m_maxPreCtxt - m_minPreCtxt + 1); +#ifdef GRAPHITE2_TELEMETRY + telemetry::set_category(face.tele.states); +#endif + m_states = gralloc<State>(m_numStates); +#ifdef GRAPHITE2_TELEMETRY + telemetry::set_category(face.tele.transitions); +#endif + m_transitions = gralloc<uint16>(m_numTransition * m_numColumns); + + if (e.test(!m_startStates || !m_states || !m_transitions, E_OUTOFMEM)) return face.error(e); + // load start states + for (uint16 * s = m_startStates, + * const s_end = s + m_maxPreCtxt - m_minPreCtxt + 1; s != s_end; ++s) + { + *s = be::read<uint16>(starts); + if (e.test(*s >= m_numStates, E_BADSTATE)) + { + face.error_context((face.error_context() & 0xFFFF00) + EC_ASTARTS + int((s - m_startStates) << 24)); + return face.error(e); // true; + } + } + + // load state transition table. + for (uint16 * t = m_transitions, + * const t_end = t + m_numTransition*m_numColumns; t != t_end; ++t) + { + *t = be::read<uint16>(states); + if (e.test(*t >= m_numStates, E_BADSTATE)) + { + face.error_context((face.error_context() & 0xFFFF00) + EC_ATRANS + int(((t - m_transitions) / m_numColumns) << 8)); + return face.error(e); + } + } + + State * s = m_states, + * const success_begin = m_states + m_numStates - m_numSuccess; + const RuleEntry * rule_map_end = m_ruleMap + be::peek<uint16>(o_rule_map + m_numSuccess*sizeof(uint16)); + for (size_t n = m_numStates; n; --n, ++s) + { + RuleEntry * const begin = s < success_begin ? 0 : m_ruleMap + be::read<uint16>(o_rule_map), + * const end = s < success_begin ? 0 : m_ruleMap + be::peek<uint16>(o_rule_map); + + if (e.test(begin >= rule_map_end || end > rule_map_end || begin > end, E_BADRULEMAPPING)) + { + face.error_context((face.error_context() & 0xFFFF00) + EC_ARULEMAP + int(n << 24)); + return face.error(e); + } + s->rules = begin; + s->rules_end = (end - begin <= FiniteStateMachine::MAX_RULES)? end : + begin + FiniteStateMachine::MAX_RULES; + if (begin) // keep UBSan happy can't call qsort with null begin + qsort(begin, end - begin, sizeof(RuleEntry), &cmpRuleEntry); + } + + return true; +} + +bool Pass::readRanges(const byte * ranges, size_t num_ranges, Error &e) +{ + m_cols = gralloc<uint16>(m_numGlyphs); + if (e.test(!m_cols, E_OUTOFMEM)) return false; + memset(m_cols, 0xFF, m_numGlyphs * sizeof(uint16)); + for (size_t n = num_ranges; n; --n) + { + uint16 * ci = m_cols + be::read<uint16>(ranges), + * ci_end = m_cols + be::read<uint16>(ranges) + 1, + col = be::read<uint16>(ranges); + + if (e.test(ci >= ci_end || ci_end > m_cols+m_numGlyphs || col >= m_numColumns, E_BADRANGE)) + return false; + + // A glyph must only belong to one column at a time + while (ci != ci_end && *ci == 0xffff) + *ci++ = col; + + if (e.test(ci != ci_end, E_BADRANGE)) + return false; + } + return true; +} + + +bool Pass::runGraphite(vm::Machine & m, FiniteStateMachine & fsm, bool reverse) const +{ + Slot *s = m.slotMap().segment.first(); + if (!s || !testPassConstraint(m)) return true; + if (reverse) + { + m.slotMap().segment.reverseSlots(); + s = m.slotMap().segment.first(); + } + if (m_numRules) + { + Slot *currHigh = s->next(); + +#if !defined GRAPHITE2_NTRACING + if (fsm.dbgout) *fsm.dbgout << "rules" << json::array; + json::closer rules_array_closer(fsm.dbgout); +#endif + + m.slotMap().highwater(currHigh); + int lc = m_iMaxLoop; + do + { + findNDoRule(s, m, fsm); + if (m.status() != Machine::finished) return false; + if (s && (s == m.slotMap().highwater() || m.slotMap().highpassed() || --lc == 0)) { + if (!lc) + s = m.slotMap().highwater(); + lc = m_iMaxLoop; + if (s) + m.slotMap().highwater(s->next()); + } + } while (s); + } + //TODO: Use enums for flags + const bool collisions = m_numCollRuns || m_kernColls; + + if (!collisions || !m.slotMap().segment.hasCollisionInfo()) + return true; + + if (m_numCollRuns) + { + if (!(m.slotMap().segment.flags() & Segment::SEG_INITCOLLISIONS)) + { + m.slotMap().segment.positionSlots(0, 0, 0, m.slotMap().dir(), true); +// m.slotMap().segment.flags(m.slotMap().segment.flags() | Segment::SEG_INITCOLLISIONS); + } + if (!collisionShift(&m.slotMap().segment, m.slotMap().dir(), fsm.dbgout)) + return false; + } + if ((m_kernColls) && !collisionKern(&m.slotMap().segment, m.slotMap().dir(), fsm.dbgout)) + return false; + if (collisions && !collisionFinish(&m.slotMap().segment, fsm.dbgout)) + return false; + return true; +} + +bool Pass::runFSM(FiniteStateMachine& fsm, Slot * slot) const +{ + fsm.reset(slot, m_maxPreCtxt); + if (fsm.slots.context() < m_minPreCtxt) + return false; + + uint16 state = m_startStates[m_maxPreCtxt - fsm.slots.context()]; + uint8 free_slots = SlotMap::MAX_SLOTS; + do + { + fsm.slots.pushSlot(slot); + if (slot->gid() >= m_numGlyphs + || m_cols[slot->gid()] == 0xffffU + || --free_slots == 0 + || state >= m_numTransition) + return free_slots != 0; + + const uint16 * transitions = m_transitions + state*m_numColumns; + state = transitions[m_cols[slot->gid()]]; + if (state >= m_successStart) + fsm.rules.accumulate_rules(m_states[state]); + + slot = slot->next(); + } while (state != 0 && slot); + + fsm.slots.pushSlot(slot); + return true; +} + +#if !defined GRAPHITE2_NTRACING + +inline +Slot * input_slot(const SlotMap & slots, const int n) +{ + Slot * s = slots[slots.context() + n]; + if (!s->isCopied()) return s; + + return s->prev() ? s->prev()->next() : (s->next() ? s->next()->prev() : slots.segment.last()); +} + +inline +Slot * output_slot(const SlotMap & slots, const int n) +{ + Slot * s = slots[slots.context() + n - 1]; + return s ? s->next() : slots.segment.first(); +} + +#endif //!defined GRAPHITE2_NTRACING + +void Pass::findNDoRule(Slot * & slot, Machine &m, FiniteStateMachine & fsm) const +{ + assert(slot); + + if (runFSM(fsm, slot)) + { + // Search for the first rule which passes the constraint + const RuleEntry * r = fsm.rules.begin(), + * const re = fsm.rules.end(); + while (r != re && !testConstraint(*r->rule, m)) + { + ++r; + if (m.status() != Machine::finished) + return; + } + +#if !defined GRAPHITE2_NTRACING + if (fsm.dbgout) + { + if (fsm.rules.size() != 0) + { + *fsm.dbgout << json::item << json::object; + dumpRuleEventConsidered(fsm, *r); + if (r != re) + { + const int adv = doAction(r->rule->action, slot, m); + dumpRuleEventOutput(fsm, *r->rule, slot); + if (r->rule->action->deletes()) fsm.slots.collectGarbage(slot); + adjustSlot(adv, slot, fsm.slots); + *fsm.dbgout << "cursor" << objectid(dslot(&fsm.slots.segment, slot)) + << json::close; // Close RuelEvent object + + return; + } + else + { + *fsm.dbgout << json::close // close "considered" array + << "output" << json::null + << "cursor" << objectid(dslot(&fsm.slots.segment, slot->next())) + << json::close; + } + } + } + else +#endif + { + if (r != re) + { + const int adv = doAction(r->rule->action, slot, m); + if (m.status() != Machine::finished) return; + if (r->rule->action->deletes()) fsm.slots.collectGarbage(slot); + adjustSlot(adv, slot, fsm.slots); + return; + } + } + } + + slot = slot->next(); + return; +} + +#if !defined GRAPHITE2_NTRACING + +void Pass::dumpRuleEventConsidered(const FiniteStateMachine & fsm, const RuleEntry & re) const +{ + *fsm.dbgout << "considered" << json::array; + for (const RuleEntry *r = fsm.rules.begin(); r != &re; ++r) + { + if (r->rule->preContext > fsm.slots.context()) + continue; + *fsm.dbgout << json::flat << json::object + << "id" << r->rule - m_rules + << "failed" << true + << "input" << json::flat << json::object + << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, -r->rule->preContext))) + << "length" << r->rule->sort + << json::close // close "input" + << json::close; // close Rule object + } +} + + +void Pass::dumpRuleEventOutput(const FiniteStateMachine & fsm, const Rule & r, Slot * const last_slot) const +{ + *fsm.dbgout << json::item << json::flat << json::object + << "id" << &r - m_rules + << "failed" << false + << "input" << json::flat << json::object + << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, 0))) + << "length" << r.sort - r.preContext + << json::close // close "input" + << json::close // close Rule object + << json::close // close considered array + << "output" << json::object + << "range" << json::flat << json::object + << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, 0))) + << "end" << objectid(dslot(&fsm.slots.segment, last_slot)) + << json::close // close "input" + << "slots" << json::array; + const Position rsb_prepos = last_slot ? last_slot->origin() : fsm.slots.segment.advance(); + fsm.slots.segment.positionSlots(0, 0, 0, fsm.slots.segment.currdir()); + + for(Slot * slot = output_slot(fsm.slots, 0); slot != last_slot; slot = slot->next()) + *fsm.dbgout << dslot(&fsm.slots.segment, slot); + *fsm.dbgout << json::close // close "slots" + << "postshift" << (last_slot ? last_slot->origin() : fsm.slots.segment.advance()) - rsb_prepos + << json::close; // close "output" object + +} + +#endif + + +inline +bool Pass::testPassConstraint(Machine & m) const +{ + if (!m_cPConstraint) return true; + + assert(m_cPConstraint.constraint()); + + m.slotMap().reset(*m.slotMap().segment.first(), 0); + m.slotMap().pushSlot(m.slotMap().segment.first()); + vm::slotref * map = m.slotMap().begin(); + const uint32 ret = m_cPConstraint.run(m, map); + +#if !defined GRAPHITE2_NTRACING + json * const dbgout = m.slotMap().segment.getFace()->logger(); + if (dbgout) + *dbgout << "constraint" << (ret && m.status() == Machine::finished); +#endif + + return ret && m.status() == Machine::finished; +} + + +bool Pass::testConstraint(const Rule & r, Machine & m) const +{ + const uint16 curr_context = m.slotMap().context(); + if (unsigned(r.sort + curr_context - r.preContext) > m.slotMap().size() + || curr_context - r.preContext < 0) return false; + + vm::slotref * map = m.slotMap().begin() + curr_context - r.preContext; + if (map[r.sort - 1] == 0) + return false; + + if (!*r.constraint) return true; + assert(r.constraint->constraint()); + for (int n = r.sort; n && map; --n, ++map) + { + if (!*map) continue; + const int32 ret = r.constraint->run(m, map); + if (!ret || m.status() != Machine::finished) + return false; + } + + return true; +} + + +void SlotMap::collectGarbage(Slot * &aSlot) +{ + for(Slot **s = begin(), *const *const se = end() - 1; s != se; ++s) { + Slot *& slot = *s; + if(slot && (slot->isDeleted() || slot->isCopied())) + { + if (slot == aSlot) + aSlot = slot->prev() ? slot->prev() : slot->next(); + segment.freeSlot(slot); + } + } +} + + + +int Pass::doAction(const Code *codeptr, Slot * & slot_out, vm::Machine & m) const +{ + assert(codeptr); + if (!*codeptr) return 0; + SlotMap & smap = m.slotMap(); + vm::slotref * map = &smap[smap.context()]; + smap.highpassed(false); + + int32 ret = codeptr->run(m, map); + + if (m.status() != Machine::finished) + { + slot_out = NULL; + smap.highwater(0); + return 0; + } + + slot_out = *map; + return ret; +} + + +void Pass::adjustSlot(int delta, Slot * & slot_out, SlotMap & smap) const +{ + if (!slot_out) + { + if (smap.highpassed() || slot_out == smap.highwater()) + { + slot_out = smap.segment.last(); + ++delta; + if (!smap.highwater() || smap.highwater() == slot_out) + smap.highpassed(false); + } + else + { + slot_out = smap.segment.first(); + --delta; + } + } + if (delta < 0) + { + while (++delta <= 0 && slot_out) + { + slot_out = slot_out->prev(); + if (smap.highpassed() && smap.highwater() == slot_out) + smap.highpassed(false); + } + } + else if (delta > 0) + { + while (--delta >= 0 && slot_out) + { + if (slot_out == smap.highwater() && slot_out) + smap.highpassed(true); + slot_out = slot_out->next(); + } + } +} + +bool Pass::collisionShift(Segment *seg, int dir, json * const dbgout) const +{ + ShiftCollider shiftcoll(dbgout); + // bool isfirst = true; + bool hasCollisions = false; + Slot *start = seg->first(); // turn on collision fixing for the first slot + Slot *end = NULL; + bool moved = false; + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << "collisions" << json::array + << json::flat << json::object << "num-loops" << m_numCollRuns << json::close; +#endif + + while (start) + { +#if !defined GRAPHITE2_NTRACING + if (dbgout) *dbgout << json::object << "phase" << "1" << "moves" << json::array; +#endif + hasCollisions = false; + end = NULL; + // phase 1 : position shiftable glyphs, ignoring kernable glyphs + for (Slot *s = start; s; s = s->next()) + { + const SlotCollision * c = seg->collisionInfo(s); + if (start && (c->flags() & (SlotCollision::COLL_FIX | SlotCollision::COLL_KERN)) == SlotCollision::COLL_FIX + && !resolveCollisions(seg, s, start, shiftcoll, false, dir, moved, hasCollisions, dbgout)) + return false; + if (s != start && (c->flags() & SlotCollision::COLL_END)) + { + end = s->next(); + break; + } + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::close << json::close; // phase-1 +#endif + + // phase 2 : loop until happy. + for (int i = 0; i < m_numCollRuns - 1; ++i) + { + if (hasCollisions || moved) + { + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::object << "phase" << "2a" << "loop" << i << "moves" << json::array; +#endif + // phase 2a : if any shiftable glyphs are in collision, iterate backwards, + // fixing them and ignoring other non-collided glyphs. Note that this handles ONLY + // glyphs that are actually in collision from phases 1 or 2b, and working backwards + // has the intended effect of breaking logjams. + if (hasCollisions) + { + hasCollisions = false; + #if 0 + moved = true; + for (Slot *s = start; s != end; s = s->next()) + { + SlotCollision * c = seg->collisionInfo(s); + c->setShift(Position(0, 0)); + } + #endif + Slot *lend = end ? end->prev() : seg->last(); + Slot *lstart = start->prev(); + for (Slot *s = lend; s != lstart; s = s->prev()) + { + SlotCollision * c = seg->collisionInfo(s); + if (start && (c->flags() & (SlotCollision::COLL_FIX | SlotCollision::COLL_KERN | SlotCollision::COLL_ISCOL)) + == (SlotCollision::COLL_FIX | SlotCollision::COLL_ISCOL)) // ONLY if this glyph is still colliding + { + if (!resolveCollisions(seg, s, lend, shiftcoll, true, dir, moved, hasCollisions, dbgout)) + return false; + c->setFlags(c->flags() | SlotCollision::COLL_TEMPLOCK); + } + } + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::close << json::close // phase 2a + << json::object << "phase" << "2b" << "loop" << i << "moves" << json::array; +#endif + + // phase 2b : redo basic diacritic positioning pass for ALL glyphs. Each successive loop adjusts + // glyphs from their current adjusted position, which has the effect of gradually minimizing the + // resulting adjustment; ie, the final result will be gradually closer to the original location. + // Also it allows more flexibility in the final adjustment, since it is moving along the + // possible 8 vectors from successively different starting locations. + if (moved) + { + moved = false; + for (Slot *s = start; s != end; s = s->next()) + { + SlotCollision * c = seg->collisionInfo(s); + if (start && (c->flags() & (SlotCollision::COLL_FIX | SlotCollision::COLL_TEMPLOCK + | SlotCollision::COLL_KERN)) == SlotCollision::COLL_FIX + && !resolveCollisions(seg, s, start, shiftcoll, false, dir, moved, hasCollisions, dbgout)) + return false; + else if (c->flags() & SlotCollision::COLL_TEMPLOCK) + c->setFlags(c->flags() & ~SlotCollision::COLL_TEMPLOCK); + } + } + // if (!hasCollisions) // no, don't leave yet because phase 2b will continue to improve things + // break; +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::close << json::close; // phase 2 +#endif + } + } + if (!end) + break; + start = NULL; + for (Slot *s = end->prev(); s; s = s->next()) + { + if (seg->collisionInfo(s)->flags() & SlotCollision::COLL_START) + { + start = s; + break; + } + } + } + return true; +} + +bool Pass::collisionKern(Segment *seg, int dir, json * const dbgout) const +{ + Slot *start = seg->first(); + float ymin = 1e38f; + float ymax = -1e38f; + const GlyphCache &gc = seg->getFace()->glyphs(); + + // phase 3 : handle kerning of clusters +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::object << "phase" << "3" << "moves" << json::array; +#endif + + for (Slot *s = seg->first(); s; s = s->next()) + { + if (!gc.check(s->gid())) + return false; + const SlotCollision * c = seg->collisionInfo(s); + const Rect &bbox = seg->theGlyphBBoxTemporary(s->gid()); + float y = s->origin().y + c->shift().y; + if (!(c->flags() & SlotCollision::COLL_ISSPACE)) + { + ymax = max(y + bbox.tr.y, ymax); + ymin = min(y + bbox.bl.y, ymin); + } + if (start && (c->flags() & (SlotCollision::COLL_KERN | SlotCollision::COLL_FIX)) + == (SlotCollision::COLL_KERN | SlotCollision::COLL_FIX)) + resolveKern(seg, s, start, dir, ymin, ymax, dbgout); + if (c->flags() & SlotCollision::COLL_END) + start = NULL; + if (c->flags() & SlotCollision::COLL_START) + start = s; + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::close << json::close; // phase 3 +#endif + return true; +} + +bool Pass::collisionFinish(Segment *seg, GR_MAYBE_UNUSED json * const dbgout) const +{ + for (Slot *s = seg->first(); s; s = s->next()) + { + SlotCollision *c = seg->collisionInfo(s); + if (c->shift().x != 0 || c->shift().y != 0) + { + const Position newOffset = c->shift(); + const Position nullPosition(0, 0); + c->setOffset(newOffset + c->offset()); + c->setShift(nullPosition); + } + } +// seg->positionSlots(); + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + *dbgout << json::close; +#endif + return true; +} + +// Can slot s be kerned, or is it attached to something that can be kerned? +static bool inKernCluster(Segment *seg, Slot *s) +{ + SlotCollision *c = seg->collisionInfo(s); + if (c->flags() & SlotCollision::COLL_KERN /** && c->flags() & SlotCollision::COLL_FIX **/ ) + return true; + while (s->attachedTo()) + { + s = s->attachedTo(); + c = seg->collisionInfo(s); + if (c->flags() & SlotCollision::COLL_KERN /** && c->flags() & SlotCollision::COLL_FIX **/ ) + return true; + } + return false; +} + +// Fix collisions for the given slot. +// Return true if everything was fixed, false if there are still collisions remaining. +// isRev means be we are processing backwards. +bool Pass::resolveCollisions(Segment *seg, Slot *slotFix, Slot *start, + ShiftCollider &coll, GR_MAYBE_UNUSED bool isRev, int dir, bool &moved, bool &hasCol, + json * const dbgout) const +{ + Slot * nbor; // neighboring slot + SlotCollision *cFix = seg->collisionInfo(slotFix); + if (!coll.initSlot(seg, slotFix, cFix->limit(), cFix->margin(), cFix->marginWt(), + cFix->shift(), cFix->offset(), dir, dbgout)) + return false; + bool collides = false; + // When we're processing forward, ignore kernable glyphs that preceed the target glyph. + // When processing backward, don't ignore these until we pass slotFix. + bool ignoreForKern = !isRev; + bool rtl = dir & 1; + Slot *base = slotFix; + while (base->attachedTo()) + base = base->attachedTo(); + Position zero(0., 0.); + + // Look for collisions with the neighboring glyphs. + for (nbor = start; nbor; nbor = isRev ? nbor->prev() : nbor->next()) + { + SlotCollision *cNbor = seg->collisionInfo(nbor); + bool sameCluster = nbor->isChildOf(base); + if (nbor != slotFix // don't process if this is the slot of interest + && !(cNbor->ignore()) // don't process if ignoring + && (nbor == base || sameCluster // process if in the same cluster as slotFix + || !inKernCluster(seg, nbor)) // or this cluster is not to be kerned +// || (rtl ^ ignoreForKern)) // or it comes before(ltr) or after(rtl) + && (!isRev // if processing forwards then good to merge otherwise only: + || !(cNbor->flags() & SlotCollision::COLL_FIX) // merge in immovable stuff + || ((cNbor->flags() & SlotCollision::COLL_KERN) && !sameCluster) // ignore other kernable clusters + || (cNbor->flags() & SlotCollision::COLL_ISCOL)) // test against other collided glyphs + && !coll.mergeSlot(seg, nbor, cNbor, cNbor->shift(), !ignoreForKern, sameCluster, collides, false, dbgout)) + return false; + else if (nbor == slotFix) + // Switching sides of this glyph - if we were ignoring kernable stuff before, don't anymore. + ignoreForKern = !ignoreForKern; + + if (nbor != start && (cNbor->flags() & (isRev ? SlotCollision::COLL_START : SlotCollision::COLL_END))) + break; + } + bool isCol = false; + if (collides || cFix->shift().x != 0.f || cFix->shift().y != 0.f) + { + Position shift = coll.resolve(seg, isCol, dbgout); + // isCol has been set to true if a collision remains. + if (std::fabs(shift.x) < 1e38f && std::fabs(shift.y) < 1e38f) + { + if (sqr(shift.x-cFix->shift().x) + sqr(shift.y-cFix->shift().y) >= m_colThreshold * m_colThreshold) + moved = true; + cFix->setShift(shift); + if (slotFix->firstChild()) + { + Rect bbox; + Position here = slotFix->origin() + shift; + float clusterMin = here.x; + slotFix->firstChild()->finalise(seg, NULL, here, bbox, 0, clusterMin, rtl, false); + } + } + } + else + { + // This glyph is not colliding with anything. +#if !defined GRAPHITE2_NTRACING + if (dbgout) + { + *dbgout << json::object + << "missed" << objectid(dslot(seg, slotFix)); + coll.outputJsonDbg(dbgout, seg, -1); + *dbgout << json::close; + } +#endif + } + + // Set the is-collision flag bit. + if (isCol) + { cFix->setFlags(cFix->flags() | SlotCollision::COLL_ISCOL | SlotCollision::COLL_KNOWN); } + else + { cFix->setFlags((cFix->flags() & ~SlotCollision::COLL_ISCOL) | SlotCollision::COLL_KNOWN); } + hasCol |= isCol; + return true; +} + +float Pass::resolveKern(Segment *seg, Slot *slotFix, GR_MAYBE_UNUSED Slot *start, int dir, + float &ymin, float &ymax, json *const dbgout) const +{ + Slot *nbor; // neighboring slot + float currSpace = 0.; + bool collides = false; + unsigned int space_count = 0; + Slot *base = slotFix; + while (base->attachedTo()) + base = base->attachedTo(); + SlotCollision *cFix = seg->collisionInfo(base); + const GlyphCache &gc = seg->getFace()->glyphs(); + const Rect &bbb = seg->theGlyphBBoxTemporary(slotFix->gid()); + const float by = slotFix->origin().y + cFix->shift().y; + + if (base != slotFix) + { + cFix->setFlags(cFix->flags() | SlotCollision::COLL_KERN | SlotCollision::COLL_FIX); + return 0; + } + bool seenEnd = (cFix->flags() & SlotCollision::COLL_END) != 0; + bool isInit = false; + KernCollider coll(dbgout); + + ymax = max(by + bbb.tr.y, ymax); + ymin = min(by + bbb.bl.y, ymin); + for (nbor = slotFix->next(); nbor; nbor = nbor->next()) + { + if (nbor->isChildOf(base)) + continue; + if (!gc.check(nbor->gid())) + return 0.; + const Rect &bb = seg->theGlyphBBoxTemporary(nbor->gid()); + SlotCollision *cNbor = seg->collisionInfo(nbor); + if ((bb.bl.y == 0.f && bb.tr.y == 0.f) || (cNbor->flags() & SlotCollision::COLL_ISSPACE)) + { + if (m_kernColls == InWord) + break; + // Add space for a space glyph. + currSpace += nbor->advance(); + ++space_count; + } + else + { + space_count = 0; + if (nbor != slotFix && !cNbor->ignore()) + { + seenEnd = true; + if (!isInit) + { + if (!coll.initSlot(seg, slotFix, cFix->limit(), cFix->margin(), + cFix->shift(), cFix->offset(), dir, ymin, ymax, dbgout)) + return 0.; + isInit = true; + } + collides |= coll.mergeSlot(seg, nbor, cNbor->shift(), currSpace, dir, dbgout); + } + } + if (cNbor->flags() & SlotCollision::COLL_END) + { + if (seenEnd && space_count < 2) + break; + else + seenEnd = true; + } + } + if (collides) + { + Position mv = coll.resolve(seg, slotFix, dir, dbgout); + coll.shift(mv, dir); + Position delta = slotFix->advancePos() + mv - cFix->shift(); + slotFix->advance(delta); + cFix->setShift(mv); + return mv.x; + } + return 0.; +} diff --git a/gfx/graphite2/src/Position.cpp b/gfx/graphite2/src/Position.cpp new file mode 100644 index 0000000000..d2fdbd4e7c --- /dev/null +++ b/gfx/graphite2/src/Position.cpp @@ -0,0 +1,97 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/Position.h" +#include <cmath> + +using namespace graphite2; + +bool Rect::hitTest(Rect &other) +{ + if (bl.x > other.tr.x) return false; + if (tr.x < other.bl.x) return false; + if (bl.y > other.tr.y) return false; + if (tr.y < other.bl.y) return false; + return true; +} + +Position Rect::overlap(Position &offset, Rect &other, Position &othero) +{ + float ax = (bl.x + offset.x) - (other.tr.x + othero.x); + float ay = (bl.y + offset.y) - (other.tr.y + othero.y); + float bx = (other.bl.x + othero.x) - (tr.x + offset.x); + float by = (other.bl.y + othero.y) - (tr.y + offset.y); + return Position((ax > bx ? ax : bx), (ay > by ? ay : by)); +} + +float boundmin(float move, float lim1, float lim2, float &error) +{ + // error is always positive for easy comparison + if (move < lim1 && move < lim2) + { error = 0.; return move; } + else if (lim1 < lim2) + { error = std::fabs(move - lim1); return lim1; } + else + { error = std::fabs(move - lim2); return lim2; } +} + +#if 0 +Position Rect::constrainedAvoid(Position &offset, Rect &box, Rect &sdbox, Position &other, Rect &obox, Rect &osdbox) +{ + // a = max, i = min, s = sum, d = diff + float eax, eay, eix, eiy, eas, eis, ead, eid; + float beste = INF; + Position res; + // calculate the movements in each direction and the error (amount of remaining overlap) + // first param is movement, second and third are movement over the constraining box + float ax = boundmin(obox.tr.x + other.x - box.bl.x - offset.x + 1, tr.x - offset.x, INF, &eax); + float ay = boundmin(obox.tr.y + other.y - box.bl.y - offset.y + 1, tr.y - offset.y, INF, &eay); + float ix = boundmin(obox.bl.x + other.x - box.tr.x - offset.x + 1, bl.x - offset.x, INF, &eix); + float iy = boundmin(obox.bl.y + other.y - box.tr.y - offset.y + 1, bl.y - offset.y, INF, &eiy); + float as = boundmin(ISQRT2 * (osdbox.tr.x + other.x + other.y - sdbox.bl.x - offset.x - offset.y) + 1, tr.x - offset.x, tr.y - offset.y, &eas); + float is = boundmin(ISQRT2 * (osdbox.bl.x + other.x + other.y - sdbox.tr.x - offset.x - offset.y) + 1, bl.x - offset.x, bl.y - offset.y, &eis); + float ad = boundmin(ISQRT2 * (osdbox.tr.y + other.x - other.y - sdbox.bl.y - offset.x + offset.y) + 1, tr.y - offset.y, tr.x - offset.x, &ead); + float id = boundmin(ISQRT2 * (osdbox.bl.y + other.x - other.y - sdbox.tr.y - offset.x + offset.y) + 1, bl.y - offset.y, bl.x - offset.x, &eid); + + if (eax < beste) + { res = Position(ax, 0); beste = eax; } + if (eay < beste) + { res = Position(0, ay); beste = eay; } + if (eix < beste) + { res = Position(ix, 0); beste = eix; } + if (eiy < beste) + { res = Position(0, iy); beste = eiy; } + if (SQRT2 * (eas) < beste) + { res = Position(as, ad); beste = SQRT2 * (eas); } + if (SQRT2 * (eis) < beste) + { res = Position(is, is); beste = SQRT2 * (eis); } + if (SQRT2 * (ead) < beste) + { res = Position(ad, ad); beste = SQRT2 * (ead); } + if (SQRT2 * (eid) < beste) + { res = Position(id, id); beste = SQRT2 * (eid); } + return res; +} +#endif diff --git a/gfx/graphite2/src/Segment.cpp b/gfx/graphite2/src/Segment.cpp new file mode 100644 index 0000000000..62edd4250f --- /dev/null +++ b/gfx/graphite2/src/Segment.cpp @@ -0,0 +1,423 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/UtfCodec.h" +#include <cstring> +#include <cstdlib> + +#include "inc/bits.h" +#include "inc/Segment.h" +#include "graphite2/Font.h" +#include "inc/CharInfo.h" +#include "inc/debug.h" +#include "inc/Slot.h" +#include "inc/Main.h" +#include "inc/CmapCache.h" +#include "inc/Collider.h" +#include "graphite2/Segment.h" + + +using namespace graphite2; + +Segment::Segment(size_t numchars, const Face* face, uint32 script, int textDir) +: m_freeSlots(NULL), + m_freeJustifies(NULL), + m_charinfo(new CharInfo[numchars]), + m_collisions(NULL), + m_face(face), + m_silf(face->chooseSilf(script)), + m_first(NULL), + m_last(NULL), + m_bufSize(numchars + 10), + m_numGlyphs(numchars), + m_numCharinfo(numchars), + m_defaultOriginal(0), + m_dir(textDir), + m_flags(((m_silf->flags() & 0x20) != 0) << 1), + m_passBits(m_silf->aPassBits() ? -1 : 0) +{ + freeSlot(newSlot()); + m_bufSize = log_binary(numchars)+1; +} + +Segment::~Segment() +{ + for (SlotRope::iterator i = m_slots.begin(); i != m_slots.end(); ++i) + free(*i); + for (AttributeRope::iterator i = m_userAttrs.begin(); i != m_userAttrs.end(); ++i) + free(*i); + for (JustifyRope::iterator i = m_justifies.begin(); i != m_justifies.end(); ++i) + free(*i); + delete[] m_charinfo; + free(m_collisions); +} + +void Segment::appendSlot(int id, int cid, int gid, int iFeats, size_t coffset) +{ + Slot *aSlot = newSlot(); + + if (!aSlot) return; + m_charinfo[id].init(cid); + m_charinfo[id].feats(iFeats); + m_charinfo[id].base(coffset); + const GlyphFace * theGlyph = m_face->glyphs().glyphSafe(gid); + m_charinfo[id].breakWeight(theGlyph ? theGlyph->attrs()[m_silf->aBreak()] : 0); + + aSlot->child(NULL); + aSlot->setGlyph(this, gid, theGlyph); + aSlot->originate(id); + aSlot->before(id); + aSlot->after(id); + if (m_last) m_last->next(aSlot); + aSlot->prev(m_last); + m_last = aSlot; + if (!m_first) m_first = aSlot; + if (theGlyph && m_silf->aPassBits()) + m_passBits &= theGlyph->attrs()[m_silf->aPassBits()] + | (m_silf->numPasses() > 16 ? (theGlyph->attrs()[m_silf->aPassBits() + 1] << 16) : 0); +} + +Slot *Segment::newSlot() +{ + if (!m_freeSlots) + { + // check that the segment doesn't grow indefinintely + if (m_numGlyphs > m_numCharinfo * MAX_SEG_GROWTH_FACTOR) + return NULL; + int numUser = m_silf->numUser(); +#if !defined GRAPHITE2_NTRACING + if (m_face->logger()) ++numUser; +#endif + Slot *newSlots = grzeroalloc<Slot>(m_bufSize); + int16 *newAttrs = grzeroalloc<int16>(m_bufSize * numUser); + if (!newSlots || !newAttrs) + { + free(newSlots); + free(newAttrs); + return NULL; + } + for (size_t i = 0; i < m_bufSize; i++) + { + ::new (newSlots + i) Slot(newAttrs + i * numUser); + newSlots[i].next(newSlots + i + 1); + } + newSlots[m_bufSize - 1].next(NULL); + newSlots[0].next(NULL); + m_slots.push_back(newSlots); + m_userAttrs.push_back(newAttrs); + m_freeSlots = (m_bufSize > 1)? newSlots + 1 : NULL; + return newSlots; + } + Slot *res = m_freeSlots; + m_freeSlots = m_freeSlots->next(); + res->next(NULL); + return res; +} + +void Segment::freeSlot(Slot *aSlot) +{ + if (aSlot == nullptr) return; + if (m_last == aSlot) m_last = aSlot->prev(); + if (m_first == aSlot) m_first = aSlot->next(); + if (aSlot->attachedTo()) + aSlot->attachedTo()->removeChild(aSlot); + while (aSlot->firstChild()) + { + if (aSlot->firstChild()->attachedTo() == aSlot) + { + aSlot->firstChild()->attachTo(nullptr); + aSlot->removeChild(aSlot->firstChild()); + } + else + aSlot->firstChild(nullptr); + } + // reset the slot incase it is reused + ::new (aSlot) Slot(aSlot->userAttrs()); + memset(aSlot->userAttrs(), 0, m_silf->numUser() * sizeof(int16)); + // Update generation counter for debug +#if !defined GRAPHITE2_NTRACING + if (m_face->logger()) + ++aSlot->userAttrs()[m_silf->numUser()]; +#endif + // update next pointer + if (!m_freeSlots) + aSlot->next(nullptr); + else + aSlot->next(m_freeSlots); + m_freeSlots = aSlot; +} + +SlotJustify *Segment::newJustify() +{ + if (!m_freeJustifies) + { + const size_t justSize = SlotJustify::size_of(m_silf->numJustLevels()); + byte *justs = grzeroalloc<byte>(justSize * m_bufSize); + if (!justs) return NULL; + for (ptrdiff_t i = m_bufSize - 2; i >= 0; --i) + { + SlotJustify *p = reinterpret_cast<SlotJustify *>(justs + justSize * i); + SlotJustify *next = reinterpret_cast<SlotJustify *>(justs + justSize * (i + 1)); + p->next = next; + } + m_freeJustifies = (SlotJustify *)justs; + m_justifies.push_back(m_freeJustifies); + } + SlotJustify *res = m_freeJustifies; + m_freeJustifies = m_freeJustifies->next; + res->next = NULL; + return res; +} + +void Segment::freeJustify(SlotJustify *aJustify) +{ + int numJust = m_silf->numJustLevels(); + if (m_silf->numJustLevels() <= 0) numJust = 1; + aJustify->next = m_freeJustifies; + memset(aJustify->values, 0, numJust*SlotJustify::NUMJUSTPARAMS*sizeof(int16)); + m_freeJustifies = aJustify; +} + +// reverse the slots but keep diacritics in their same position after their bases +void Segment::reverseSlots() +{ + m_dir = m_dir ^ 64; // invert the reverse flag + if (m_first == m_last) return; // skip 0 or 1 glyph runs + + Slot *t = 0; + Slot *curr = m_first; + Slot *tlast; + Slot *tfirst; + Slot *out = 0; + + while (curr && getSlotBidiClass(curr) == 16) + curr = curr->next(); + if (!curr) return; + tfirst = curr->prev(); + tlast = curr; + + while (curr) + { + if (getSlotBidiClass(curr) == 16) + { + Slot *d = curr->next(); + while (d && getSlotBidiClass(d) == 16) + d = d->next(); + + d = d ? d->prev() : m_last; + Slot *p = out->next(); // one after the diacritics. out can't be null + if (p) + p->prev(d); + else + tlast = d; + t = d->next(); + d->next(p); + curr->prev(out); + out->next(curr); + } + else // will always fire first time round the loop + { + if (out) + out->prev(curr); + t = curr->next(); + curr->next(out); + out = curr; + } + curr = t; + } + out->prev(tfirst); + if (tfirst) + tfirst->next(out); + else + m_first = out; + m_last = tlast; +} + +void Segment::linkClusters(Slot *s, Slot * end) +{ + end = end->next(); + + for (; s != end && !s->isBase(); s = s->next()); + Slot * ls = s; + + if (m_dir & 1) + { + for (; s != end; s = s->next()) + { + if (!s->isBase()) continue; + + s->sibling(ls); + ls = s; + } + } + else + { + for (; s != end; s = s->next()) + { + if (!s->isBase()) continue; + + ls->sibling(s); + ls = s; + } + } +} + +Position Segment::positionSlots(const Font *font, Slot * iStart, Slot * iEnd, bool isRtl, bool isFinal) +{ + Position currpos(0., 0.); + float clusterMin = 0.; + Rect bbox; + bool reorder = (currdir() != isRtl); + + if (reorder) + { + Slot *temp; + reverseSlots(); + temp = iStart; + iStart = iEnd; + iEnd = temp; + } + if (!iStart) iStart = m_first; + if (!iEnd) iEnd = m_last; + + if (!iStart || !iEnd) // only true for empty segments + return currpos; + + if (isRtl) + { + for (Slot * s = iEnd, * const end = iStart->prev(); s && s != end; s = s->prev()) + { + if (s->isBase()) + currpos = s->finalise(this, font, currpos, bbox, 0, clusterMin = currpos.x, isRtl, isFinal); + } + } + else + { + for (Slot * s = iStart, * const end = iEnd->next(); s && s != end; s = s->next()) + { + if (s->isBase()) + currpos = s->finalise(this, font, currpos, bbox, 0, clusterMin = currpos.x, isRtl, isFinal); + } + } + if (reorder) + reverseSlots(); + return currpos; +} + + +void Segment::associateChars(int offset, size_t numChars) +{ + int i = 0, j = 0; + CharInfo *c, *cend; + for (c = m_charinfo + offset, cend = m_charinfo + offset + numChars; c != cend; ++c) + { + c->before(-1); + c->after(-1); + } + for (Slot * s = m_first; s; s->index(i++), s = s->next()) + { + j = s->before(); + if (j < 0) continue; + + for (const int after = s->after(); j <= after; ++j) + { + c = charinfo(j); + if (c->before() == -1 || i < c->before()) c->before(i); + if (c->after() < i) c->after(i); + } + } + for (Slot *s = m_first; s; s = s->next()) + { + int a; + for (a = s->after() + 1; a < offset + int(numChars) && charinfo(a)->after() < 0; ++a) + { charinfo(a)->after(s->index()); } + --a; + s->after(a); + + for (a = s->before() - 1; a >= offset && charinfo(a)->before() < 0; --a) + { charinfo(a)->before(s->index()); } + ++a; + s->before(a); + } +} + + +template <typename utf_iter> +inline void process_utf_data(Segment & seg, const Face & face, const int fid, utf_iter c, size_t n_chars) +{ + const Cmap & cmap = face.cmap(); + int slotid = 0; + + const typename utf_iter::codeunit_type * const base = c; + for (; n_chars; --n_chars, ++c, ++slotid) + { + const uint32 usv = *c; + uint16 gid = cmap[usv]; + if (!gid) gid = face.findPseudo(usv); + seg.appendSlot(slotid, usv, gid, fid, c - base); + } +} + + +bool Segment::read_text(const Face *face, const Features* pFeats/*must not be NULL*/, gr_encform enc, const void* pStart, size_t nChars) +{ + assert(face); + assert(pFeats); + if (!m_charinfo) return false; + + // utf iterator is self recovering so we don't care about the error state of the iterator. + switch (enc) + { + case gr_utf8: process_utf_data(*this, *face, addFeatures(*pFeats), utf8::const_iterator(pStart), nChars); break; + case gr_utf16: process_utf_data(*this, *face, addFeatures(*pFeats), utf16::const_iterator(pStart), nChars); break; + case gr_utf32: process_utf_data(*this, *face, addFeatures(*pFeats), utf32::const_iterator(pStart), nChars); break; + } + return true; +} + +void Segment::doMirror(uint16 aMirror) +{ + Slot * s; + for (s = m_first; s; s = s->next()) + { + unsigned short g = glyphAttr(s->gid(), aMirror); + if (g && (!(dir() & 4) || !glyphAttr(s->gid(), aMirror + 1))) + s->setGlyph(this, g); + } +} + +bool Segment::initCollisions() +{ + m_collisions = grzeroalloc<SlotCollision>(slotCount()); + if (!m_collisions) return false; + + for (Slot *p = m_first; p; p = p->next()) + if (p->index() < slotCount()) + ::new (collisionInfo(p)) SlotCollision(this, p); + else + return false; + return true; +} diff --git a/gfx/graphite2/src/Silf.cpp b/gfx/graphite2/src/Silf.cpp new file mode 100644 index 0000000000..44d3c96171 --- /dev/null +++ b/gfx/graphite2/src/Silf.cpp @@ -0,0 +1,439 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cstdlib> +#include "graphite2/Segment.h" +#include "inc/debug.h" +#include "inc/Endian.h" +#include "inc/Silf.h" +#include "inc/Segment.h" +#include "inc/Rule.h" +#include "inc/Error.h" + + +using namespace graphite2; + +namespace { static const uint32 ERROROFFSET = 0xFFFFFFFF; } + +Silf::Silf() throw() +: m_passes(0), + m_pseudos(0), + m_classOffsets(0), + m_classData(0), + m_justs(0), + m_numPasses(0), + m_numJusts(0), + m_sPass(0), + m_pPass(0), + m_jPass(0), + m_bPass(0), + m_flags(0), + m_dir(0), + m_aPseudo(0), + m_aBreak(0), + m_aUser(0), + m_aBidi(0), + m_aMirror(0), + m_aPassBits(0), + m_iMaxComp(0), + m_aCollision(0), + m_aLig(0), + m_numPseudo(0), + m_nClass(0), + m_nLinear(0), + m_gEndLine(0) +{ + memset(&m_silfinfo, 0, sizeof m_silfinfo); +} + +Silf::~Silf() throw() +{ + releaseBuffers(); +} + +void Silf::releaseBuffers() throw() +{ + delete [] m_passes; + delete [] m_pseudos; + free(m_classOffsets); + free(m_classData); + free(m_justs); + m_passes= 0; + m_pseudos = 0; + m_classOffsets = 0; + m_classData = 0; + m_justs = 0; +} + + +bool Silf::readGraphite(const byte * const silf_start, size_t lSilf, Face& face, uint32 version) +{ + const byte * p = silf_start, + * const silf_end = p + lSilf; + Error e; + + if (e.test(version >= 0x00060000, E_BADSILFVERSION)) + { + releaseBuffers(); return face.error(e); + } + if (version >= 0x00030000) + { + if (e.test(lSilf < 28, E_BADSIZE)) { releaseBuffers(); return face.error(e); } + be::skip<int32>(p); // ruleVersion + be::skip<uint16>(p,2); // passOffset & pseudosOffset + } + else if (e.test(lSilf < 20, E_BADSIZE)) { releaseBuffers(); return face.error(e); } + const uint16 maxGlyph = be::read<uint16>(p); + m_silfinfo.extra_ascent = be::read<uint16>(p); + m_silfinfo.extra_descent = be::read<uint16>(p); + m_numPasses = be::read<uint8>(p); + m_sPass = be::read<uint8>(p); + m_pPass = be::read<uint8>(p); + m_jPass = be::read<uint8>(p); + m_bPass = be::read<uint8>(p); + m_flags = be::read<uint8>(p); + be::skip<uint8>(p,2); // max{Pre,Post}Context. + m_aPseudo = be::read<uint8>(p); + m_aBreak = be::read<uint8>(p); + m_aBidi = be::read<uint8>(p); + m_aMirror = be::read<uint8>(p); + m_aPassBits = be::read<uint8>(p); + + // Read Justification levels. + m_numJusts = be::read<uint8>(p); + if (e.test(maxGlyph >= face.glyphs().numGlyphs(), E_BADMAXGLYPH) + || e.test(p + m_numJusts * 8 >= silf_end, E_BADNUMJUSTS)) + { + releaseBuffers(); return face.error(e); + } + + if (m_numJusts) + { + m_justs = gralloc<Justinfo>(m_numJusts); + if (e.test(!m_justs, E_OUTOFMEM)) return face.error(e); + + for (uint8 i = 0; i < m_numJusts; i++) + { + ::new(m_justs + i) Justinfo(p[0], p[1], p[2], p[3]); + be::skip<byte>(p,8); + } + } + + if (e.test(p + sizeof(uint16) + sizeof(uint8)*8 >= silf_end, E_BADENDJUSTS)) { releaseBuffers(); return face.error(e); } + m_aLig = be::read<uint16>(p); + m_aUser = be::read<uint8>(p); + m_iMaxComp = be::read<uint8>(p); + m_dir = be::read<uint8>(p) - 1; + m_aCollision = be::read<uint8>(p); + be::skip<byte>(p,3); + be::skip<uint16>(p, be::read<uint8>(p)); // don't need critical features yet + be::skip<byte>(p); // reserved + if (e.test(p >= silf_end, E_BADCRITFEATURES)) { releaseBuffers(); return face.error(e); } + be::skip<uint32>(p, be::read<uint8>(p)); // don't use scriptTag array. + if (e.test(p + sizeof(uint16) + sizeof(uint32) >= silf_end, E_BADSCRIPTTAGS)) { releaseBuffers(); return face.error(e); } + m_gEndLine = be::read<uint16>(p); // lbGID + const byte * o_passes = p; + uint32 passes_start = be::read<uint32>(p); + + const size_t num_attrs = face.glyphs().numAttrs(); + if (e.test(m_aPseudo >= num_attrs, E_BADAPSEUDO) + || e.test(m_aBreak >= num_attrs, E_BADABREAK) + || e.test(m_aBidi >= num_attrs, E_BADABIDI) + || e.test(m_aMirror>= num_attrs, E_BADAMIRROR) + || e.test(m_aCollision && m_aCollision >= num_attrs - 5, E_BADACOLLISION) + || e.test(m_numPasses > 128, E_BADNUMPASSES) || e.test(passes_start >= lSilf, E_BADPASSESSTART) + || e.test(m_pPass < m_sPass, E_BADPASSBOUND) || e.test(m_pPass > m_numPasses, E_BADPPASS) || e.test(m_sPass > m_numPasses, E_BADSPASS) + || e.test(m_jPass < m_pPass, E_BADJPASSBOUND) || e.test(m_jPass > m_numPasses, E_BADJPASS) + || e.test((m_bPass != 0xFF && (m_bPass < m_jPass || m_bPass > m_numPasses)), E_BADBPASS) + || e.test(m_aLig > 127, E_BADALIG)) + { + releaseBuffers(); + return face.error(e); + } + be::skip<uint32>(p, m_numPasses); + if (e.test(unsigned(p - silf_start) + sizeof(uint16) >= passes_start, E_BADPASSESSTART)) { releaseBuffers(); return face.error(e); } + m_numPseudo = be::read<uint16>(p); + be::skip<uint16>(p, 3); // searchPseudo, pseudoSelector, pseudoShift + m_pseudos = new Pseudo[m_numPseudo]; + if (e.test(unsigned(p - silf_start) + m_numPseudo*(sizeof(uint32) + sizeof(uint16)) >= passes_start, E_BADNUMPSEUDO) + || e.test(!m_pseudos, E_OUTOFMEM)) + { + releaseBuffers(); return face.error(e); + } + for (int i = 0; i < m_numPseudo; i++) + { + m_pseudos[i].uid = be::read<uint32>(p); + m_pseudos[i].gid = be::read<uint16>(p); + } + + const size_t clen = readClassMap(p, passes_start + silf_start - p, version, e); + m_passes = new Pass[m_numPasses]; + if (e || e.test(clen > unsigned(passes_start + silf_start - p), E_BADPASSESSTART) + || e.test(!m_passes, E_OUTOFMEM)) + { releaseBuffers(); return face.error(e); } + + for (size_t i = 0; i < m_numPasses; ++i) + { + uint32 pass_start = be::read<uint32>(o_passes); + uint32 pass_end = be::peek<uint32>(o_passes); + face.error_context((face.error_context() & 0xFF00) + EC_ASILF + unsigned(i << 16)); + if (e.test(pass_start > pass_end, E_BADPASSSTART) + || e.test(pass_start < passes_start, E_BADPASSSTART) + || e.test(pass_end > lSilf, E_BADPASSEND)) { + releaseBuffers(); return face.error(e); + } + + enum passtype pt = PASS_TYPE_UNKNOWN; + if (i >= m_jPass) pt = PASS_TYPE_JUSTIFICATION; + else if (i >= m_pPass) pt = PASS_TYPE_POSITIONING; + else if (i >= m_sPass) pt = PASS_TYPE_SUBSTITUTE; + else pt = PASS_TYPE_LINEBREAK; + + m_passes[i].init(this); + if (!m_passes[i].readPass(silf_start + pass_start, pass_end - pass_start, pass_start, face, pt, + version, e)) + { + releaseBuffers(); + return false; + } + } + + // fill in gr_faceinfo + m_silfinfo.upem = face.glyphs().unitsPerEm(); + m_silfinfo.has_bidi_pass = (m_bPass != 0xFF); + m_silfinfo.justifies = (m_numJusts != 0) || (m_jPass < m_pPass); + m_silfinfo.line_ends = (m_flags & 1); + m_silfinfo.space_contextuals = gr_faceinfo::gr_space_contextuals((m_flags >> 2) & 0x7); + return true; +} + +template<typename T> inline uint32 Silf::readClassOffsets(const byte *&p, size_t data_len, Error &e) +{ + const T cls_off = 2*sizeof(uint16) + sizeof(T)*(m_nClass+1); + const uint32 max_off = (be::peek<T>(p + sizeof(T)*m_nClass) - cls_off)/sizeof(uint16); + // Check that the last+1 offset is less than or equal to the class map length. + if (e.test(be::peek<T>(p) != cls_off, E_MISALIGNEDCLASSES) + || e.test(max_off > (data_len - cls_off)/sizeof(uint16), E_HIGHCLASSOFFSET)) + return ERROROFFSET; + + // Read in all the offsets. + m_classOffsets = gralloc<uint32>(m_nClass+1); + if (e.test(!m_classOffsets, E_OUTOFMEM)) return ERROROFFSET; + for (uint32 * o = m_classOffsets, * const o_end = o + m_nClass + 1; o != o_end; ++o) + { + *o = (be::read<T>(p) - cls_off)/sizeof(uint16); + if (e.test(*o > max_off, E_HIGHCLASSOFFSET)) + return ERROROFFSET; + } + return max_off; +} + +size_t Silf::readClassMap(const byte *p, size_t data_len, uint32 version, Error &e) +{ + if (e.test(data_len < sizeof(uint16)*2, E_BADCLASSSIZE)) return ERROROFFSET; + + m_nClass = be::read<uint16>(p); + m_nLinear = be::read<uint16>(p); + + // Check that numLinear < numClass, + // that there is at least enough data for numClasses offsets. + if (e.test(m_nLinear > m_nClass, E_TOOMANYLINEAR) + || e.test((m_nClass + 1) * (version >= 0x00040000 ? sizeof(uint32) : sizeof(uint16)) > (data_len - 4), E_CLASSESTOOBIG)) + return ERROROFFSET; + + uint32 max_off; + if (version >= 0x00040000) + max_off = readClassOffsets<uint32>(p, data_len, e); + else + max_off = readClassOffsets<uint16>(p, data_len, e); + + if (max_off == ERROROFFSET) return ERROROFFSET; + + if (e.test((int)max_off < m_nLinear + (m_nClass - m_nLinear) * 6, E_CLASSESTOOBIG)) + return ERROROFFSET; + + // Check the linear offsets are sane, these must be monotonically increasing. + assert(m_nClass >= m_nLinear); + for (const uint32 *o = m_classOffsets, * const o_end = o + m_nLinear; o != o_end; ++o) + if (e.test(o[0] > o[1], E_BADCLASSOFFSET)) + return ERROROFFSET; + + // Fortunately the class data is all uint16s so we can decode these now + m_classData = gralloc<uint16>(max_off); + if (e.test(!m_classData, E_OUTOFMEM)) return ERROROFFSET; + for (uint16 *d = m_classData, * const d_end = d + max_off; d != d_end; ++d) + *d = be::read<uint16>(p); + + // Check the lookup class invariants for each non-linear class + for (const uint32 *o = m_classOffsets + m_nLinear, * const o_end = m_classOffsets + m_nClass; o != o_end; ++o) + { + const uint16 * lookup = m_classData + *o; + if (e.test(*o + 4 > max_off, E_HIGHCLASSOFFSET) // LookupClass doesn't stretch over max_off + || e.test(lookup[0] == 0 // A LookupClass with no looks is a suspicious thing ... + || lookup[0] * 2 + *o + 4 > max_off // numIDs lookup pairs fits within (start of LookupClass' lookups array, max_off] + || lookup[3] + lookup[1] != lookup[0], E_BADCLASSLOOKUPINFO) // rangeShift: numIDs - searchRange + || e.test(((o[1] - *o) & 1) != 0, ERROROFFSET)) // glyphs are in pairs so difference must be even. + return ERROROFFSET; + } + + return max_off; +} + +uint16 Silf::findPseudo(uint32 uid) const +{ + for (int i = 0; i < m_numPseudo; i++) + if (m_pseudos[i].uid == uid) return m_pseudos[i].gid; + return 0; +} + +uint16 Silf::findClassIndex(uint16 cid, uint16 gid) const +{ + if (cid > m_nClass) return -1; + + const uint16 * cls = m_classData + m_classOffsets[cid]; + if (cid < m_nLinear) // output class being used for input, shouldn't happen + { + for (unsigned int i = 0, n = m_classOffsets[cid + 1] - m_classOffsets[cid]; i < n; ++i, ++cls) + if (*cls == gid) return i; + return -1; + } + else + { + const uint16 * min = cls + 4, // lookups array + * max = min + cls[0]*2; // lookups aray is numIDs (cls[0]) uint16 pairs long + do + { + const uint16 * p = min + (-2 & ((max-min)/2)); + if (p[0] > gid) max = p; + else min = p; + } + while (max - min > 2); + return min[0] == gid ? min[1] : -1; + } +} + +uint16 Silf::getClassGlyph(uint16 cid, unsigned int index) const +{ + if (cid > m_nClass) return 0; + + uint32 loc = m_classOffsets[cid]; + if (cid < m_nLinear) + { + if (index < m_classOffsets[cid + 1] - loc) + return m_classData[index + loc]; + } + else // input class being used for output. Shouldn't happen + { + for (unsigned int i = loc + 4; i < m_classOffsets[cid + 1]; i += 2) + if (m_classData[i + 1] == index) return m_classData[i]; + } + return 0; +} + + +bool Silf::runGraphite(Segment *seg, uint8 firstPass, uint8 lastPass, int dobidi) const +{ + assert(seg != 0); + size_t maxSize = seg->slotCount() * MAX_SEG_GROWTH_FACTOR; + SlotMap map(*seg, m_dir, maxSize); + FiniteStateMachine fsm(map, seg->getFace()->logger()); + vm::Machine m(map); + uint8 lbidi = m_bPass; +#if !defined GRAPHITE2_NTRACING + json * const dbgout = seg->getFace()->logger(); +#endif + + if (lastPass == 0) + { + if (firstPass == lastPass && lbidi == 0xFF) + return true; + lastPass = m_numPasses; + } + if ((firstPass < lbidi || (dobidi && firstPass == lbidi)) && (lastPass >= lbidi || (dobidi && lastPass + 1 == lbidi))) + lastPass++; + else + lbidi = 0xFF; + + for (size_t i = firstPass; i < lastPass; ++i) + { + // bidi and mirroring + if (i == lbidi) + { +#if !defined GRAPHITE2_NTRACING + if (dbgout) + { + *dbgout << json::item << json::object +// << "pindex" << i // for debugging + << "id" << -1 + << "slotsdir" << (seg->currdir() ? "rtl" : "ltr") + << "passdir" << (m_dir & 1 ? "rtl" : "ltr") + << "slots" << json::array; + seg->positionSlots(0, 0, 0, seg->currdir()); + for(Slot * s = seg->first(); s; s = s->next()) + *dbgout << dslot(seg, s); + *dbgout << json::close + << "rules" << json::array << json::close + << json::close; + } +#endif + if (seg->currdir() != (m_dir & 1)) + seg->reverseSlots(); + if (m_aMirror && (seg->dir() & 3) == 3) + seg->doMirror(m_aMirror); + --i; + lbidi = lastPass; + --lastPass; + continue; + } + +#if !defined GRAPHITE2_NTRACING + if (dbgout) + { + *dbgout << json::item << json::object +// << "pindex" << i // for debugging + << "id" << i+1 + << "slotsdir" << (seg->currdir() ? "rtl" : "ltr") + << "passdir" << ((m_dir & 1) ^ m_passes[i].reverseDir() ? "rtl" : "ltr") + << "slots" << json::array; + seg->positionSlots(0, 0, 0, seg->currdir()); + for(Slot * s = seg->first(); s; s = s->next()) + *dbgout << dslot(seg, s); + *dbgout << json::close; + } +#endif + + // test whether to reorder, prepare for positioning + bool reverse = (lbidi == 0xFF) && (seg->currdir() != ((m_dir & 1) ^ m_passes[i].reverseDir())); + if ((i >= 32 || (seg->passBits() & (1 << i)) == 0 || m_passes[i].collisionLoops()) + && !m_passes[i].runGraphite(m, fsm, reverse)) + return false; + // only subsitution passes can change segment length, cached subsegments are short for their text + if (m.status() != vm::Machine::finished + || (seg->slotCount() && seg->slotCount() > maxSize)) + return false; + } + return true; +} diff --git a/gfx/graphite2/src/Slot.cpp b/gfx/graphite2/src/Slot.cpp new file mode 100644 index 0000000000..0fdb098952 --- /dev/null +++ b/gfx/graphite2/src/Slot.cpp @@ -0,0 +1,529 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/Silf.h" +#include "inc/CharInfo.h" +#include "inc/Rule.h" +#include "inc/Collider.h" + + +using namespace graphite2; + +Slot::Slot(int16 *user_attrs) : + m_next(NULL), m_prev(NULL), + m_glyphid(0), m_realglyphid(0), m_original(0), m_before(0), m_after(0), + m_index(0), m_parent(NULL), m_child(NULL), m_sibling(NULL), + m_position(0, 0), m_shift(0, 0), m_advance(0, 0), + m_attach(0, 0), m_with(0, 0), m_just(0.), + m_flags(0), m_attLevel(0), m_bidiCls(-1), m_bidiLevel(0), + m_userAttr(user_attrs), m_justs(NULL) +{ +} + +// take care, this does not copy any of the GrSlot pointer fields +void Slot::set(const Slot & orig, int charOffset, size_t sizeAttr, size_t justLevels, size_t numChars) +{ + // leave m_next and m_prev unchanged + m_glyphid = orig.m_glyphid; + m_realglyphid = orig.m_realglyphid; + m_original = orig.m_original + charOffset; + if (charOffset + int(orig.m_before) < 0) + m_before = 0; + else + m_before = orig.m_before + charOffset; + if (charOffset <= 0 && orig.m_after + charOffset >= numChars) + m_after = int(numChars) - 1; + else + m_after = orig.m_after + charOffset; + m_parent = NULL; + m_child = NULL; + m_sibling = NULL; + m_position = orig.m_position; + m_shift = orig.m_shift; + m_advance = orig.m_advance; + m_attach = orig.m_attach; + m_with = orig.m_with; + m_flags = orig.m_flags; + m_attLevel = orig.m_attLevel; + m_bidiCls = orig.m_bidiCls; + m_bidiLevel = orig.m_bidiLevel; + if (m_userAttr && orig.m_userAttr) + memcpy(m_userAttr, orig.m_userAttr, sizeAttr * sizeof(*m_userAttr)); + if (m_justs && orig.m_justs) + memcpy(m_justs, orig.m_justs, SlotJustify::size_of(justLevels)); +} + +void Slot::update(int /*numGrSlots*/, int numCharInfo, Position &relpos) +{ + m_before += numCharInfo; + m_after += numCharInfo; + m_position = m_position + relpos; +} + +Position Slot::finalise(const Segment *seg, const Font *font, Position & base, Rect & bbox, uint8 attrLevel, float & clusterMin, bool rtl, bool isFinal, int depth) +{ + SlotCollision *coll = NULL; + if (depth > 100 || (attrLevel && m_attLevel > attrLevel)) return Position(0, 0); + float scale = font ? font->scale() : 1.0f; + Position shift(m_shift.x * (rtl * -2 + 1) + m_just, m_shift.y); + float tAdvance = m_advance.x + m_just; + if (isFinal && (coll = seg->collisionInfo(this))) + { + const Position &collshift = coll->offset(); + if (!(coll->flags() & SlotCollision::COLL_KERN) || rtl) + shift = shift + collshift; + } + const GlyphFace * glyphFace = seg->getFace()->glyphs().glyphSafe(glyph()); + if (font) + { + scale = font->scale(); + shift *= scale; + if (font->isHinted() && glyphFace) + tAdvance = (m_advance.x - glyphFace->theAdvance().x + m_just) * scale + font->advance(glyph()); + else + tAdvance *= scale; + } + Position res; + + m_position = base + shift; + if (!m_parent) + { + res = base + Position(tAdvance, m_advance.y * scale); + clusterMin = m_position.x; + } + else + { + float tAdv; + m_position += (m_attach - m_with) * scale; + tAdv = m_advance.x >= 0.5f ? m_position.x + tAdvance - shift.x : 0.f; + res = Position(tAdv, 0); + if ((m_advance.x >= 0.5f || m_position.x < 0) && m_position.x < clusterMin) clusterMin = m_position.x; + } + + if (glyphFace) + { + Rect ourBbox = glyphFace->theBBox() * scale + m_position; + bbox = bbox.widen(ourBbox); + } + + if (m_child && m_child != this && m_child->attachedTo() == this) + { + Position tRes = m_child->finalise(seg, font, m_position, bbox, attrLevel, clusterMin, rtl, isFinal, depth + 1); + if ((!m_parent || m_advance.x >= 0.5f) && tRes.x > res.x) res = tRes; + } + + if (m_parent && m_sibling && m_sibling != this && m_sibling->attachedTo() == m_parent) + { + Position tRes = m_sibling->finalise(seg, font, base, bbox, attrLevel, clusterMin, rtl, isFinal, depth + 1); + if (tRes.x > res.x) res = tRes; + } + + if (!m_parent && clusterMin < base.x) + { + Position adj = Position(m_position.x - clusterMin, 0.); + res += adj; + m_position += adj; + if (m_child) m_child->floodShift(adj); + } + return res; +} + +int32 Slot::clusterMetric(const Segment *seg, uint8 metric, uint8 attrLevel, bool rtl) +{ + Position base; + if (glyph() >= seg->getFace()->glyphs().numGlyphs()) + return 0; + Rect bbox = seg->theGlyphBBoxTemporary(glyph()); + float clusterMin = 0.; + Position res = finalise(seg, NULL, base, bbox, attrLevel, clusterMin, rtl, false); + + switch (metrics(metric)) + { + case kgmetLsb : + return int32(bbox.bl.x); + case kgmetRsb : + return int32(res.x - bbox.tr.x); + case kgmetBbTop : + return int32(bbox.tr.y); + case kgmetBbBottom : + return int32(bbox.bl.y); + case kgmetBbLeft : + return int32(bbox.bl.x); + case kgmetBbRight : + return int32(bbox.tr.x); + case kgmetBbWidth : + return int32(bbox.tr.x - bbox.bl.x); + case kgmetBbHeight : + return int32(bbox.tr.y - bbox.bl.y); + case kgmetAdvWidth : + return int32(res.x); + case kgmetAdvHeight : + return int32(res.y); + default : + return 0; + } +} + +#define SLOTGETCOLATTR(x) { SlotCollision *c = seg->collisionInfo(this); return c ? int(c-> x) : 0; } + +int Slot::getAttr(const Segment *seg, attrCode ind, uint8 subindex) const +{ + if (ind >= gr_slatJStretch && ind < gr_slatJStretch + 20 && ind != gr_slatJWidth) + { + int indx = ind - gr_slatJStretch; + return getJustify(seg, indx / 5, indx % 5); + } + + switch (ind) + { + case gr_slatAdvX : return int(m_advance.x); + case gr_slatAdvY : return int(m_advance.y); + case gr_slatAttTo : return m_parent ? 1 : 0; + case gr_slatAttX : return int(m_attach.x); + case gr_slatAttY : return int(m_attach.y); + case gr_slatAttXOff : + case gr_slatAttYOff : return 0; + case gr_slatAttWithX : return int(m_with.x); + case gr_slatAttWithY : return int(m_with.y); + case gr_slatAttWithXOff: + case gr_slatAttWithYOff:return 0; + case gr_slatAttLevel : return m_attLevel; + case gr_slatBreak : return seg->charinfo(m_original)->breakWeight(); + case gr_slatCompRef : return 0; + case gr_slatDir : return seg->dir() & 1; + case gr_slatInsert : return isInsertBefore(); + case gr_slatPosX : return int(m_position.x); // but need to calculate it + case gr_slatPosY : return int(m_position.y); + case gr_slatShiftX : return int(m_shift.x); + case gr_slatShiftY : return int(m_shift.y); + case gr_slatMeasureSol: return -1; // err what's this? + case gr_slatMeasureEol: return -1; + case gr_slatJWidth: return int(m_just); + case gr_slatUserDefnV1: subindex = 0; GR_FALLTHROUGH; + // no break + case gr_slatUserDefn : return subindex < seg->numAttrs() ? m_userAttr[subindex] : 0; + case gr_slatSegSplit : return seg->charinfo(m_original)->flags() & 3; + case gr_slatBidiLevel: return m_bidiLevel; + case gr_slatColFlags : { SlotCollision *c = seg->collisionInfo(this); return c ? c->flags() : 0; } + case gr_slatColLimitblx:SLOTGETCOLATTR(limit().bl.x) + case gr_slatColLimitbly:SLOTGETCOLATTR(limit().bl.y) + case gr_slatColLimittrx:SLOTGETCOLATTR(limit().tr.x) + case gr_slatColLimittry:SLOTGETCOLATTR(limit().tr.y) + case gr_slatColShiftx : SLOTGETCOLATTR(offset().x) + case gr_slatColShifty : SLOTGETCOLATTR(offset().y) + case gr_slatColMargin : SLOTGETCOLATTR(margin()) + case gr_slatColMarginWt:SLOTGETCOLATTR(marginWt()) + case gr_slatColExclGlyph:SLOTGETCOLATTR(exclGlyph()) + case gr_slatColExclOffx:SLOTGETCOLATTR(exclOffset().x) + case gr_slatColExclOffy:SLOTGETCOLATTR(exclOffset().y) + case gr_slatSeqClass : SLOTGETCOLATTR(seqClass()) + case gr_slatSeqProxClass:SLOTGETCOLATTR(seqProxClass()) + case gr_slatSeqOrder : SLOTGETCOLATTR(seqOrder()) + case gr_slatSeqAboveXoff:SLOTGETCOLATTR(seqAboveXoff()) + case gr_slatSeqAboveWt: SLOTGETCOLATTR(seqAboveWt()) + case gr_slatSeqBelowXlim:SLOTGETCOLATTR(seqBelowXlim()) + case gr_slatSeqBelowWt: SLOTGETCOLATTR(seqBelowWt()) + case gr_slatSeqValignHt:SLOTGETCOLATTR(seqValignHt()) + case gr_slatSeqValignWt:SLOTGETCOLATTR(seqValignWt()) + default : return 0; + } +} + +#define SLOTCOLSETATTR(x) { \ + SlotCollision *c = seg->collisionInfo(this); \ + if (c) { c-> x ; c->setFlags(c->flags() & ~SlotCollision::COLL_KNOWN); } \ + break; } +#define SLOTCOLSETCOMPLEXATTR(t, y, x) { \ + SlotCollision *c = seg->collisionInfo(this); \ + if (c) { \ + const t &s = c-> y; \ + c-> x ; c->setFlags(c->flags() & ~SlotCollision::COLL_KNOWN); } \ + break; } + +void Slot::setAttr(Segment *seg, attrCode ind, uint8 subindex, int16 value, const SlotMap & map) +{ + if (ind == gr_slatUserDefnV1) + { + ind = gr_slatUserDefn; + subindex = 0; + if (seg->numAttrs() == 0) + return; + } + else if (ind >= gr_slatJStretch && ind < gr_slatJStretch + 20 && ind != gr_slatJWidth) + { + int indx = ind - gr_slatJStretch; + return setJustify(seg, indx / 5, indx % 5, value); + } + + switch (ind) + { + case gr_slatAdvX : m_advance.x = value; break; + case gr_slatAdvY : m_advance.y = value; break; + case gr_slatAttTo : + { + const uint16 idx = uint16(value); + if (idx < map.size() && map[idx]) + { + Slot *other = map[idx]; + if (other == this || other == m_parent || other->isCopied()) break; + if (m_parent) { m_parent->removeChild(this); attachTo(NULL); } + Slot *pOther = other; + int count = 0; + bool foundOther = false; + while (pOther) + { + ++count; + if (pOther == this) foundOther = true; + pOther = pOther->attachedTo(); + } + for (pOther = m_child; pOther; pOther = pOther->m_child) + ++count; + for (pOther = m_sibling; pOther; pOther = pOther->m_sibling) + ++count; + if (count < 100 && !foundOther && other->child(this)) + { + attachTo(other); + if ((map.dir() != 0) ^ (idx > subindex)) + m_with = Position(advance(), 0); + else // normal match to previous root + m_attach = Position(other->advance(), 0); + } + } + break; + } + case gr_slatAttX : m_attach.x = value; break; + case gr_slatAttY : m_attach.y = value; break; + case gr_slatAttXOff : + case gr_slatAttYOff : break; + case gr_slatAttWithX : m_with.x = value; break; + case gr_slatAttWithY : m_with.y = value; break; + case gr_slatAttWithXOff : + case gr_slatAttWithYOff : break; + case gr_slatAttLevel : + m_attLevel = byte(value); + break; + case gr_slatBreak : + seg->charinfo(m_original)->breakWeight(value); + break; + case gr_slatCompRef : break; // not sure what to do here + case gr_slatDir : break; + case gr_slatInsert : + markInsertBefore(value? true : false); + break; + case gr_slatPosX : break; // can't set these here + case gr_slatPosY : break; + case gr_slatShiftX : m_shift.x = value; break; + case gr_slatShiftY : m_shift.y = value; break; + case gr_slatMeasureSol : break; + case gr_slatMeasureEol : break; + case gr_slatJWidth : just(value); break; + case gr_slatSegSplit : seg->charinfo(m_original)->addflags(value & 3); break; + case gr_slatUserDefn : m_userAttr[subindex] = value; break; + case gr_slatColFlags : { + SlotCollision *c = seg->collisionInfo(this); + if (c) + c->setFlags(value); + break; } + case gr_slatColLimitblx : SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(Position(value, s.bl.y), s.tr))) + case gr_slatColLimitbly : SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(Position(s.bl.x, value), s.tr))) + case gr_slatColLimittrx : SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(s.bl, Position(value, s.tr.y)))) + case gr_slatColLimittry : SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(s.bl, Position(s.tr.x, value)))) + case gr_slatColMargin : SLOTCOLSETATTR(setMargin(value)) + case gr_slatColMarginWt : SLOTCOLSETATTR(setMarginWt(value)) + case gr_slatColExclGlyph : SLOTCOLSETATTR(setExclGlyph(value)) + case gr_slatColExclOffx : SLOTCOLSETCOMPLEXATTR(Position, exclOffset(), setExclOffset(Position(value, s.y))) + case gr_slatColExclOffy : SLOTCOLSETCOMPLEXATTR(Position, exclOffset(), setExclOffset(Position(s.x, value))) + case gr_slatSeqClass : SLOTCOLSETATTR(setSeqClass(value)) + case gr_slatSeqProxClass : SLOTCOLSETATTR(setSeqProxClass(value)) + case gr_slatSeqOrder : SLOTCOLSETATTR(setSeqOrder(value)) + case gr_slatSeqAboveXoff : SLOTCOLSETATTR(setSeqAboveXoff(value)) + case gr_slatSeqAboveWt : SLOTCOLSETATTR(setSeqAboveWt(value)) + case gr_slatSeqBelowXlim : SLOTCOLSETATTR(setSeqBelowXlim(value)) + case gr_slatSeqBelowWt : SLOTCOLSETATTR(setSeqBelowWt(value)) + case gr_slatSeqValignHt : SLOTCOLSETATTR(setSeqValignHt(value)) + case gr_slatSeqValignWt : SLOTCOLSETATTR(setSeqValignWt(value)) + default : + break; + } +} + +int Slot::getJustify(const Segment *seg, uint8 level, uint8 subindex) const +{ + if (level && level >= seg->silf()->numJustLevels()) return 0; + + if (m_justs) + return m_justs->values[level * SlotJustify::NUMJUSTPARAMS + subindex]; + + if (level >= seg->silf()->numJustLevels()) return 0; + Justinfo *jAttrs = seg->silf()->justAttrs() + level; + + switch (subindex) { + case 0 : return seg->glyphAttr(gid(), jAttrs->attrStretch()); + case 1 : return seg->glyphAttr(gid(), jAttrs->attrShrink()); + case 2 : return seg->glyphAttr(gid(), jAttrs->attrStep()); + case 3 : return seg->glyphAttr(gid(), jAttrs->attrWeight()); + case 4 : return 0; // not been set yet, so clearly 0 + default: return 0; + } +} + +void Slot::setJustify(Segment *seg, uint8 level, uint8 subindex, int16 value) +{ + if (level && level >= seg->silf()->numJustLevels()) return; + if (!m_justs) + { + SlotJustify *j = seg->newJustify(); + if (!j) return; + j->LoadSlot(this, seg); + m_justs = j; + } + m_justs->values[level * SlotJustify::NUMJUSTPARAMS + subindex] = value; +} + +bool Slot::child(Slot *ap) +{ + if (this == ap) return false; + else if (ap == m_child) return true; + else if (!m_child) + m_child = ap; + else + return m_child->sibling(ap); + return true; +} + +bool Slot::sibling(Slot *ap) +{ + if (this == ap) return false; + else if (ap == m_sibling) return true; + else if (!m_sibling || !ap) + m_sibling = ap; + else + return m_sibling->sibling(ap); + return true; +} + +bool Slot::removeChild(Slot *ap) +{ + if (this == ap || !m_child || !ap) return false; + else if (ap == m_child) + { + Slot *nSibling = m_child->nextSibling(); + m_child->nextSibling(NULL); + m_child = nSibling; + return true; + } + for (Slot *p = m_child; p; p = p->m_sibling) + { + if (p->m_sibling && p->m_sibling == ap) + { + p->m_sibling = p->m_sibling->m_sibling; + ap->nextSibling(NULL); + return true; + } + } + return false; +} + +void Slot::setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph) +{ + m_glyphid = glyphid; + m_bidiCls = -1; + if (!theGlyph) + { + theGlyph = seg->getFace()->glyphs().glyphSafe(glyphid); + if (!theGlyph) + { + m_realglyphid = 0; + m_advance = Position(0.,0.); + return; + } + } + m_realglyphid = theGlyph->attrs()[seg->silf()->aPseudo()]; + if (m_realglyphid > seg->getFace()->glyphs().numGlyphs()) + m_realglyphid = 0; + const GlyphFace *aGlyph = theGlyph; + if (m_realglyphid) + { + aGlyph = seg->getFace()->glyphs().glyphSafe(m_realglyphid); + if (!aGlyph) aGlyph = theGlyph; + } + m_advance = Position(aGlyph->theAdvance().x, 0.); + if (seg->silf()->aPassBits()) + { + seg->mergePassBits(uint8(theGlyph->attrs()[seg->silf()->aPassBits()])); + if (seg->silf()->numPasses() > 16) + seg->mergePassBits(theGlyph->attrs()[seg->silf()->aPassBits()+1] << 16); + } +} + +void Slot::floodShift(Position adj, int depth) +{ + if (depth > 100) + return; + m_position += adj; + if (m_child) m_child->floodShift(adj, depth + 1); + if (m_sibling) m_sibling->floodShift(adj, depth + 1); +} + +void SlotJustify::LoadSlot(const Slot *s, const Segment *seg) +{ + for (int i = seg->silf()->numJustLevels() - 1; i >= 0; --i) + { + Justinfo *justs = seg->silf()->justAttrs() + i; + int16 *v = values + i * NUMJUSTPARAMS; + v[0] = seg->glyphAttr(s->gid(), justs->attrStretch()); + v[1] = seg->glyphAttr(s->gid(), justs->attrShrink()); + v[2] = seg->glyphAttr(s->gid(), justs->attrStep()); + v[3] = seg->glyphAttr(s->gid(), justs->attrWeight()); + } +} + +Slot * Slot::nextInCluster(const Slot *s) const +{ + Slot *base; + if (s->firstChild()) + return s->firstChild(); + else if (s->nextSibling()) + return s->nextSibling(); + while ((base = s->attachedTo())) + { + // if (base->firstChild() == s && base->nextSibling()) + if (base->nextSibling()) + return base->nextSibling(); + s = base; + } + return NULL; +} + +bool Slot::isChildOf(const Slot *base) const +{ + for (Slot *p = m_parent; p; p = p->m_parent) + if (p == base) + return true; + return false; +} diff --git a/gfx/graphite2/src/Sparse.cpp b/gfx/graphite2/src/Sparse.cpp new file mode 100644 index 0000000000..aa43113669 --- /dev/null +++ b/gfx/graphite2/src/Sparse.cpp @@ -0,0 +1,62 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cassert> +#include "inc/Sparse.h" +#include "inc/bits.h" + +using namespace graphite2; + +const sparse::chunk sparse::empty_chunk = {0,0}; + +sparse::~sparse() throw() +{ + if (m_array.map == &empty_chunk) return; + free(m_array.values); +} + + +sparse::mapped_type sparse::operator [] (const key_type k) const throw() +{ + mapped_type g = key_type(k/SIZEOF_CHUNK - m_nchunks) >> (sizeof k*8 - 1); + const chunk & c = m_array.map[g*k/SIZEOF_CHUNK]; + const mask_t m = c.mask >> (SIZEOF_CHUNK - 1 - (k%SIZEOF_CHUNK)); + g *= m & 1; + + return g*m_array.values[g*(c.offset + bit_set_count(m >> 1))]; +} + + +size_t sparse::capacity() const throw() +{ + size_t n = m_nchunks, + s = 0; + + for (const chunk *ci=m_array.map; n; --n, ++ci) + s += bit_set_count(ci->mask); + + return s; +} diff --git a/gfx/graphite2/src/TtfUtil.cpp b/gfx/graphite2/src/TtfUtil.cpp new file mode 100644 index 0000000000..2eb46a11fb --- /dev/null +++ b/gfx/graphite2/src/TtfUtil.cpp @@ -0,0 +1,2053 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +/*--------------------------------------------------------------------*//*:Ignore this sentence. + +File: TtfUtil.cpp +Responsibility: Alan Ward +Last reviewed: Not yet. + +Description + Implements the methods for TtfUtil class. This file should remain portable to any C++ + environment by only using standard C++ and the TTF structurs defined in Tt.h. +-------------------------------------------------------------------------------*//*:End Ignore*/ + + +/*********************************************************************************************** + Include files +***********************************************************************************************/ +// Language headers +//#include <algorithm> +#include <cassert> +#include <cstddef> +#include <cstring> +#include <climits> +#include <cwchar> +//#include <stdexcept> +// Platform headers +// Module headers +#include "inc/TtfUtil.h" +#include "inc/TtfTypes.h" +#include "inc/Endian.h" + +/*********************************************************************************************** + Forward declarations +***********************************************************************************************/ + +/*********************************************************************************************** + Local Constants and static variables +***********************************************************************************************/ +namespace +{ +#ifdef ALL_TTFUTILS + // max number of components allowed in composite glyphs + const int kMaxGlyphComponents = 8; +#endif + + template <int R, typename T> + inline float fixed_to_float(const T f) { + return float(f)/float(2^R); + } + +/*---------------------------------------------------------------------------------------------- + Table of standard Postscript glyph names. From Martin Hosken. Disagress with ttfdump.exe +---------------------------------------------------------------------------------------------*/ +#ifdef ALL_TTFUTILS + const int kcPostNames = 258; + + const char * rgPostName[kcPostNames] = { + ".notdef", ".null", "nonmarkingreturn", "space", "exclam", "quotedbl", "numbersign", + "dollar", "percent", "ampersand", "quotesingle", "parenleft", + "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", + "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", + "nine", "colon", "semicolon", "less", "equal", "greater", "question", + "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", + "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", + "bracketleft", "backslash", "bracketright", "asciicircum", + "underscore", "grave", "a", "b", "c", "d", "e", "f", "g", "h", "i", + "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", + "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", + "Adieresis", "Aring", "Ccedilla", "Eacute", "Ntilde", "Odieresis", + "Udieresis", "aacute", "agrave", "acircumflex", "adieresis", "atilde", + "aring", "ccedilla", "eacute", "egrave", "ecircumflex", "edieresis", + "iacute", "igrave", "icircumflex", "idieresis", "ntilde", "oacute", + "ograve", "ocircumflex", "odieresis", "otilde", "uacute", "ugrave", + "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling", + "section", "bullet", "paragraph", "germandbls", "registered", + "copyright", "trademark", "acute", "dieresis", "notequal", "AE", + "Oslash", "infinity", "plusminus", "lessequal", "greaterequal", "yen", + "mu", "partialdiff", "summation", "product", "pi", "integral", + "ordfeminine", "ordmasculine", "Omega", "ae", "oslash", "questiondown", + "exclamdown", "logicalnot", "radical", "florin", "approxequal", + "Delta", "guillemotleft", "guillemotright", "ellipsis", "nonbreakingspace", + "Agrave", "Atilde", "Otilde", "OE", "oe", "endash", "emdash", + "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide", + "lozenge", "ydieresis", "Ydieresis", "fraction", "currency", + "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl", "periodcentered", + "quotesinglbase", "quotedblbase", "perthousand", "Acircumflex", + "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute", + "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex", + "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi", + "circumflex", "tilde", "macron", "breve", "dotaccent", "ring", + "cedilla", "hungarumlaut", "ogonek", "caron", "Lslash", "lslash", + "Scaron", "scaron", "Zcaron", "zcaron", "brokenbar", "Eth", "eth", + "Yacute", "yacute", "Thorn", "thorn", "minus", "multiply", + "onesuperior", "twosuperior", "threesuperior", "onehalf", "onequarter", + "threequarters", "franc", "Gbreve", "gbreve", "Idotaccent", "Scedilla", + "scedilla", "Cacute", "cacute", "Ccaron", "ccaron", + "dcroat" }; +#endif + +} // end of namespace + +/*********************************************************************************************** + Methods +***********************************************************************************************/ + +/* Note on error processing: The code guards against bad glyph ids being used to look up data +in open ended tables (loca, hmtx). If the glyph id comes from a cmap this shouldn't happen +but it seems prudent to check for user errors here. The code does assume that data obtained +from the TTF file is valid otherwise (though the CheckTable method seeks to check for +obvious problems that might accompany a change in table versions). For example an invalid +offset in the loca table which could exceed the size of the glyf table is NOT trapped. +Likewise if numberOf_LongHorMetrics in the hhea table is wrong, this will NOT be trapped, +which could cause a lookup in the hmtx table to exceed the table length. Of course, TTF tables +that are completely corrupt will cause unpredictable results. */ + +/* Note on composite glyphs: Glyphs that have components that are themselves composites +are not supported. IsDeepComposite can be used to test for this. False is returned from many +of the methods in this cases. It is unclear how to build composite glyphs in some cases, +so this code represents my best guess until test cases can be found. See notes on the high- +level GlyfPoints method. */ +namespace graphite2 +{ +namespace TtfUtil +{ + + +/*---------------------------------------------------------------------------------------------- + Get offset and size of the offset table needed to find table directory. + Return true if success, false otherwise. + lSize excludes any table directory entries. +----------------------------------------------------------------------------------------------*/ +bool GetHeaderInfo(size_t & lOffset, size_t & lSize) +{ + lOffset = 0; + lSize = offsetof(Sfnt::OffsetSubTable, table_directory); + assert(sizeof(uint32) + 4*sizeof (uint16) == lSize); + return true; +} + +/*---------------------------------------------------------------------------------------------- + Check the offset table for expected data. + Return true if success, false otherwise. +----------------------------------------------------------------------------------------------*/ +bool CheckHeader(const void * pHdr) +{ + const Sfnt::OffsetSubTable * pOffsetTable + = reinterpret_cast<const Sfnt::OffsetSubTable *>(pHdr); + + return pHdr && be::swap(pOffsetTable->scaler_type) == Sfnt::OffsetSubTable::TrueTypeWin; +} + +/*---------------------------------------------------------------------------------------------- + Get offset and size of the table directory. + Return true if successful, false otherwise. +----------------------------------------------------------------------------------------------*/ +bool GetTableDirInfo(const void * pHdr, size_t & lOffset, size_t & lSize) +{ + const Sfnt::OffsetSubTable * pOffsetTable + = reinterpret_cast<const Sfnt::OffsetSubTable *>(pHdr); + + lOffset = offsetof(Sfnt::OffsetSubTable, table_directory); + lSize = be::swap(pOffsetTable->num_tables) + * sizeof(Sfnt::OffsetSubTable::Entry); + + return true; +} + + +/*---------------------------------------------------------------------------------------------- + Get offset and size of the specified table. + Return true if successful, false otherwise. On false, offset and size will be 0. +----------------------------------------------------------------------------------------------*/ +bool GetTableInfo(const Tag TableTag, const void * pHdr, const void * pTableDir, + size_t & lOffset, size_t & lSize) +{ + const Sfnt::OffsetSubTable * pOffsetTable + = reinterpret_cast<const Sfnt::OffsetSubTable *>(pHdr); + const size_t num_tables = be::swap(pOffsetTable->num_tables); + const Sfnt::OffsetSubTable::Entry + * entry_itr = reinterpret_cast<const Sfnt::OffsetSubTable::Entry *>( + pTableDir), + * const dir_end = entry_itr + num_tables; + + if (num_tables > 40) + return false; + + for (;entry_itr != dir_end; ++entry_itr) // 40 - safe guard + { + if (be::swap(entry_itr->tag) == TableTag) + { + lOffset = be::swap(entry_itr->offset); + lSize = be::swap(entry_itr->length); + return true; + } + } + + return false; +} + +/*---------------------------------------------------------------------------------------------- + Check the specified table. Tests depend on the table type. + Return true if successful, false otherwise. +----------------------------------------------------------------------------------------------*/ +bool CheckTable(const Tag TableId, const void * pTable, size_t lTableSize) +{ + using namespace Sfnt; + + if (pTable == 0 || lTableSize < 4) return false; + + switch(TableId) + { + case Tag::cmap: // cmap + { + const Sfnt::CharacterCodeMap * const pCmap + = reinterpret_cast<const Sfnt::CharacterCodeMap *>(pTable); + if (lTableSize < sizeof(Sfnt::CharacterCodeMap)) + return false; + return be::swap(pCmap->version) == 0; + } + + case Tag::head: // head + { + const Sfnt::FontHeader * const pHead + = reinterpret_cast<const Sfnt::FontHeader *>(pTable); + if (lTableSize < sizeof(Sfnt::FontHeader)) + return false; + bool r = be::swap(pHead->version) == OneFix + && be::swap(pHead->magic_number) == FontHeader::MagicNumber + && be::swap(pHead->glyph_data_format) + == FontHeader::GlypDataFormat + && (be::swap(pHead->index_to_loc_format) + == FontHeader::ShortIndexLocFormat + || be::swap(pHead->index_to_loc_format) + == FontHeader::LongIndexLocFormat) + && sizeof(FontHeader) <= lTableSize; + return r; + } + + case Tag::post: // post + { + const Sfnt::PostScriptGlyphName * const pPost + = reinterpret_cast<const Sfnt::PostScriptGlyphName *>(pTable); + if (lTableSize < sizeof(Sfnt::PostScriptGlyphName)) + return false; + const fixed format = be::swap(pPost->format); + bool r = format == PostScriptGlyphName::Format1 + || format == PostScriptGlyphName::Format2 + || format == PostScriptGlyphName::Format3 + || format == PostScriptGlyphName::Format25; + return r; + } + + case Tag::hhea: // hhea + { + const Sfnt::HorizontalHeader * pHhea = + reinterpret_cast<const Sfnt::HorizontalHeader *>(pTable); + if (lTableSize < sizeof(Sfnt::HorizontalHeader)) + return false; + bool r = be::swap(pHhea->version) == OneFix + && be::swap(pHhea->metric_data_format) == 0 + && sizeof (Sfnt::HorizontalHeader) <= lTableSize; + return r; + } + + case Tag::maxp: // maxp + { + const Sfnt::MaximumProfile * pMaxp = + reinterpret_cast<const Sfnt::MaximumProfile *>(pTable); + if (lTableSize < sizeof(Sfnt::MaximumProfile)) + return false; + bool r = be::swap(pMaxp->version) == OneFix + && sizeof(Sfnt::MaximumProfile) <= lTableSize; + return r; + } + + case Tag::OS_2: // OS/2 + { + const Sfnt::Compatibility * pOs2 + = reinterpret_cast<const Sfnt::Compatibility *>(pTable); + if (be::swap(pOs2->version) == 0) + { // OS/2 table version 1 size +// if (sizeof(Sfnt::Compatibility) +// - sizeof(uint32)*2 - sizeof(int16)*2 +// - sizeof(uint16)*3 <= lTableSize) + if (sizeof(Sfnt::Compatibility0) <= lTableSize) + return true; + } + else if (be::swap(pOs2->version) == 1) + { // OS/2 table version 2 size +// if (sizeof(Sfnt::Compatibility) +// - sizeof(int16) *2 +// - sizeof(uint16)*3 <= lTableSize) + if (sizeof(Sfnt::Compatibility1) <= lTableSize) + return true; + } + else if (be::swap(pOs2->version) == 2) + { // OS/2 table version 3 size + if (sizeof(Sfnt::Compatibility2) <= lTableSize) + return true; + } + else if (be::swap(pOs2->version) == 3 || be::swap(pOs2->version) == 4) + { // OS/2 table version 4 size - version 4 changed the meaning of some fields which we don't use + if (sizeof(Sfnt::Compatibility3) <= lTableSize) + return true; + } + else + return false; + break; + } + + case Tag::name: + { + const Sfnt::FontNames * pName + = reinterpret_cast<const Sfnt::FontNames *>(pTable); + if (lTableSize < sizeof(Sfnt::FontNames)) + return false; + return be::swap(pName->format) == 0; + } + + case Tag::glyf: + { + return (lTableSize >= sizeof(Sfnt::Glyph)); + } + + default: + break; + } + + return true; +} + +/*---------------------------------------------------------------------------------------------- + Return the number of glyphs in the font. Should never be less than zero. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +size_t GlyphCount(const void * pMaxp) +{ + const Sfnt::MaximumProfile * pTable = + reinterpret_cast<const Sfnt::MaximumProfile *>(pMaxp); + return be::swap(pTable->num_glyphs); +} + +#ifdef ALL_TTFUTILS +/*---------------------------------------------------------------------------------------------- + Return the maximum number of components for any composite glyph in the font. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +size_t MaxCompositeComponentCount(const void * pMaxp) +{ + const Sfnt::MaximumProfile * pTable = + reinterpret_cast<const Sfnt::MaximumProfile *>(pMaxp); + return be::swap(pTable->max_component_elements); +} + +/*---------------------------------------------------------------------------------------------- + Composite glyphs can be composed of glyphs that are themselves composites. + This method returns the maximum number of levels like this for any glyph in the font. + A non-composite glyph has a level of 1. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +size_t MaxCompositeLevelCount(const void * pMaxp) +{ + const Sfnt::MaximumProfile * pTable = + reinterpret_cast<const Sfnt::MaximumProfile *>(pMaxp); + return be::swap(pTable->max_component_depth); +} + +/*---------------------------------------------------------------------------------------------- + Return the number of glyphs in the font according to a differt source. + Should never be less than zero. Return -1 on failure. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +size_t LocaGlyphCount(size_t lLocaSize, const void * pHead) //throw(std::domain_error) +{ + + const Sfnt::FontHeader * pTable + = reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + if (be::swap(pTable->index_to_loc_format) + == Sfnt::FontHeader::ShortIndexLocFormat) + // loca entries are two bytes and have been divided by two + return (lLocaSize >> 1) - 1; + + if (be::swap(pTable->index_to_loc_format) + == Sfnt::FontHeader::LongIndexLocFormat) + // loca entries are four bytes + return (lLocaSize >> 2) - 1; + + return -1; + //throw std::domain_error("head table in inconsistent state. The font may be corrupted"); +} +#endif + +/*---------------------------------------------------------------------------------------------- + Return the design units the font is designed with +----------------------------------------------------------------------------------------------*/ +int DesignUnits(const void * pHead) +{ + const Sfnt::FontHeader * pTable = + reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + return be::swap(pTable->units_per_em); +} + +#ifdef ALL_TTFUTILS +/*---------------------------------------------------------------------------------------------- + Return the checksum from the head table, which serves as a unique identifer for the font. +----------------------------------------------------------------------------------------------*/ +int HeadTableCheckSum(const void * pHead) +{ + const Sfnt::FontHeader * pTable = + reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + return be::swap(pTable->check_sum_adjustment); +} + +/*---------------------------------------------------------------------------------------------- + Return the create time from the head table. This consists of a 64-bit integer, which + we return here as two 32-bit integers. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +void HeadTableCreateTime(const void * pHead, + unsigned int * pnDateBC, unsigned int * pnDateAD) +{ + const Sfnt::FontHeader * pTable = + reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + *pnDateBC = be::swap(pTable->created[0]); + *pnDateAD = be::swap(pTable->created[1]); +} + +/*---------------------------------------------------------------------------------------------- + Return the modify time from the head table.This consists of a 64-bit integer, which + we return here as two 32-bit integers. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +void HeadTableModifyTime(const void * pHead, + unsigned int * pnDateBC, unsigned int *pnDateAD) +{ + const Sfnt::FontHeader * pTable = + reinterpret_cast<const Sfnt::FontHeader *>(pHead); + ; + *pnDateBC = be::swap(pTable->modified[0]); + *pnDateAD = be::swap(pTable->modified[1]); +} + +/*---------------------------------------------------------------------------------------------- + Return true if the font is italic. +----------------------------------------------------------------------------------------------*/ +bool IsItalic(const void * pHead) +{ + const Sfnt::FontHeader * pTable = + reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + return ((be::swap(pTable->mac_style) & 0x00000002) != 0); +} + +/*---------------------------------------------------------------------------------------------- + Return the ascent for the font +----------------------------------------------------------------------------------------------*/ +int FontAscent(const void * pOs2) +{ + const Sfnt::Compatibility * pTable = reinterpret_cast<const Sfnt::Compatibility *>(pOs2); + + return be::swap(pTable->win_ascent); +} + +/*---------------------------------------------------------------------------------------------- + Return the descent for the font +----------------------------------------------------------------------------------------------*/ +int FontDescent(const void * pOs2) +{ + const Sfnt::Compatibility * pTable = reinterpret_cast<const Sfnt::Compatibility *>(pOs2); + + return be::swap(pTable->win_descent); +} + +/*---------------------------------------------------------------------------------------------- + Get the bold and italic style bits. + Return true if successful. false otherwise. + In addition to checking the OS/2 table, one could also check + the head table's macStyle field (overridden by the OS/2 table on Win) + the sub-family name in the name table (though this can contain oblique, dark, etc too) +----------------------------------------------------------------------------------------------*/ +bool FontOs2Style(const void *pOs2, bool & fBold, bool & fItalic) +{ + const Sfnt::Compatibility * pTable = reinterpret_cast<const Sfnt::Compatibility *>(pOs2); + + fBold = (be::swap(pTable->fs_selection) & Sfnt::Compatibility::Bold) != 0; + fItalic = (be::swap(pTable->fs_selection) & Sfnt::Compatibility::Italic) != 0; + + return true; +} +#endif + +/*---------------------------------------------------------------------------------------------- + Method for searching name table. +----------------------------------------------------------------------------------------------*/ +bool GetNameInfo(const void * pName, int nPlatformId, int nEncodingId, + int nLangId, int nNameId, size_t & lOffset, size_t & lSize) +{ + lOffset = 0; + lSize = 0; + + const Sfnt::FontNames * pTable = reinterpret_cast<const Sfnt::FontNames *>(pName); + uint16 cRecord = be::swap(pTable->count); + uint16 nRecordOffset = be::swap(pTable->string_offset); + const Sfnt::NameRecord * pRecord = reinterpret_cast<const Sfnt::NameRecord *>(pTable + 1); + + for (int i = 0; i < cRecord; ++i) + { + if (be::swap(pRecord->platform_id) == nPlatformId && + be::swap(pRecord->platform_specific_id) == nEncodingId && + be::swap(pRecord->language_id) == nLangId && + be::swap(pRecord->name_id) == nNameId) + { + lOffset = be::swap(pRecord->offset) + nRecordOffset; + lSize = be::swap(pRecord->length); + return true; + } + pRecord++; + } + + return false; +} + +#ifdef ALL_TTFUTILS +/*---------------------------------------------------------------------------------------------- + Return all the lang-IDs that have data for the given name-IDs. Assume that there is room + in the return array (langIdList) for 128 items. The purpose of this method is to return + a list of all possible lang-IDs. +----------------------------------------------------------------------------------------------*/ +int GetLangsForNames(const void * pName, int nPlatformId, int nEncodingId, + int * nameIdList, int cNameIds, short * langIdList) +{ + const Sfnt::FontNames * pTable = reinterpret_cast<const Sfnt::FontNames *>(pName); + int cLangIds = 0; + uint16 cRecord = be::swap(pTable->count); + if (cRecord > 127) return cLangIds; + //uint16 nRecordOffset = swapw(pTable->stringOffset); + const Sfnt::NameRecord * pRecord = reinterpret_cast<const Sfnt::NameRecord *>(pTable + 1); + + for (int i = 0; i < cRecord; ++i) + { + if (be::swap(pRecord->platform_id) == nPlatformId && + be::swap(pRecord->platform_specific_id) == nEncodingId) + { + bool fNameFound = false; + int nLangId = be::swap(pRecord->language_id); + int nNameId = be::swap(pRecord->name_id); + for (int j = 0; j < cNameIds; j++) + { + if (nNameId == nameIdList[j]) + { + fNameFound = true; + break; + } + } + if (fNameFound) + { + // Add it if it's not there. + int ilang; + for (ilang = 0; ilang < cLangIds; ilang++) + if (langIdList[ilang] == nLangId) + break; + if (ilang >= cLangIds) + { + langIdList[cLangIds] = short(nLangId); + cLangIds++; + } + if (cLangIds == 128) + return cLangIds; + } + } + pRecord++; + } + + return cLangIds; +} + +/*---------------------------------------------------------------------------------------------- + Get the offset and size of the font family name in English for the MS Platform with Unicode + writing system. The offset is within the pName data. The string is double byte with MSB + first. +----------------------------------------------------------------------------------------------*/ +bool Get31EngFamilyInfo(const void * pName, size_t & lOffset, size_t & lSize) +{ + return GetNameInfo(pName, Sfnt::NameRecord::Microsoft, 1, 1033, + Sfnt::NameRecord::Family, lOffset, lSize); +} + +/*---------------------------------------------------------------------------------------------- + Get the offset and size of the full font name in English for the MS Platform with Unicode + writing system. The offset is within the pName data. The string is double byte with MSB + first. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +bool Get31EngFullFontInfo(const void * pName, size_t & lOffset, size_t & lSize) +{ + return GetNameInfo(pName, Sfnt::NameRecord::Microsoft, 1, 1033, + Sfnt::NameRecord::Fullname, lOffset, lSize); +} + +/*---------------------------------------------------------------------------------------------- + Get the offset and size of the font family name in English for the MS Platform with Symbol + writing system. The offset is within the pName data. The string is double byte with MSB + first. +----------------------------------------------------------------------------------------------*/ +bool Get30EngFamilyInfo(const void * pName, size_t & lOffset, size_t & lSize) +{ + return GetNameInfo(pName, Sfnt::NameRecord::Microsoft, 0, 1033, + Sfnt::NameRecord::Family, lOffset, lSize); +} + +/*---------------------------------------------------------------------------------------------- + Get the offset and size of the full font name in English for the MS Platform with Symbol + writing system. The offset is within the pName data. The string is double byte with MSB + first. + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +bool Get30EngFullFontInfo(const void * pName, size_t & lOffset, size_t & lSize) +{ + return GetNameInfo(pName, Sfnt::NameRecord::Microsoft, 0, 1033, + Sfnt::NameRecord::Fullname, lOffset, lSize); +} + +/*---------------------------------------------------------------------------------------------- + Return the Glyph ID for a given Postscript name. This method finds the first glyph which + matches the requested Postscript name. Ideally every glyph should have a unique Postscript + name (except for special names such as .notdef), but this is not always true. + On failure return value less than zero. + -1 - table search failed + -2 - format 3 table (no Postscript glyph info) + -3 - other failures + + Note: this method is not currently used by the Graphite engine. +----------------------------------------------------------------------------------------------*/ +int PostLookup(const void * pPost, size_t lPostSize, const void * pMaxp, + const char * pPostName) +{ + using namespace Sfnt; + + const Sfnt::PostScriptGlyphName * pTable + = reinterpret_cast<const Sfnt::PostScriptGlyphName *>(pPost); + fixed format = be::swap(pTable->format); + + if (format == PostScriptGlyphName::Format3) + { // format 3 - no Postscript glyph info in font + return -2; + } + + // search for given Postscript name among the standard names + int iPostName = -1; // index in standard names + for (int i = 0; i < kcPostNames; i++) + { + if (!strcmp(pPostName, rgPostName[i])) + { + iPostName = i; + break; + } + } + + if (format == PostScriptGlyphName::Format1) + { // format 1 - use standard Postscript names + return iPostName; + } + + if (format == PostScriptGlyphName::Format25) + { + if (iPostName == -1) + return -1; + + const PostScriptGlyphName25 * pTable25 + = static_cast<const PostScriptGlyphName25 *>(pTable); + int cnGlyphs = GlyphCount(pMaxp); + for (gid16 nGlyphId = 0; nGlyphId < cnGlyphs && nGlyphId < kcPostNames; + nGlyphId++) + { // glyph_name_index25 contains bytes so no byte swapping needed + // search for first glyph id that uses the standard name + if (nGlyphId + pTable25->offset[nGlyphId] == iPostName) + return nGlyphId; + } + } + + if (format == PostScriptGlyphName::Format2) + { // format 2 + const PostScriptGlyphName2 * pTable2 + = static_cast<const PostScriptGlyphName2 *>(pTable); + + int cnGlyphs = be::swap(pTable2->number_of_glyphs); + + if (iPostName != -1) + { // did match a standard name, look for first glyph id mapped to that name + for (gid16 nGlyphId = 0; nGlyphId < cnGlyphs; nGlyphId++) + { + if (be::swap(pTable2->glyph_name_index[nGlyphId]) == iPostName) + return nGlyphId; + } + } + + { // did not match a standard name, search font specific names + size_t nStrSizeGoal = strlen(pPostName); + const char * pFirstGlyphName = reinterpret_cast<const char *>( + &pTable2->glyph_name_index[0] + cnGlyphs); + const char * pGlyphName = pFirstGlyphName; + int iInNames = 0; // index in font specific names + bool fFound = false; + const char * const endOfTable + = reinterpret_cast<const char *>(pTable2) + lPostSize; + while (pGlyphName < endOfTable && !fFound) + { // search Pascal strings for first matching name + size_t nStringSize = size_t(*pGlyphName); + if (nStrSizeGoal != nStringSize || + strncmp(pGlyphName + 1, pPostName, nStringSize)) + { // did not match + ++iInNames; + pGlyphName += nStringSize + 1; + } + else + { // did match + fFound = true; + } + } + if (!fFound) + return -1; // no font specific name matches request + + iInNames += kcPostNames; + for (gid16 nGlyphId = 0; nGlyphId < cnGlyphs; nGlyphId++) + { // search for first glyph id that maps to the found string index + if (be::swap(pTable2->glyph_name_index[nGlyphId]) == iInNames) + return nGlyphId; + } + return -1; // no glyph mapped to this index (very strange) + } + } + + return -3; +} + +/*---------------------------------------------------------------------------------------------- + Convert a Unicode character string from big endian (MSB first, Motorola) format to little + endian (LSB first, Intel) format. + nSize is the number of Unicode characters in the string. It should not include any + terminating null. If nSize is 0, it is assumed the string is null terminated. nSize + defaults to 0. + Return true if successful, false otherwise. +----------------------------------------------------------------------------------------------*/ +void SwapWString(void * pWStr, size_t nSize /* = 0 */) //throw (std::invalid_argument) +{ + if (pWStr == 0) + { +// throw std::invalid_argument("null pointer given"); + return; + } + + uint16 * pStr = reinterpret_cast<uint16 *>(pWStr); + uint16 * const pStrEnd = pStr + (nSize == 0 ? wcslen((const wchar_t*)pStr) : nSize); + + for (; pStr != pStrEnd; ++pStr) + *pStr = be::swap(*pStr); +// std::transform(pStr, pStrEnd, pStr, read<uint16>); + +// for (int i = 0; i < nSize; i++) +// { // swap the wide characters in the string +// pStr[i] = utf16(be::swap(uint16(pStr[i]))); +// } +} +#endif + +/*---------------------------------------------------------------------------------------------- + Get the left-side bearing and and advance width based on the given tables and Glyph ID + Return true if successful, false otherwise. On false, one or both value could be INT_MIN +----------------------------------------------------------------------------------------------*/ +bool HorMetrics(gid16 nGlyphId, const void * pHmtx, size_t lHmtxSize, const void * pHhea, + int & nLsb, unsigned int & nAdvWid) +{ + const Sfnt::HorizontalMetric * phmtx = + reinterpret_cast<const Sfnt::HorizontalMetric *>(pHmtx); + + const Sfnt::HorizontalHeader * phhea = + reinterpret_cast<const Sfnt::HorizontalHeader *>(pHhea); + + size_t cLongHorMetrics = be::swap(phhea->num_long_hor_metrics); + if (nGlyphId < cLongHorMetrics) + { // glyph id is acceptable + if ((nGlyphId + 1) * sizeof(Sfnt::HorizontalMetric) > lHmtxSize) return false; + nAdvWid = be::swap(phmtx[nGlyphId].advance_width); + nLsb = be::swap(phmtx[nGlyphId].left_side_bearing); + } + else + { + // guard against bad glyph id + size_t lLsbOffset = sizeof(Sfnt::HorizontalMetric) * cLongHorMetrics + + sizeof(int16) * (nGlyphId - cLongHorMetrics); // offset in bytes + // We test like this as LsbOffset is an offset not a length. + if (lLsbOffset >= lHmtxSize - sizeof(int16) || cLongHorMetrics == 0) + { + nLsb = 0; + return false; + } + nAdvWid = be::swap(phmtx[cLongHorMetrics - 1].advance_width); + nLsb = be::peek<int16>(reinterpret_cast<const byte *>(phmtx) + lLsbOffset); + } + + return true; +} + +/*---------------------------------------------------------------------------------------------- + Return a pointer to the requested cmap subtable. By default find the Microsoft Unicode + subtable. Pass nEncoding as -1 to find first table that matches only nPlatformId. + Return NULL if the subtable cannot be found. +----------------------------------------------------------------------------------------------*/ +const void * FindCmapSubtable(const void * pCmap, int nPlatformId, /* =3 */ int nEncodingId, /* = 1 */ size_t length) +{ + const Sfnt::CharacterCodeMap * pTable = reinterpret_cast<const Sfnt::CharacterCodeMap *>(pCmap); + uint16 csuPlatforms = be::swap(pTable->num_subtables); + if (length && (sizeof(Sfnt::CharacterCodeMap) + 8 * (csuPlatforms - 1) > length)) + return NULL; + for (int i = 0; i < csuPlatforms; i++) + { + if (be::swap(pTable->encoding[i].platform_id) == nPlatformId && + (nEncodingId == -1 || be::swap(pTable->encoding[i].platform_specific_id) == nEncodingId)) + { + uint32 offset = be::swap(pTable->encoding[i].offset); + const uint8 * pRtn = reinterpret_cast<const uint8 *>(pCmap) + offset; + if (length) + { + if (offset > length - 2) return NULL; + uint16 format = be::read<uint16>(pRtn); + if (format == 4) + { + if (offset > length - 4) return NULL; + uint16 subTableLength = be::peek<uint16>(pRtn); + if (i + 1 == csuPlatforms) + { + if (subTableLength > length - offset) + return NULL; + } + else if (subTableLength > be::swap(pTable->encoding[i+1].offset)) + return NULL; + } + if (format == 12) + { + if (offset > length - 6) return NULL; + uint32 subTableLength = be::peek<uint32>(pRtn); + if (i + 1 == csuPlatforms) + { + if (subTableLength > length - offset) + return NULL; + } + else if (subTableLength > be::swap(pTable->encoding[i+1].offset)) + return NULL; + } + } + return reinterpret_cast<const uint8 *>(pCmap) + offset; + } + } + + return 0; +} + +/*---------------------------------------------------------------------------------------------- + Check the Microsoft Unicode subtable for expected values +----------------------------------------------------------------------------------------------*/ +bool CheckCmapSubtable4(const void * pCmapSubtable4, const void * pCmapEnd /*, unsigned int maxgid*/) +{ + size_t table_len = (const byte *)pCmapEnd - (const byte *)pCmapSubtable4; + if (!pCmapSubtable4) return false; + const Sfnt::CmapSubTable * pTable = reinterpret_cast<const Sfnt::CmapSubTable *>(pCmapSubtable4); + // Bob H say some freeware TT fonts have version 1 (eg, CALIGULA.TTF) + // so don't check subtable version. 21 Mar 2002 spec changes version to language. + if (table_len < sizeof(*pTable) || be::swap(pTable->format) != 4) return false; + const Sfnt::CmapSubTableFormat4 * pTable4 = reinterpret_cast<const Sfnt::CmapSubTableFormat4 *>(pCmapSubtable4); + if (table_len < sizeof(*pTable4)) + return false; + uint16 length = be::swap(pTable4->length); + if (length > table_len) + return false; + if (length < sizeof(Sfnt::CmapSubTableFormat4)) + return false; + uint16 nRanges = be::swap(pTable4->seg_count_x2) >> 1; + if (!nRanges || length < sizeof(Sfnt::CmapSubTableFormat4) + 4 * nRanges * sizeof(uint16)) + return false; + // check last range is properly terminated + uint16 chEnd = be::peek<uint16>(pTable4->end_code + nRanges - 1); + if (chEnd != 0xFFFF) + return false; +#if 0 + int lastend = -1; + for (int i = 0; i < nRanges; ++i) + { + uint16 end = be::peek<uint16>(pTable4->end_code + i); + uint16 start = be::peek<uint16>(pTable4->end_code + nRanges + 1 + i); + int16 delta = be::peek<int16>(pTable4->end_code + 2*nRanges + 1 + i); + uint16 offset = be::peek<uint16>(pTable4->end_code + 3*nRanges + 1 + i); + if (lastend >= end || lastend >= start) + return false; + if (offset) + { + const uint16 *gstart = pTable4->end_code + 3*nRanges + 1 + i + (offset >> 1); + const uint16 *gend = gstart + end - start; + if ((char *)gend >= (char *)pCmapSubtable4 + length) + return false; + while (gstart <= gend) + { + uint16 g = be::peek<uint16>(gstart++); + if (g && ((g + delta) & 0xFFFF) > maxgid) + return false; + } + } + else if (((delta + end) & 0xFFFF) > maxgid) + return false; + lastend = end; + } +#endif + return true; +} + +/*---------------------------------------------------------------------------------------------- + Return the Glyph ID for the given Unicode ID in the Microsoft Unicode subtable. + (Actually this code only depends on subtable being format 4.) + Return 0 if the Unicode ID is not in the subtable. +----------------------------------------------------------------------------------------------*/ +gid16 CmapSubtable4Lookup(const void * pCmapSubtabel4, unsigned int nUnicodeId, int rangeKey) +{ + const Sfnt::CmapSubTableFormat4 * pTable = reinterpret_cast<const Sfnt::CmapSubTableFormat4 *>(pCmapSubtabel4); + + uint16 nSeg = be::swap(pTable->seg_count_x2) >> 1; + + uint16 n; + const uint16 * pLeft, * pMid; + uint16 cMid, chStart, chEnd; + + if (rangeKey) + { + pMid = &(pTable->end_code[rangeKey]); + chEnd = be::peek<uint16>(pMid); + } + else + { + // Binary search of the endCode[] array + pLeft = &(pTable->end_code[0]); + n = nSeg; + while (n > 0) + { + cMid = n >> 1; // Pick an element in the middle + pMid = pLeft + cMid; + chEnd = be::peek<uint16>(pMid); + if (nUnicodeId <= chEnd) + { + if (cMid == 0 || nUnicodeId > be::peek<uint16>(pMid -1)) + break; // Must be this seg or none! + n = cMid; // Continue on left side, omitting mid point + } + else + { + pLeft = pMid + 1; // Continue on right side, omitting mid point + n -= (cMid + 1); + } + } + + if (!n) + return 0; + } + + // Ok, we're down to one segment and pMid points to the endCode element + // Either this is it or none is. + + chStart = be::peek<uint16>(pMid += nSeg + 1); + if (chEnd >= nUnicodeId && nUnicodeId >= chStart) + { + // Found correct segment. Find Glyph Id + int16 idDelta = be::peek<uint16>(pMid += nSeg); + uint16 idRangeOffset = be::peek<uint16>(pMid += nSeg); + + if (idRangeOffset == 0) + return (uint16)(idDelta + nUnicodeId); // must use modulus 2^16 + + // Look up value in glyphIdArray + const ptrdiff_t offset = (nUnicodeId - chStart) + (idRangeOffset >> 1) + + (pMid - reinterpret_cast<const uint16 *>(pTable)); + if (offset * 2 + 1 >= be::swap<uint16>(pTable->length)) + return 0; + gid16 nGlyphId = be::peek<uint16>(reinterpret_cast<const uint16 *>(pTable)+offset); + // If this value is 0, return 0. Else add the idDelta + return nGlyphId ? nGlyphId + idDelta : 0; + } + + return 0; +} + +/*---------------------------------------------------------------------------------------------- + Return the next Unicode value in the cmap. Pass 0 to obtain the first item. + Returns 0xFFFF as the last item. + pRangeKey is an optional key that is used to optimize the search; its value is the range + in which the character is found. +----------------------------------------------------------------------------------------------*/ +unsigned int CmapSubtable4NextCodepoint(const void *pCmap31, unsigned int nUnicodeId, int * pRangeKey) +{ + const Sfnt::CmapSubTableFormat4 * pTable = reinterpret_cast<const Sfnt::CmapSubTableFormat4 *>(pCmap31); + + uint16 nRange = be::swap(pTable->seg_count_x2) >> 1; + + uint32 nUnicodePrev = (uint32)nUnicodeId; + + const uint16 * pStartCode = &(pTable->end_code[0]) + + nRange // length of end code array + + 1; // reserved word + + if (nUnicodePrev == 0) + { + // return the first codepoint. + if (pRangeKey) + *pRangeKey = 0; + return be::peek<uint16>(pStartCode); + } + else if (nUnicodePrev >= 0xFFFF) + { + if (pRangeKey) + *pRangeKey = nRange - 1; + return 0xFFFF; + } + + int iRange = (pRangeKey) ? *pRangeKey : 0; + // Just in case we have a bad key: + while (iRange > 0 && be::peek<uint16>(pStartCode + iRange) > nUnicodePrev) + iRange--; + while (iRange < nRange - 1 && be::peek<uint16>(pTable->end_code + iRange) < nUnicodePrev) + iRange++; + + // Now iRange is the range containing nUnicodePrev. + unsigned int nStartCode = be::peek<uint16>(pStartCode + iRange); + unsigned int nEndCode = be::peek<uint16>(pTable->end_code + iRange); + + if (nStartCode > nUnicodePrev) + // Oops, nUnicodePrev is not in the cmap! Adjust so we get a reasonable + // answer this time around. + nUnicodePrev = nStartCode - 1; + + if (nEndCode > nUnicodePrev) + { + // Next is in the same range; it is the next successive codepoint. + if (pRangeKey) + *pRangeKey = iRange; + return nUnicodePrev + 1; + } + + // Otherwise the next codepoint is the first one in the next range. + // There is guaranteed to be a next range because there must be one that + // ends with 0xFFFF. + if (pRangeKey) + *pRangeKey = iRange + 1; + return (iRange + 1 >= nRange) ? 0xFFFF : be::peek<uint16>(pStartCode + iRange + 1); +} + +/*---------------------------------------------------------------------------------------------- + Check the Microsoft UCS-4 subtable for expected values. +----------------------------------------------------------------------------------------------*/ +bool CheckCmapSubtable12(const void *pCmapSubtable12, const void *pCmapEnd /*, unsigned int maxgid*/) +{ + size_t table_len = (const byte *)pCmapEnd - (const byte *)pCmapSubtable12; + if (!pCmapSubtable12) return false; + const Sfnt::CmapSubTable * pTable = reinterpret_cast<const Sfnt::CmapSubTable *>(pCmapSubtable12); + if (table_len < sizeof(*pTable) || be::swap(pTable->format) != 12) + return false; + const Sfnt::CmapSubTableFormat12 * pTable12 = reinterpret_cast<const Sfnt::CmapSubTableFormat12 *>(pCmapSubtable12); + if (table_len < sizeof(*pTable12)) + return false; + uint32 length = be::swap(pTable12->length); + if (length > table_len) + return false; + if (length < sizeof(Sfnt::CmapSubTableFormat12)) + return false; + uint32 num_groups = be::swap(pTable12->num_groups); + if (num_groups > 0x10000000 || length != (sizeof(Sfnt::CmapSubTableFormat12) + (num_groups - 1) * sizeof(uint32) * 3)) + return false; +#if 0 + for (unsigned int i = 0; i < num_groups; ++i) + { + if (be::swap(pTable12->group[i].end_char_code) - be::swap(pTable12->group[i].start_char_code) + be::swap(pTable12->group[i].start_glyph_id) > maxgid) + return false; + if (i > 0 && be::swap(pTable12->group[i].start_char_code) <= be::swap(pTable12->group[i-1].end_char_code)) + return false; + } +#endif + return true; +} + +/*---------------------------------------------------------------------------------------------- + Return the Glyph ID for the given Unicode ID in the Microsoft UCS-4 subtable. + (Actually this code only depends on subtable being format 12.) + Return 0 if the Unicode ID is not in the subtable. +----------------------------------------------------------------------------------------------*/ +gid16 CmapSubtable12Lookup(const void * pCmap310, unsigned int uUnicodeId, int rangeKey) +{ + const Sfnt::CmapSubTableFormat12 * pTable = reinterpret_cast<const Sfnt::CmapSubTableFormat12 *>(pCmap310); + + //uint32 uLength = be::swap(pTable->length); //could use to test for premature end of table + uint32 ucGroups = be::swap(pTable->num_groups); + + for (unsigned int i = rangeKey; i < ucGroups; i++) + { + uint32 uStartCode = be::swap(pTable->group[i].start_char_code); + uint32 uEndCode = be::swap(pTable->group[i].end_char_code); + if (uUnicodeId >= uStartCode && uUnicodeId <= uEndCode) + { + uint32 uDiff = uUnicodeId - uStartCode; + uint32 uStartGid = be::swap(pTable->group[i].start_glyph_id); + return static_cast<gid16>(uStartGid + uDiff); + } + } + + return 0; +} + +/*---------------------------------------------------------------------------------------------- + Return the next Unicode value in the cmap. Pass 0 to obtain the first item. + Returns 0x10FFFF as the last item. + pRangeKey is an optional key that is used to optimize the search; its value is the range + in which the character is found. +----------------------------------------------------------------------------------------------*/ +unsigned int CmapSubtable12NextCodepoint(const void *pCmap310, unsigned int nUnicodeId, int * pRangeKey) +{ + const Sfnt::CmapSubTableFormat12 * pTable = reinterpret_cast<const Sfnt::CmapSubTableFormat12 *>(pCmap310); + + int nRange = be::swap(pTable->num_groups); + + uint32 nUnicodePrev = (uint32)nUnicodeId; + + if (nUnicodePrev == 0) + { + // return the first codepoint. + if (pRangeKey) + *pRangeKey = 0; + return be::swap(pTable->group[0].start_char_code); + } + else if (nUnicodePrev >= 0x10FFFF) + { + if (pRangeKey) + *pRangeKey = nRange; + return 0x10FFFF; + } + + int iRange = (pRangeKey) ? *pRangeKey : 0; + // Just in case we have a bad key: + while (iRange > 0 && be::swap(pTable->group[iRange].start_char_code) > nUnicodePrev) + iRange--; + while (iRange < nRange - 1 && be::swap(pTable->group[iRange].end_char_code) < nUnicodePrev) + iRange++; + + // Now iRange is the range containing nUnicodePrev. + + unsigned int nStartCode = be::swap(pTable->group[iRange].start_char_code); + unsigned int nEndCode = be::swap(pTable->group[iRange].end_char_code); + + if (nStartCode > nUnicodePrev) + // Oops, nUnicodePrev is not in the cmap! Adjust so we get a reasonable + // answer this time around. + nUnicodePrev = nStartCode - 1; + + if (nEndCode > nUnicodePrev) + { + // Next is in the same range; it is the next successive codepoint. + if (pRangeKey) + *pRangeKey = iRange; + return nUnicodePrev + 1; + } + + // Otherwise the next codepoint is the first one in the next range, or 10FFFF if we're done. + if (pRangeKey) + *pRangeKey = iRange + 1; + return (iRange + 1 >= nRange) ? 0x10FFFF : be::swap(pTable->group[iRange + 1].start_char_code); +} + +/*---------------------------------------------------------------------------------------------- + Return the offset stored in the loca table for the given Glyph ID. + (This offset is into the glyf table.) + Return -1 if the lookup failed. + Technically this method should return an unsigned long but it is unlikely the offset will + exceed 2^31. +----------------------------------------------------------------------------------------------*/ +size_t LocaLookup(gid16 nGlyphId, + const void * pLoca, size_t lLocaSize, + const void * pHead) // throw (std::out_of_range) +{ + const Sfnt::FontHeader * pTable = reinterpret_cast<const Sfnt::FontHeader *>(pHead); + size_t res = -2; + + // CheckTable verifies the index_to_loc_format is valid + if (be::swap(pTable->index_to_loc_format) == Sfnt::FontHeader::ShortIndexLocFormat) + { // loca entries are two bytes and have been divided by two + if (lLocaSize > 1 && nGlyphId + 1u < lLocaSize >> 1) // allow sentinel value to be accessed + { + const uint16 * pShortTable = reinterpret_cast<const uint16 *>(pLoca); + res = be::peek<uint16>(pShortTable + nGlyphId) << 1; + if (res == static_cast<size_t>(be::peek<uint16>(pShortTable + nGlyphId + 1) << 1)) + return -1; + } + } + else if (be::swap(pTable->index_to_loc_format) == Sfnt::FontHeader::LongIndexLocFormat) + { // loca entries are four bytes + if (lLocaSize > 3 && nGlyphId + 1u < lLocaSize >> 2) + { + const uint32 * pLongTable = reinterpret_cast<const uint32 *>(pLoca); + res = be::peek<uint32>(pLongTable + nGlyphId); + if (res == static_cast<size_t>(be::peek<uint32>(pLongTable + nGlyphId + 1))) + return -1; + } + } + + // only get here if glyph id was bad + return res; + //throw std::out_of_range("glyph id out of range for font"); +} + +/*---------------------------------------------------------------------------------------------- + Return a pointer into the glyf table based on the given offset (from LocaLookup). + Return NULL on error. +----------------------------------------------------------------------------------------------*/ +void * GlyfLookup(const void * pGlyf, size_t nGlyfOffset, size_t nTableLen) +{ + const uint8 * pByte = reinterpret_cast<const uint8 *>(pGlyf); + if (OVERFLOW_OFFSET_CHECK(pByte, nGlyfOffset) || nGlyfOffset >= nTableLen - sizeof(Sfnt::Glyph)) + return NULL; + return const_cast<uint8 *>(pByte + nGlyfOffset); +} + +/*---------------------------------------------------------------------------------------------- + Get the bounding box coordinates for a simple glyf entry (non-composite). + Return true if successful, false otherwise. +----------------------------------------------------------------------------------------------*/ +bool GlyfBox(const void * pSimpleGlyf, int & xMin, int & yMin, + int & xMax, int & yMax) +{ + const Sfnt::Glyph * pGlyph = reinterpret_cast<const Sfnt::Glyph *>(pSimpleGlyf); + + xMin = be::swap(pGlyph->x_min); + yMin = be::swap(pGlyph->y_min); + xMax = be::swap(pGlyph->x_max); + yMax = be::swap(pGlyph->y_max); + + return true; +} + +#ifdef ALL_TTFUTILS +/*---------------------------------------------------------------------------------------------- + Return the number of contours for a simple glyf entry (non-composite) + Returning -1 means this is a composite glyph +----------------------------------------------------------------------------------------------*/ +int GlyfContourCount(const void * pSimpleGlyf) +{ + const Sfnt::Glyph * pGlyph = reinterpret_cast<const Sfnt::Glyph *>(pSimpleGlyf); + return be::swap(pGlyph->number_of_contours); // -1 means composite glyph +} + +/*---------------------------------------------------------------------------------------------- + Get the point numbers for the end points of the glyph contours for a simple + glyf entry (non-composite). + cnPointsTotal - count of contours from GlyfContourCount(); (same as number of end points) + prgnContourEndPoints - should point to a buffer large enough to hold cnPoints integers + cnPoints - count of points placed in above range + Return true if successful, false otherwise. + False could indicate a multi-level composite glyphs. +----------------------------------------------------------------------------------------------*/ +bool GlyfContourEndPoints(const void * pSimpleGlyf, int * prgnContourEndPoint, + int cnPointsTotal, int & cnPoints) +{ + const Sfnt::SimpleGlyph * pGlyph = reinterpret_cast<const Sfnt::SimpleGlyph *>(pSimpleGlyf); + + int cContours = be::swap(pGlyph->number_of_contours); + if (cContours < 0) + return false; // this method isn't supposed handle composite glyphs + + for (int i = 0; i < cContours && i < cnPointsTotal; i++) + { + prgnContourEndPoint[i] = be::swap(pGlyph->end_pts_of_contours[i]); + } + + cnPoints = cContours; + return true; +} + +/*---------------------------------------------------------------------------------------------- + Get the points for a simple glyf entry (non-composite) + cnPointsTotal - count of points from largest end point obtained from GlyfContourEndPoints + prgnX & prgnY - should point to buffers large enough to hold cnPointsTotal integers + The ranges are parallel so that coordinates for point(n) are found at offset n in both + ranges. This is raw point data with relative coordinates. + prgbFlag - should point to a buffer a large enough to hold cnPointsTotal bytes + This range is parallel to the prgnX & prgnY + cnPoints - count of points placed in above ranges + Return true if successful, false otherwise. + False could indicate a composite glyph +----------------------------------------------------------------------------------------------*/ +bool GlyfPoints(const void * pSimpleGlyf, int * prgnX, int * prgnY, + char * prgbFlag, int cnPointsTotal, int & cnPoints) +{ + using namespace Sfnt; + + const Sfnt::SimpleGlyph * pGlyph = reinterpret_cast<const Sfnt::SimpleGlyph *>(pSimpleGlyf); + int cContours = be::swap(pGlyph->number_of_contours); + // return false for composite glyph + if (cContours <= 0) + return false; + int cPts = be::swap(pGlyph->end_pts_of_contours[cContours - 1]) + 1; + if (cPts > cnPointsTotal) + return false; + + // skip over bounding box data & point to byte count of instructions (hints) + const uint8 * pbGlyph = reinterpret_cast<const uint8 *> + (&pGlyph->end_pts_of_contours[cContours]); + + // skip over hints & point to first flag + int cbHints = be::swap(*(uint16 *)pbGlyph); + pbGlyph += sizeof(uint16); + pbGlyph += cbHints; + + // load flags & point to first x coordinate + int iFlag = 0; + while (iFlag < cPts) + { + if (!(*pbGlyph & SimpleGlyph::Repeat)) + { // flag isn't repeated + prgbFlag[iFlag] = (char)*pbGlyph; + pbGlyph++; + iFlag++; + } + else + { // flag is repeated; count specified by next byte + char chFlag = (char)*pbGlyph; + pbGlyph++; + int cFlags = (int)*pbGlyph; + pbGlyph++; + prgbFlag[iFlag] = chFlag; + iFlag++; + for (int i = 0; i < cFlags; i++) + { + prgbFlag[iFlag + i] = chFlag; + } + iFlag += cFlags; + } + } + if (iFlag != cPts) + return false; + + // load x coordinates + iFlag = 0; + while (iFlag < cPts) + { + if (prgbFlag[iFlag] & SimpleGlyph::XShort) + { + prgnX[iFlag] = *pbGlyph; + if (!(prgbFlag[iFlag] & SimpleGlyph::XIsPos)) + { + prgnX[iFlag] = -prgnX[iFlag]; + } + pbGlyph++; + } + else + { + if (prgbFlag[iFlag] & SimpleGlyph::XIsSame) + { + prgnX[iFlag] = 0; + // do NOT increment pbGlyph + } + else + { + prgnX[iFlag] = be::swap(*(int16 *)pbGlyph); + pbGlyph += sizeof(int16); + } + } + iFlag++; + } + + // load y coordinates + iFlag = 0; + while (iFlag < cPts) + { + if (prgbFlag[iFlag] & SimpleGlyph::YShort) + { + prgnY[iFlag] = *pbGlyph; + if (!(prgbFlag[iFlag] & SimpleGlyph::YIsPos)) + { + prgnY[iFlag] = -prgnY[iFlag]; + } + pbGlyph++; + } + else + { + if (prgbFlag[iFlag] & SimpleGlyph::YIsSame) + { + prgnY[iFlag] = 0; + // do NOT increment pbGlyph + } + else + { + prgnY[iFlag] = be::swap(*(int16 *)pbGlyph); + pbGlyph += sizeof(int16); + } + } + iFlag++; + } + + cnPoints = cPts; + return true; +} + +/*---------------------------------------------------------------------------------------------- + Fill prgnCompId with the component Glyph IDs from pSimpleGlyf. + Client must allocate space before calling. + pSimpleGlyf - assumed to point to a composite glyph + cCompIdTotal - the number of elements in prgnCompId + cCompId - the total number of Glyph IDs stored in prgnCompId + Return true if successful, false otherwise + False could indicate a non-composite glyph or the input array was not big enough +----------------------------------------------------------------------------------------------*/ +bool GetComponentGlyphIds(const void * pSimpleGlyf, int * prgnCompId, + size_t cnCompIdTotal, size_t & cnCompId) +{ + using namespace Sfnt; + + if (GlyfContourCount(pSimpleGlyf) >= 0) + return false; + + const Sfnt::SimpleGlyph * pGlyph = reinterpret_cast<const Sfnt::SimpleGlyph *>(pSimpleGlyf); + // for a composite glyph, the special data begins here + const uint8 * pbGlyph = reinterpret_cast<const uint8 *>(&pGlyph->end_pts_of_contours[0]); + + uint16 GlyphFlags; + size_t iCurrentComp = 0; + do + { + GlyphFlags = be::swap(*((uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + prgnCompId[iCurrentComp++] = be::swap(*((uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + if (iCurrentComp >= cnCompIdTotal) + return false; + int nOffset = 0; + nOffset += GlyphFlags & CompoundGlyph::Arg1Arg2Words ? 4 : 2; + nOffset += GlyphFlags & CompoundGlyph::HaveScale ? 2 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveXAndYScale ? 4 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveTwoByTwo ? 8 : 0; + pbGlyph += nOffset; + } while (GlyphFlags & CompoundGlyph::MoreComponents); + + cnCompId = iCurrentComp; + + return true; +} + +/*---------------------------------------------------------------------------------------------- + Return info on how a component glyph is to be placed + pSimpleGlyph - assumed to point to a composite glyph + nCompId - glyph id for component of interest + bOffset - if true, a & b are the x & y offsets for this component + if false, b is the point on this component that is attaching to point a on the + preceding glyph + Return true if successful, false otherwise + False could indicate a non-composite glyph or that component wasn't found +----------------------------------------------------------------------------------------------*/ +bool GetComponentPlacement(const void * pSimpleGlyf, int nCompId, + bool fOffset, int & a, int & b) +{ + using namespace Sfnt; + + if (GlyfContourCount(pSimpleGlyf) >= 0) + return false; + + const Sfnt::SimpleGlyph * pGlyph = reinterpret_cast<const Sfnt::SimpleGlyph *>(pSimpleGlyf); + // for a composite glyph, the special data begins here + const uint8 * pbGlyph = reinterpret_cast<const uint8 *>(&pGlyph->end_pts_of_contours[0]); + + uint16 GlyphFlags; + do + { + GlyphFlags = be::swap(*((uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + if (be::swap(*((uint16 *)pbGlyph)) == nCompId) + { + pbGlyph += sizeof(uint16); // skip over glyph id of component + fOffset = (GlyphFlags & CompoundGlyph::ArgsAreXYValues) == CompoundGlyph::ArgsAreXYValues; + + if (GlyphFlags & CompoundGlyph::Arg1Arg2Words ) + { + a = be::swap(*(int16 *)pbGlyph); + pbGlyph += sizeof(int16); + b = be::swap(*(int16 *)pbGlyph); + pbGlyph += sizeof(int16); + } + else + { // args are signed bytes + a = *pbGlyph++; + b = *pbGlyph++; + } + return true; + } + pbGlyph += sizeof(uint16); // skip over glyph id of component + int nOffset = 0; + nOffset += GlyphFlags & CompoundGlyph::Arg1Arg2Words ? 4 : 2; + nOffset += GlyphFlags & CompoundGlyph::HaveScale ? 2 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveXAndYScale ? 4 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveTwoByTwo ? 8 : 0; + pbGlyph += nOffset; + } while (GlyphFlags & CompoundGlyph::MoreComponents); + + // didn't find requested component + fOffset = true; + a = 0; + b = 0; + return false; +} + +/*---------------------------------------------------------------------------------------------- + Return info on how a component glyph is to be transformed + pSimpleGlyph - assumed to point to a composite glyph + nCompId - glyph id for component of interest + flt11, flt11, flt11, flt11 - a 2x2 matrix giving the transform + bTransOffset - whether to transform the offset from above method + The spec is unclear about the meaning of this flag + Currently - initialize to true for MS rasterizer and false for Mac rasterizer, then + on return it will indicate whether transform should apply to offset (MSDN CD 10/99) + Return true if successful, false otherwise + False could indicate a non-composite glyph or that component wasn't found +----------------------------------------------------------------------------------------------*/ +bool GetComponentTransform(const void * pSimpleGlyf, int nCompId, + float & flt11, float & flt12, float & flt21, float & flt22, + bool & fTransOffset) +{ + using namespace Sfnt; + + if (GlyfContourCount(pSimpleGlyf) >= 0) + return false; + + const Sfnt::SimpleGlyph * pGlyph = reinterpret_cast<const Sfnt::SimpleGlyph *>(pSimpleGlyf); + // for a composite glyph, the special data begins here + const uint8 * pbGlyph = reinterpret_cast<const uint8 *>(&pGlyph->end_pts_of_contours[0]); + + uint16 GlyphFlags; + do + { + GlyphFlags = be::swap(*((uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + if (be::swap(*((uint16 *)pbGlyph)) == nCompId) + { + pbGlyph += sizeof(uint16); // skip over glyph id of component + pbGlyph += GlyphFlags & CompoundGlyph::Arg1Arg2Words ? 4 : 2; // skip over placement data + + if (fTransOffset) // MS rasterizer + fTransOffset = !(GlyphFlags & CompoundGlyph::UnscaledOffset); + else // Apple rasterizer + fTransOffset = (GlyphFlags & CompoundGlyph::ScaledOffset) != 0; + + if (GlyphFlags & CompoundGlyph::HaveScale) + { + flt11 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + flt12 = 0; + flt21 = 0; + flt22 = flt11; + } + else if (GlyphFlags & CompoundGlyph::HaveXAndYScale) + { + flt11 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + flt12 = 0; + flt21 = 0; + flt22 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + } + else if (GlyphFlags & CompoundGlyph::HaveTwoByTwo) + { + flt11 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + flt12 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + flt21 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + flt22 = fixed_to_float<14>(be::swap(*(uint16 *)pbGlyph)); + pbGlyph += sizeof(uint16); + } + else + { // identity transform + flt11 = 1.0; + flt12 = 0.0; + flt21 = 0.0; + flt22 = 1.0; + } + return true; + } + pbGlyph += sizeof(uint16); // skip over glyph id of component + int nOffset = 0; + nOffset += GlyphFlags & CompoundGlyph::Arg1Arg2Words ? 4 : 2; + nOffset += GlyphFlags & CompoundGlyph::HaveScale ? 2 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveXAndYScale ? 4 : 0; + nOffset += GlyphFlags & CompoundGlyph::HaveTwoByTwo ? 8 : 0; + pbGlyph += nOffset; + } while (GlyphFlags & CompoundGlyph::MoreComponents); + + // didn't find requested component + fTransOffset = false; + flt11 = 1; + flt12 = 0; + flt21 = 0; + flt22 = 1; + return false; +} +#endif + +/*---------------------------------------------------------------------------------------------- + Return a pointer into the glyf table based on the given tables and Glyph ID + Since this method doesn't check for spaces, it is good to call IsSpace before using it. + Return NULL on error. +----------------------------------------------------------------------------------------------*/ +void * GlyfLookup(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead) +{ + // test for valid glyph id + // CheckTable verifies the index_to_loc_format is valid + + const Sfnt::FontHeader * pTable + = reinterpret_cast<const Sfnt::FontHeader *>(pHead); + + if (be::swap(pTable->index_to_loc_format) == Sfnt::FontHeader::ShortIndexLocFormat) + { // loca entries are two bytes (and have been divided by two) + if (nGlyphId >= (lLocaSize >> 1) - 1) // don't allow nGlyphId to access sentinel + { +// throw std::out_of_range("glyph id out of range for font"); + return NULL; + } + } + if (be::swap(pTable->index_to_loc_format) == Sfnt::FontHeader::LongIndexLocFormat) + { // loca entries are four bytes + if (nGlyphId >= (lLocaSize >> 2) - 1) + { +// throw std::out_of_range("glyph id out of range for font"); + return NULL; + } + } + + size_t lGlyfOffset = LocaLookup(nGlyphId, pLoca, lLocaSize, pHead); + void * pSimpleGlyf = GlyfLookup(pGlyf, lGlyfOffset, lGlyfSize); // invalid loca offset returns null + return pSimpleGlyf; +} + +#ifdef ALL_TTFUTILS +/*---------------------------------------------------------------------------------------------- + Determine if a particular Glyph ID has any data in the glyf table. If it is white space, + there will be no glyf data, though there will be metric data in hmtx, etc. +----------------------------------------------------------------------------------------------*/ +bool IsSpace(gid16 nGlyphId, const void * pLoca, size_t lLocaSize, const void * pHead) +{ + size_t lGlyfOffset = LocaLookup(nGlyphId, pLoca, lLocaSize, pHead); + + // the +1 should always work because there is a sentinel value at the end of the loca table + size_t lNextGlyfOffset = LocaLookup(nGlyphId + 1, pLoca, lLocaSize, pHead); + + return (lNextGlyfOffset - lGlyfOffset) == 0; +} + +/*---------------------------------------------------------------------------------------------- + Determine if a particular Glyph ID is a multi-level composite. +----------------------------------------------------------------------------------------------*/ +bool IsDeepComposite(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, long lLocaSize, const void * pHead) +{ + if (IsSpace(nGlyphId, pLoca, lLocaSize, pHead)) {return false;} + + void * pSimpleGlyf = GlyfLookup(nGlyphId, pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) + return false; // no way to really indicate an error occured here + + if (GlyfContourCount(pSimpleGlyf) >= 0) + return false; + + int rgnCompId[kMaxGlyphComponents]; // assumes only a limited number of glyph components + size_t cCompIdTotal = kMaxGlyphComponents; + size_t cCompId = 0; + + if (!GetComponentGlyphIds(pSimpleGlyf, rgnCompId, cCompIdTotal, cCompId)) + return false; + + for (size_t i = 0; i < cCompId; i++) + { + pSimpleGlyf = GlyfLookup(static_cast<gid16>(rgnCompId[i]), + pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) {return false;} + + if (GlyfContourCount(pSimpleGlyf) < 0) + return true; + } + + return false; +} + +/*---------------------------------------------------------------------------------------------- + Get the bounding box coordinates based on the given tables and Glyph ID + Handles both simple and composite glyphs. + Return true if successful, false otherwise. On false, all point values will be INT_MIN + False may indicate a white space glyph +----------------------------------------------------------------------------------------------*/ +bool GlyfBox(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead, int & xMin, int & yMin, int & xMax, int & yMax) +{ + xMin = yMin = xMax = yMax = INT_MIN; + + if (IsSpace(nGlyphId, pLoca, lLocaSize, pHead)) {return false;} + + void * pSimpleGlyf = GlyfLookup(nGlyphId, pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) {return false;} + + return GlyfBox(pSimpleGlyf, xMin, yMin, xMax, yMax); +} + +/*---------------------------------------------------------------------------------------------- + Get the number of contours based on the given tables and Glyph ID + Handles both simple and composite glyphs. + Return true if successful, false otherwise. On false, cnContours will be INT_MIN + False may indicate a white space glyph or a multi-level composite glyph. +----------------------------------------------------------------------------------------------*/ +bool GlyfContourCount(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead, size_t & cnContours) +{ + cnContours = static_cast<size_t>(INT_MIN); + + if (IsSpace(nGlyphId, pLoca, lLocaSize, pHead)) {return false;} + + void * pSimpleGlyf = GlyfLookup(nGlyphId, pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) {return false;} + + int cRtnContours = GlyfContourCount(pSimpleGlyf); + if (cRtnContours >= 0) + { + cnContours = size_t(cRtnContours); + return true; + } + + //handle composite glyphs + + int rgnCompId[kMaxGlyphComponents]; // assumes no glyph will be made of more than 8 components + size_t cCompIdTotal = kMaxGlyphComponents; + size_t cCompId = 0; + + if (!GetComponentGlyphIds(pSimpleGlyf, rgnCompId, cCompIdTotal, cCompId)) + return false; + + cRtnContours = 0; + int cTmp = 0; + for (size_t i = 0; i < cCompId; i++) + { + if (IsSpace(static_cast<gid16>(rgnCompId[i]), pLoca, lLocaSize, pHead)) {return false;} + pSimpleGlyf = GlyfLookup(static_cast<gid16>(rgnCompId[i]), + pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == 0) {return false;} + // return false on multi-level composite + if ((cTmp = GlyfContourCount(pSimpleGlyf)) < 0) + return false; + cRtnContours += cTmp; + } + + cnContours = size_t(cRtnContours); + return true; +} + +/*---------------------------------------------------------------------------------------------- + Get the point numbers for the end points of the glyph contours based on the given tables + and Glyph ID + Handles both simple and composite glyphs. + cnPoints - count of contours from GlyfContourCount (same as number of end points) + prgnContourEndPoints - should point to a buffer large enough to hold cnPoints integers + Return true if successful, false otherwise. On false, all end points are INT_MIN + False may indicate a white space glyph or a multi-level composite glyph. +----------------------------------------------------------------------------------------------*/ +bool GlyfContourEndPoints(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead, + int * prgnContourEndPoint, size_t cnPoints) +{ + memset(prgnContourEndPoint, 0xFF, cnPoints * sizeof(int)); + // std::fill_n(prgnContourEndPoint, cnPoints, INT_MIN); + + if (IsSpace(nGlyphId, pLoca, lLocaSize, pHead)) {return false;} + + void * pSimpleGlyf = GlyfLookup(nGlyphId, pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) {return false;} + + int cContours = GlyfContourCount(pSimpleGlyf); + int cActualPts = 0; + if (cContours > 0) + return GlyfContourEndPoints(pSimpleGlyf, prgnContourEndPoint, cnPoints, cActualPts); + + // handle composite glyphs + + int rgnCompId[kMaxGlyphComponents]; // assumes no glyph will be made of more than 8 components + size_t cCompIdTotal = kMaxGlyphComponents; + size_t cCompId = 0; + + if (!GetComponentGlyphIds(pSimpleGlyf, rgnCompId, cCompIdTotal, cCompId)) + return false; + + int * prgnCurrentEndPoint = prgnContourEndPoint; + int cCurrentPoints = cnPoints; + int nPrevPt = 0; + for (size_t i = 0; i < cCompId; i++) + { + if (IsSpace(static_cast<gid16>(rgnCompId[i]), pLoca, lLocaSize, pHead)) {return false;} + pSimpleGlyf = GlyfLookup(static_cast<gid16>(rgnCompId[i]), pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) {return false;} + // returns false on multi-level composite + if (!GlyfContourEndPoints(pSimpleGlyf, prgnCurrentEndPoint, cCurrentPoints, cActualPts)) + return false; + // points in composite are numbered sequentially as components are added + // must adjust end point numbers for new point numbers + for (int j = 0; j < cActualPts; j++) + prgnCurrentEndPoint[j] += nPrevPt; + nPrevPt = prgnCurrentEndPoint[cActualPts - 1] + 1; + + prgnCurrentEndPoint += cActualPts; + cCurrentPoints -= cActualPts; + } + + return true; +} + +/*---------------------------------------------------------------------------------------------- + Get the points for a glyph based on the given tables and Glyph ID + Handles both simple and composite glyphs. + cnPoints - count of points from largest end point obtained from GlyfContourEndPoints + prgnX & prgnY - should point to buffers large enough to hold cnPoints integers + The ranges are parallel so that coordinates for point(n) are found at offset n in + both ranges. These points are in absolute coordinates. + prgfOnCurve - should point to a buffer a large enough to hold cnPoints bytes (bool) + This range is parallel to the prgnX & prgnY + Return true if successful, false otherwise. On false, all points may be INT_MIN + False may indicate a white space glyph, a multi-level composite, or a corrupt font + It's not clear from the TTF spec when the transforms should be applied. Should the + transform be done before or after attachment point calcs? (current code - before) + Should the transform be applied to other offsets? (currently - no; however commented + out code is in place so that if CompoundGlyph::UnscaledOffset on the MS rasterizer is + clear (typical) then yes, and if CompoundGlyph::ScaledOffset on the Apple rasterizer is + clear (typical?) then no). See GetComponentTransform. + It's also unclear where point numbering with attachment poinst starts + (currently - first point number is relative to whole glyph, second point number is + relative to current glyph). +----------------------------------------------------------------------------------------------*/ +bool GlyfPoints(gid16 nGlyphId, const void * pGlyf, + const void * pLoca, size_t lGlyfSize, size_t lLocaSize, const void * pHead, + const int * /*prgnContourEndPoint*/, size_t /*cnEndPoints*/, + int * prgnX, int * prgnY, bool * prgfOnCurve, size_t cnPoints) +{ + memset(prgnX, 0x7F, cnPoints * sizeof(int)); + memset(prgnY, 0x7F, cnPoints * sizeof(int)); + + if (IsSpace(nGlyphId, pLoca, lLocaSize, pHead)) + return false; + + void * pSimpleGlyf = GlyfLookup(nGlyphId, pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pSimpleGlyf == NULL) + return false; + + int cContours = GlyfContourCount(pSimpleGlyf); + int cActualPts; + if (cContours > 0) + { + if (!GlyfPoints(pSimpleGlyf, prgnX, prgnY, (char *)prgfOnCurve, cnPoints, cActualPts)) + return false; + CalcAbsolutePoints(prgnX, prgnY, cnPoints); + SimplifyFlags((char *)prgfOnCurve, cnPoints); + return true; + } + + // handle composite glyphs + int rgnCompId[kMaxGlyphComponents]; // assumes no glyph will be made of more than 8 components + size_t cCompIdTotal = kMaxGlyphComponents; + size_t cCompId = 0; + + // this will fail if there are more components than there is room for + if (!GetComponentGlyphIds(pSimpleGlyf, rgnCompId, cCompIdTotal, cCompId)) + return false; + + int * prgnCurrentX = prgnX; + int * prgnCurrentY = prgnY; + char * prgbCurrentFlag = (char *)prgfOnCurve; // converting bool to char should be safe + int cCurrentPoints = cnPoints; + bool fOffset = true, fTransOff = true; + int a, b; + float flt11, flt12, flt21, flt22; + // int * prgnPrevX = prgnX; // in case first att pt number relative to preceding glyph + // int * prgnPrevY = prgnY; + for (size_t i = 0; i < cCompId; i++) + { + if (IsSpace(static_cast<gid16>(rgnCompId[i]), pLoca, lLocaSize, pHead)) {return false;} + void * pCompGlyf = GlyfLookup(static_cast<gid16>(rgnCompId[i]), pGlyf, pLoca, lGlyfSize, lLocaSize, pHead); + if (pCompGlyf == NULL) {return false;} + // returns false on multi-level composite + if (!GlyfPoints(pCompGlyf, prgnCurrentX, prgnCurrentY, prgbCurrentFlag, + cCurrentPoints, cActualPts)) + return false; + if (!GetComponentPlacement(pSimpleGlyf, rgnCompId[i], fOffset, a, b)) + return false; + if (!GetComponentTransform(pSimpleGlyf, rgnCompId[i], + flt11, flt12, flt21, flt22, fTransOff)) + return false; + bool fIdTrans = flt11 == 1.0 && flt12 == 0.0 && flt21 == 0.0 && flt22 == 1.0; + + // convert points to absolute coordinates + // do before transform and attachment point placement are applied + CalcAbsolutePoints(prgnCurrentX, prgnCurrentY, cActualPts); + + // apply transform - see main method note above + // do before attachment point calcs + if (!fIdTrans) + for (int j = 0; j < cActualPts; j++) + { + int x = prgnCurrentX[j]; // store before transform applied + int y = prgnCurrentY[j]; + prgnCurrentX[j] = (int)(x * flt11 + y * flt12); + prgnCurrentY[j] = (int)(x * flt21 + y * flt22); + } + + // apply placement - see main method note above + int nXOff, nYOff; + if (fOffset) // explicit x & y offsets + { + /* ignore fTransOff for now + if (fTransOff && !fIdTrans) + { // transform x & y offsets + nXOff = (int)(a * flt11 + b * flt12); + nYOff = (int)(a * flt21 + b * flt22); + } + else */ + { // don't transform offset + nXOff = a; + nYOff = b; + } + } + else // attachment points + { // in case first point is relative to preceding glyph and second relative to current + // nXOff = prgnPrevX[a] - prgnCurrentX[b]; + // nYOff = prgnPrevY[a] - prgnCurrentY[b]; + // first point number relative to whole composite, second relative to current glyph + nXOff = prgnX[a] - prgnCurrentX[b]; + nYOff = prgnY[a] - prgnCurrentY[b]; + } + for (int j = 0; j < cActualPts; j++) + { + prgnCurrentX[j] += nXOff; + prgnCurrentY[j] += nYOff; + } + + // prgnPrevX = prgnCurrentX; + // prgnPrevY = prgnCurrentY; + prgnCurrentX += cActualPts; + prgnCurrentY += cActualPts; + prgbCurrentFlag += cActualPts; + cCurrentPoints -= cActualPts; + } + + SimplifyFlags((char *)prgfOnCurve, cnPoints); + + return true; +} + +/*---------------------------------------------------------------------------------------------- + Simplify the meaning of flags to just indicate whether point is on-curve or off-curve. +---------------------------------------------------------------------------------------------*/ +bool SimplifyFlags(char * prgbFlags, int cnPoints) +{ + for (int i = 0; i < cnPoints; i++) + prgbFlags[i] = static_cast<char>(prgbFlags[i] & Sfnt::SimpleGlyph::OnCurve); + return true; +} + +/*---------------------------------------------------------------------------------------------- + Convert relative point coordinates to absolute coordinates + Points are stored in the font such that they are offsets from one another except for the + first point of a glyph. +---------------------------------------------------------------------------------------------*/ +bool CalcAbsolutePoints(int * prgnX, int * prgnY, int cnPoints) +{ + int nX = prgnX[0]; + int nY = prgnY[0]; + for (int i = 1; i < cnPoints; i++) + { + prgnX[i] += nX; + nX = prgnX[i]; + prgnY[i] += nY; + nY = prgnY[i]; + } + + return true; +} +#endif + +/*---------------------------------------------------------------------------------------------- + Return the length of the 'name' table in bytes. + Currently used. +---------------------------------------------------------------------------------------------*/ +#if 0 +size_t NameTableLength(const byte * pTable) +{ + byte * pb = (const_cast<byte *>(pTable)) + 2; // skip format + size_t cRecords = *pb++ << 8; cRecords += *pb++; + int dbStringOffset0 = (*pb++) << 8; dbStringOffset0 += *pb++; + int dbMaxStringOffset = 0; + for (size_t irec = 0; irec < cRecords; irec++) + { + int nPlatform = (*pb++) << 8; nPlatform += *pb++; + int nEncoding = (*pb++) << 8; nEncoding += *pb++; + int nLanguage = (*pb++) << 8; nLanguage += *pb++; + int nName = (*pb++) << 8; nName += *pb++; + int cbStringLen = (*pb++) << 8; cbStringLen += *pb++; + int dbStringOffset = (*pb++) << 8; dbStringOffset += *pb++; + if (dbMaxStringOffset < dbStringOffset + cbStringLen) + dbMaxStringOffset = dbStringOffset + cbStringLen; + } + return dbStringOffset0 + dbMaxStringOffset; +} +#endif + +} // end of namespace TtfUtil +} // end of namespace graphite diff --git a/gfx/graphite2/src/UtfCodec.cpp b/gfx/graphite2/src/UtfCodec.cpp new file mode 100644 index 0000000000..a944bbf9d0 --- /dev/null +++ b/gfx/graphite2/src/UtfCodec.cpp @@ -0,0 +1,45 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "inc/UtfCodec.h" +//using namespace graphite2; + +namespace graphite2 { + +} + +using namespace graphite2; + +const int8 _utf_codec<8>::sz_lut[16] = +{ + 1,1,1,1,1,1,1,1, // 1 byte + 0,0,0,0, // trailing byte + 2,2, // 2 bytes + 3, // 3 bytes + 4 // 4 bytes +}; + +const byte _utf_codec<8>::mask_lut[5] = {0x7f, 0xff, 0x3f, 0x1f, 0x0f}; diff --git a/gfx/graphite2/src/call_machine.cpp b/gfx/graphite2/src/call_machine.cpp new file mode 100644 index 0000000000..fcd8a0c2c1 --- /dev/null +++ b/gfx/graphite2/src/call_machine.cpp @@ -0,0 +1,138 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This call threaded interpreter implmentation for machine.h +// Author: Tim Eves + +// Build either this interpreter or the direct_machine implementation. +// The call threaded interpreter is portable across compilers and +// architectures as well as being useful to debug (you can set breakpoints on +// opcodes) but is slower that the direct threaded interpreter by a factor of 2 + +#include <cassert> +#include <cstring> +#include <graphite2/Segment.h> +#include "inc/Machine.h" +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/Rule.h" + +// Disable the unused parameter warning as th compiler is mistaken since dp +// is always updated (even if by 0) on every opcode. +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +#define registers const byte * & dp, vm::Machine::stack_t * & sp, \ + vm::Machine::stack_t * const sb, regbank & reg + +// These are required by opcodes.h and should not be changed +#define STARTOP(name) bool name(registers) REGPARM(4);\ + bool name(registers) { +#define ENDOP return (sp - sb)/Machine::STACK_MAX==0; \ + } + +#define EXIT(status) { push(status); return false; } + +// This is required by opcode_table.h +#define do_(name) instr(name) + + +using namespace graphite2; +using namespace vm; + +struct regbank { + slotref is; + slotref * map; + SlotMap & smap; + slotref * const map_base; + const instr * & ip; + uint8 direction; + int8 flags; + Machine::status_t & status; +}; + +typedef bool (* ip_t)(registers); + +// Pull in the opcode definitions +// We pull these into a private namespace so these otherwise common names dont +// pollute the toplevel namespace. +namespace { +#define smap reg.smap +#define seg smap.segment +#define is reg.is +#define ip reg.ip +#define map reg.map +#define mapb reg.map_base +#define flags reg.flags +#define dir reg.direction +#define status reg.status + +#include "inc/opcodes.h" + +#undef smap +#undef seg +#undef is +#undef ip +#undef map +#undef mapb +#undef flags +#undef dir +} + +Machine::stack_t Machine::run(const instr * program, + const byte * data, + slotref * & map) + +{ + assert(program != 0); + + // Declare virtual machine registers + const instr * ip = program-1; + const byte * dp = data; + stack_t * sp = _stack + Machine::STACK_GUARD, + * const sb = sp; + regbank reg = {*map, map, _map, _map.begin()+_map.context(), ip, _map.dir(), 0, _status}; + + // Run the program + while ((reinterpret_cast<ip_t>(*++ip))(dp, sp, sb, reg)) {} + const stack_t ret = sp == _stack+STACK_GUARD+1 ? *sp-- : 0; + + check_final_stack(sp); + map = reg.map; + *map = reg.is; + return ret; +} + +// Pull in the opcode table +namespace { +#include "inc/opcode_table.h" +} + +const opcode_t * Machine::getOpcodeTable() throw() +{ + return opcode_table; +} diff --git a/gfx/graphite2/src/direct_machine.cpp b/gfx/graphite2/src/direct_machine.cpp new file mode 100644 index 0000000000..86206cfe37 --- /dev/null +++ b/gfx/graphite2/src/direct_machine.cpp @@ -0,0 +1,140 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This direct threaded interpreter implmentation for machine.h +// Author: Tim Eves + +// Build either this interpreter or the call_machine implementation. +// The direct threaded interpreter is relies upon a gcc feature called +// labels-as-values so is only portable to compilers that support the +// extension (gcc only as far as I know) however it should build on any +// architecture gcc supports. +// This is twice as fast as the call threaded model and is likely faster on +// inorder processors with short pipelines and little branch prediction such +// as the ARM and possibly Atom chips. + + +#include <cassert> +#include <cstring> +#include "inc/Machine.h" +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/Rule.h" + +#define STARTOP(name) name: { +#define ENDOP }; goto *((sp - sb)/Machine::STACK_MAX ? &&end : *++ip); +#define EXIT(status) { push(status); goto end; } + +#define do_(name) &&name + + +using namespace graphite2; +using namespace vm; + +namespace { + +// The GCC manual has this to say about labels as values: +// The &&foo expressions for the same label might have different values +// if the containing function is inlined or cloned. If a program relies +// on them being always the same, __attribute__((__noinline__,__noclone__)) +// should be used to prevent inlining and cloning. +// +// is_return in Code.cpp relies on being able to do comparisons, so it needs +// them to be always the same. +// +// The GCC manual further adds: +// If &&foo is used in a static variable initializer, inlining and +// cloning is forbidden. +// +// In this file, &&foo *is* used in a static variable initializer, and it's not +// entirely clear whether this should prevent inlining of the function or not. +// In practice, though, clang 7 can end up inlining the function with ThinLTO, +// which breaks at least is_return. https://bugs.llvm.org/show_bug.cgi?id=39241 +// So all in all, we need at least the __noinline__ attribute. __noclone__ +// is not supported by clang. +__attribute__((__noinline__)) +const void * direct_run(const bool get_table_mode, + const instr * program, + const byte * data, + Machine::stack_t * stack, + slotref * & __map, + uint8 _dir, + Machine::status_t & status, + SlotMap * __smap=0) +{ + // We need to define and return to opcode table from within this function + // other inorder to take the addresses of the instruction bodies. + #include "inc/opcode_table.h" + if (get_table_mode) + return opcode_table; + + // Declare virtual machine registers + const instr * ip = program; + const byte * dp = data; + Machine::stack_t * sp = stack + Machine::STACK_GUARD, + * const sb = sp; + SlotMap & smap = *__smap; + Segment & seg = smap.segment; + slotref is = *__map, + * map = __map, + * const mapb = smap.begin()+smap.context(); + uint8 dir = _dir; + int8 flags = 0; + + // start the program + goto **ip; + + // Pull in the opcode definitions + #include "inc/opcodes.h" + + end: + __map = map; + *__map = is; + return sp; +} + +} + +const opcode_t * Machine::getOpcodeTable() throw() +{ + slotref * dummy; + Machine::status_t dumstat = Machine::finished; + return static_cast<const opcode_t *>(direct_run(true, 0, 0, 0, dummy, 0, dumstat)); +} + + +Machine::stack_t Machine::run(const instr * program, + const byte * data, + slotref * & is) +{ + assert(program != 0); + + const stack_t *sp = static_cast<const stack_t *>( + direct_run(false, program, data, _stack, is, _map.dir(), _status, &_map)); + const stack_t ret = sp == _stack+STACK_GUARD+1 ? *sp-- : 0; + check_final_stack(sp); + return ret; +} diff --git a/gfx/graphite2/src/files.mk b/gfx/graphite2/src/files.mk new file mode 100644 index 0000000000..63063567bf --- /dev/null +++ b/gfx/graphite2/src/files.mk @@ -0,0 +1,114 @@ +# GRAPHITE2 LICENSING +# +# Copyright 2011, SIL International +# All rights reserved. +# +# This library is free software; you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published +# by the Free Software Foundation; either version 2.1 of 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 +# Lesser General Public License for more details. +# +# You should also have received a copy of the GNU Lesser General Public +# License along with this library in the file named "LICENSE". +# If not, write to the Free Software Foundation, 51 Franklin Street, +# Suite 500, Boston, MA 02110-1335, USA or visit their web page on the +# internet at http://www.fsf.org/licenses/lgpl.html. +# +# Alternatively, the contents of this file may be used under the terms of the +# Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +# License, as published by the Free Software Foundation, either version 2 +# of the License or (at your option) any later version. + +# Makefile helper file for those wanting to build Graphite2 using make +# The including makefile should set the following variables +# _NS Prefix to all variables this file creates (namespace) +# $(_NS)_MACHINE Set to direct or call. Set to direct if using gcc else +# set to call +# $(_NS)_BASE path to root of graphite2 project +# +# Returns: +# $(_NS)_SOURCES List of source files (with .cpp extension) +# $(_NS)_PRIVATE_HEADERS List of private header files (with .h extension) +# $(_NS)_PUBLIC_HEADERS List of public header files (with .h extension) + + +$(_NS)_SOURCES = \ + $($(_NS)_BASE)/src/$($(_NS)_MACHINE)_machine.cpp \ + $($(_NS)_BASE)/src/gr_char_info.cpp \ + $($(_NS)_BASE)/src/gr_face.cpp \ + $($(_NS)_BASE)/src/gr_features.cpp \ + $($(_NS)_BASE)/src/gr_font.cpp \ + $($(_NS)_BASE)/src/gr_logging.cpp \ + $($(_NS)_BASE)/src/gr_segment.cpp \ + $($(_NS)_BASE)/src/gr_slot.cpp \ + $($(_NS)_BASE)/src/json.cpp \ + $($(_NS)_BASE)/src/CmapCache.cpp \ + $($(_NS)_BASE)/src/Code.cpp \ + $($(_NS)_BASE)/src/Collider.cpp \ + $($(_NS)_BASE)/src/Decompressor.cpp \ + $($(_NS)_BASE)/src/Face.cpp \ + $($(_NS)_BASE)/src/FeatureMap.cpp \ + $($(_NS)_BASE)/src/FileFace.cpp \ + $($(_NS)_BASE)/src/Font.cpp \ + $($(_NS)_BASE)/src/GlyphCache.cpp \ + $($(_NS)_BASE)/src/GlyphFace.cpp \ + $($(_NS)_BASE)/src/Intervals.cpp \ + $($(_NS)_BASE)/src/Justifier.cpp \ + $($(_NS)_BASE)/src/NameTable.cpp \ + $($(_NS)_BASE)/src/Pass.cpp \ + $($(_NS)_BASE)/src/Position.cpp \ + $($(_NS)_BASE)/src/Segment.cpp \ + $($(_NS)_BASE)/src/Silf.cpp \ + $($(_NS)_BASE)/src/Slot.cpp \ + $($(_NS)_BASE)/src/Sparse.cpp \ + $($(_NS)_BASE)/src/TtfUtil.cpp \ + $($(_NS)_BASE)/src/UtfCodec.cpp + +$(_NS)_PRIVATE_HEADERS = \ + $($(_NS)_BASE)/src/inc/bits.h \ + $($(_NS)_BASE)/src/inc/debug.h \ + $($(_NS)_BASE)/src/inc/json.h \ + $($(_NS)_BASE)/src/inc/CharInfo.h \ + $($(_NS)_BASE)/src/inc/CmapCache.h \ + $($(_NS)_BASE)/src/inc/Code.h \ + $($(_NS)_BASE)/src/inc/Collider.h \ + $($(_NS)_BASE)/src/inc/Compression.h \ + $($(_NS)_BASE)/src/inc/Decompressor.h \ + $($(_NS)_BASE)/src/inc/Endian.h \ + $($(_NS)_BASE)/src/inc/Error.h \ + $($(_NS)_BASE)/src/inc/Face.h \ + $($(_NS)_BASE)/src/inc/FeatureMap.h \ + $($(_NS)_BASE)/src/inc/FeatureVal.h \ + $($(_NS)_BASE)/src/inc/FileFace.h \ + $($(_NS)_BASE)/src/inc/Font.h \ + $($(_NS)_BASE)/src/inc/GlyphCache.h \ + $($(_NS)_BASE)/src/inc/GlyphFace.h \ + $($(_NS)_BASE)/src/inc/Intervals.h \ + $($(_NS)_BASE)/src/inc/List.h \ + $($(_NS)_BASE)/src/inc/locale2lcid.h \ + $($(_NS)_BASE)/src/inc/Machine.h \ + $($(_NS)_BASE)/src/inc/Main.h \ + $($(_NS)_BASE)/src/inc/NameTable.h \ + $($(_NS)_BASE)/src/inc/opcode_table.h \ + $($(_NS)_BASE)/src/inc/opcodes.h \ + $($(_NS)_BASE)/src/inc/Pass.h \ + $($(_NS)_BASE)/src/inc/Position.h \ + $($(_NS)_BASE)/src/inc/Rule.h \ + $($(_NS)_BASE)/src/inc/Segment.h \ + $($(_NS)_BASE)/src/inc/Silf.h \ + $($(_NS)_BASE)/src/inc/Slot.h \ + $($(_NS)_BASE)/src/inc/Sparse.h \ + $($(_NS)_BASE)/src/inc/TtfTypes.h \ + $($(_NS)_BASE)/src/inc/TtfUtil.h \ + $($(_NS)_BASE)/src/inc/UtfCodec.h + +$(_NS)_PUBLIC_HEADERS = \ + $($(_NS)_BASE)/include/graphite2/Font.h \ + $($(_NS)_BASE)/include/graphite2/Log.h \ + $($(_NS)_BASE)/include/graphite2/Segment.h \ + $($(_NS)_BASE)/include/graphite2/Types.h diff --git a/gfx/graphite2/src/gr_char_info.cpp b/gfx/graphite2/src/gr_char_info.cpp new file mode 100644 index 0000000000..612f9ba694 --- /dev/null +++ b/gfx/graphite2/src/gr_char_info.cpp @@ -0,0 +1,65 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cassert> +#include "graphite2/Segment.h" +#include "inc/CharInfo.h" + +extern "C" +{ + +unsigned int gr_cinfo_unicode_char(const gr_char_info* p/*not NULL*/) +{ + assert(p); + return p->unicodeChar(); +} + + +int gr_cinfo_break_weight(const gr_char_info* p/*not NULL*/) +{ + assert(p); + return p->breakWeight(); +} + +int gr_cinfo_after(const gr_char_info *p/*not NULL*/) +{ + assert(p); + return p->after(); +} + +int gr_cinfo_before(const gr_char_info *p/*not NULL*/) +{ + assert(p); + return p->before(); +} + +size_t gr_cinfo_base(const gr_char_info *p/*not NULL*/) +{ + assert(p); + return p->base(); +} + +} // extern "C" diff --git a/gfx/graphite2/src/gr_face.cpp b/gfx/graphite2/src/gr_face.cpp new file mode 100644 index 0000000000..baa469727b --- /dev/null +++ b/gfx/graphite2/src/gr_face.cpp @@ -0,0 +1,267 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Font.h" +#include "inc/Face.h" +#include "inc/FileFace.h" +#include "inc/GlyphCache.h" +#include "inc/CmapCache.h" +#include "inc/Silf.h" +#include "inc/json.h" + +using namespace graphite2; + +#if !defined GRAPHITE2_NTRACING +extern json *global_log; +#endif + +namespace +{ + bool load_face(Face & face, unsigned int options) + { +#ifdef GRAPHITE2_TELEMETRY + telemetry::category _misc_cat(face.tele.misc); +#endif + Face::Table silf(face, Tag::Silf, 0x00050000); + if (!silf) + return false; + + if (!face.readGlyphs(options)) + return false; + + if (silf) + { + if (!face.readFeatures() || !face.readGraphite(silf)) + { +#if !defined GRAPHITE2_NTRACING + if (global_log) + { + *global_log << json::object + << "type" << "fontload" + << "failure" << face.error() + << "context" << face.error_context() + << json::close; + } +#endif + return false; + } + else + return true; + } + else + return false; + } + + inline + uint32 zeropad(const uint32 x) + { + if (x == 0x20202020) return 0; + if ((x & 0x00FFFFFF) == 0x00202020) return x & 0xFF000000; + if ((x & 0x0000FFFF) == 0x00002020) return x & 0xFFFF0000; + if ((x & 0x000000FF) == 0x00000020) return x & 0xFFFFFF00; + return x; + } +} + +extern "C" { + +gr_face* gr_make_face_with_ops(const void* appFaceHandle/*non-NULL*/, const gr_face_ops *ops, unsigned int faceOptions) + //the appFaceHandle must stay alive all the time when the gr_face is alive. When finished with the gr_face, call destroy_face +{ + if (ops == 0) return 0; + + Face *res = new Face(appFaceHandle, *ops); + if (res && load_face(*res, faceOptions)) + return static_cast<gr_face *>(res); + + delete res; + return 0; +} + +gr_face* gr_make_face(const void* appFaceHandle/*non-NULL*/, gr_get_table_fn tablefn, unsigned int faceOptions) +{ + const gr_face_ops ops = {sizeof(gr_face_ops), tablefn, NULL}; + return gr_make_face_with_ops(appFaceHandle, &ops, faceOptions); +} + + +gr_face* gr_make_face_with_seg_cache_and_ops(const void* appFaceHandle/*non-NULL*/, const gr_face_ops *ops, unsigned int , unsigned int faceOptions) +{ + return gr_make_face_with_ops(appFaceHandle, ops, faceOptions); +} + +gr_face* gr_make_face_with_seg_cache(const void* appFaceHandle/*non-NULL*/, gr_get_table_fn tablefn, unsigned int, unsigned int faceOptions) +{ + const gr_face_ops ops = {sizeof(gr_face_ops), tablefn, NULL}; + return gr_make_face_with_ops(appFaceHandle, &ops, faceOptions); +} + +gr_uint32 gr_str_to_tag(const char *str) +{ + uint32 res = 0; + switch(max(strlen(str),size_t(4))) + { + case 4: res |= str[3]; GR_FALLTHROUGH; + case 3: res |= str[2] << 8; GR_FALLTHROUGH; + case 2: res |= str[1] << 16; GR_FALLTHROUGH; + case 1: res |= str[0] << 24; GR_FALLTHROUGH; + default: break; + } + return res; +} + +void gr_tag_to_str(gr_uint32 tag, char *str) +{ + if (!str) return; + + *str++ = char(tag >> 24); + *str++ = char(tag >> 16); + *str++ = char(tag >> 8); + *str++ = char(tag); + *str = '\0'; +} + +gr_feature_val* gr_face_featureval_for_lang(const gr_face* pFace, gr_uint32 langname/*0 means clone default*/) //clones the features. if none for language, clones the default +{ + assert(pFace); + langname = zeropad(langname); + return static_cast<gr_feature_val *>(pFace->theSill().cloneFeatures(langname)); +} + + +const gr_feature_ref* gr_face_find_fref(const gr_face* pFace, gr_uint32 featId) //When finished with the FeatureRef, call destroy_FeatureRef +{ + assert(pFace); + featId = zeropad(featId); + const FeatureRef* pRef = pFace->featureById(featId); + return static_cast<const gr_feature_ref*>(pRef); +} + +unsigned short gr_face_n_fref(const gr_face* pFace) +{ + assert(pFace); + int res = 0; + for (int i = 0; i < pFace->numFeatures(); ++i) + if (!(pFace->feature(i)->getFlags() & FeatureRef::HIDDEN)) + ++res; + return res; +} + +const gr_feature_ref* gr_face_fref(const gr_face* pFace, gr_uint16 i) //When finished with the FeatureRef, call destroy_FeatureRef +{ + assert(pFace); + int count = 0; + for (int j = 0; j < pFace->numFeatures(); ++j) + { + const FeatureRef* pRef = pFace->feature(j); + if (!(pRef->getFlags() & FeatureRef::HIDDEN)) + if (count++ == i) + return static_cast<const gr_feature_ref*>(pRef); + } + return 0; +} + +unsigned short gr_face_n_languages(const gr_face* pFace) +{ + assert(pFace); + return pFace->theSill().numLanguages(); +} + +gr_uint32 gr_face_lang_by_index(const gr_face* pFace, gr_uint16 i) +{ + assert(pFace); + return pFace->theSill().getLangName(i); +} + + +void gr_face_destroy(gr_face *face) +{ + delete static_cast<Face*>(face); +} + + +gr_uint16 gr_face_name_lang_for_locale(gr_face *face, const char * locale) +{ + if (face) + { + return face->languageForLocale(locale); + } + return 0; +} + +unsigned short gr_face_n_glyphs(const gr_face* pFace) +{ + return pFace->glyphs().numGlyphs(); +} + +const gr_faceinfo *gr_face_info(const gr_face *pFace, gr_uint32 script) +{ + if (!pFace) return 0; + const Silf *silf = pFace->chooseSilf(script); + if (silf) return silf->silfInfo(); + return 0; +} + +int gr_face_is_char_supported(const gr_face* pFace, gr_uint32 usv, gr_uint32 script) +{ + const Cmap & cmap = pFace->cmap(); + gr_uint16 gid = cmap[usv]; + if (!gid) + { + const Silf * silf = pFace->chooseSilf(script); + gid = silf->findPseudo(usv); + } + return (gid != 0); +} + +#ifndef GRAPHITE2_NFILEFACE +gr_face* gr_make_file_face(const char *filename, unsigned int faceOptions) +{ + FileFace* pFileFace = new FileFace(filename); + if (*pFileFace) + { + gr_face* pRes = gr_make_face_with_ops(pFileFace, &FileFace::ops, faceOptions); + if (pRes) + { + pRes->takeFileFace(pFileFace); //takes ownership + return pRes; + } + } + + //error when loading + + delete pFileFace; + return NULL; +} + +gr_face* gr_make_file_face_with_seg_cache(const char* filename, unsigned int, unsigned int faceOptions) //returns NULL on failure. //TBD better error handling + //when finished with, call destroy_face +{ + return gr_make_file_face(filename, faceOptions); +} +#endif //!GRAPHITE2_NFILEFACE + +} // extern "C" diff --git a/gfx/graphite2/src/gr_features.cpp b/gfx/graphite2/src/gr_features.cpp new file mode 100644 index 0000000000..a560e053f2 --- /dev/null +++ b/gfx/graphite2/src/gr_features.cpp @@ -0,0 +1,138 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Font.h" +#include "inc/Face.h" +#include "inc/FeatureMap.h" +#include "inc/FeatureVal.h" +#include "inc/NameTable.h" + +using namespace graphite2; + +extern "C" { + + +gr_uint16 gr_fref_feature_value(const gr_feature_ref* pfeatureref, const gr_feature_val* feats) //returns 0 if either pointer is NULL +{ + if (!pfeatureref || !feats) return 0; + + return pfeatureref->getFeatureVal(*feats); +} + + +int gr_fref_set_feature_value(const gr_feature_ref* pfeatureref, gr_uint16 val, gr_feature_val* pDest) +{ + if (!pfeatureref || !pDest) return 0; + + return pfeatureref->applyValToFeature(val, *pDest); +} + + +gr_uint32 gr_fref_id(const gr_feature_ref* pfeatureref) //returns 0 if pointer is NULL +{ + if (!pfeatureref) + return 0; + + return pfeatureref->getId(); +} + + +gr_uint16 gr_fref_n_values(const gr_feature_ref* pfeatureref) +{ + if(!pfeatureref) + return 0; + return pfeatureref->getNumSettings(); +} + + +gr_int16 gr_fref_value(const gr_feature_ref* pfeatureref, gr_uint16 settingno) +{ + if(!pfeatureref || (settingno >= pfeatureref->getNumSettings())) + { + return 0; + } + return pfeatureref->getSettingValue(settingno); +} + + +void* gr_fref_label(const gr_feature_ref* pfeatureref, gr_uint16 *langId, gr_encform utf, gr_uint32 *length) +{ + if(!pfeatureref) + { + langId = 0; + length = 0; + return NULL; + } + uint16 label = pfeatureref->getNameId(); + NameTable * names = pfeatureref->getFace().nameTable(); + if (!names) + { + langId = 0; + length = 0; + return NULL; + } + return names->getName(*langId, label, utf, *length); +} + + +void* gr_fref_value_label(const gr_feature_ref*pfeatureref, gr_uint16 setting, + gr_uint16 *langId, gr_encform utf, gr_uint32 *length) +{ + if(!pfeatureref || (setting >= pfeatureref->getNumSettings())) + { + langId = 0; + length = 0; + return NULL; + } + uint16 label = pfeatureref->getSettingName(setting); + NameTable * names = pfeatureref->getFace().nameTable(); + if (!names) + { + langId = 0; + length = 0; + return NULL; + } + return names->getName(*langId, label, utf, *length); +} + + +void gr_label_destroy(void * label) +{ + free(label); +} + +gr_feature_val* gr_featureval_clone(const gr_feature_val* pfeatures/*may be NULL*/) +{ //When finished with the Features, call features_destroy + return static_cast<gr_feature_val*>(pfeatures ? new Features(*pfeatures) : new Features); +} + +void gr_featureval_destroy(gr_feature_val *p) +{ + delete static_cast<Features*>(p); +} + + +} // extern "C" diff --git a/gfx/graphite2/src/gr_font.cpp b/gfx/graphite2/src/gr_font.cpp new file mode 100644 index 0000000000..724cc83c13 --- /dev/null +++ b/gfx/graphite2/src/gr_font.cpp @@ -0,0 +1,74 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Font.h" +#include "inc/Font.h" + + +using namespace graphite2; + +extern "C" { + +void gr_engine_version(int *nMajor, int *nMinor, int *nBugFix) +{ + if (nMajor) *nMajor = GR2_VERSION_MAJOR; + if (nMinor) *nMinor = GR2_VERSION_MINOR; + if (nBugFix) *nBugFix = GR2_VERSION_BUGFIX; +} + +gr_font* gr_make_font(float ppm/*pixels per em*/, const gr_face *face) +{ + return gr_make_font_with_advance_fn(ppm, 0, 0, face); +} + + +gr_font* gr_make_font_with_ops(float ppm/*pixels per em*/, const void* appFontHandle/*non-NULL*/, const gr_font_ops * font_ops, const gr_face * face/*needed for scaling*/) +{ //the appFontHandle must stay alive all the time when the gr_font is alive. When finished with the gr_font, call destroy_gr_font + if (face == 0 || ppm <= 0) return 0; + + Font * const res = new Font(ppm, *face, appFontHandle, font_ops); + if (*res) + return static_cast<gr_font*>(res); + else + { + delete res; + return 0; + } +} + +gr_font* gr_make_font_with_advance_fn(float ppm/*pixels per em*/, const void* appFontHandle/*non-NULL*/, gr_advance_fn getAdvance, const gr_face * face/*needed for scaling*/) +{ + const gr_font_ops ops = {sizeof(gr_font_ops), getAdvance, NULL}; + return gr_make_font_with_ops(ppm, appFontHandle, &ops, face); +} + +void gr_font_destroy(gr_font *font) +{ + delete static_cast<Font*>(font); +} + + +} // extern "C" diff --git a/gfx/graphite2/src/gr_logging.cpp b/gfx/graphite2/src/gr_logging.cpp new file mode 100644 index 0000000000..8f1e675e62 --- /dev/null +++ b/gfx/graphite2/src/gr_logging.cpp @@ -0,0 +1,267 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include <cstdio> + +#include "graphite2/Log.h" +#include "inc/debug.h" +#include "inc/CharInfo.h" +#include "inc/Slot.h" +#include "inc/Segment.h" +#include "inc/json.h" +#include "inc/Collider.h" + +#if defined _WIN32 +#include "windows.h" +#endif + +using namespace graphite2; + +#if !defined GRAPHITE2_NTRACING +json *global_log = 0; +#endif + +extern "C" { + +bool gr_start_logging(GR_MAYBE_UNUSED gr_face * face, const char *log_path) +{ + if (!log_path) return false; + +#if !defined GRAPHITE2_NTRACING + gr_stop_logging(face); +#if defined _WIN32 + int n = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, log_path, -1, 0, 0); + if (n == 0 || n > MAX_PATH - 12) return false; + + LPWSTR wlog_path = gralloc<WCHAR>(n); + if (!wlog_path) return false; + FILE *log = 0; + if (wlog_path && MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, log_path, -1, wlog_path, n)) + log = _wfopen(wlog_path, L"wt"); + + free(wlog_path); +#else // _WIN32 + FILE *log = fopen(log_path, "wt"); +#endif // _WIN32 + if (!log) return false; + + if (face) + { + face->setLogger(log); + if (!face->logger()) return false; + + *face->logger() << json::array; +#ifdef GRAPHITE2_TELEMETRY + *face->logger() << face->tele; +#endif + } + else + { + global_log = new json(log); + *global_log << json::array; + } + + return true; +#else // GRAPHITE2_NTRACING + return false; +#endif // GRAPHITE2_NTRACING +} + +bool graphite_start_logging(FILE * /* log */, GrLogMask /* mask */) +{ +//#if !defined GRAPHITE2_NTRACING +// graphite_stop_logging(); +// +// if (!log) return false; +// +// dbgout = new json(log); +// if (!dbgout) return false; +// +// *dbgout << json::array; +// return true; +//#else + return false; +//#endif +} + +void gr_stop_logging(GR_MAYBE_UNUSED gr_face * face) +{ +#if !defined GRAPHITE2_NTRACING + if (face && face->logger()) + { + FILE * log = face->logger()->stream(); + face->setLogger(0); + fclose(log); + } + else if (!face && global_log) + { + FILE * log = global_log->stream(); + delete global_log; + global_log = 0; + fclose(log); + } +#endif +} + +void graphite_stop_logging() +{ +// if (dbgout) delete dbgout; +// dbgout = 0; +} + +} // extern "C" + +#ifdef GRAPHITE2_TELEMETRY +size_t * graphite2::telemetry::_category = 0UL; +#endif + +#if !defined GRAPHITE2_NTRACING + +#ifdef GRAPHITE2_TELEMETRY + +json & graphite2::operator << (json & j, const telemetry & t) throw() +{ + j << json::object + << "type" << "telemetry" + << "silf" << t.silf + << "states" << t.states + << "starts" << t.starts + << "transitions" << t.transitions + << "glyphs" << t.glyph + << "code" << t.code + << "misc" << t.misc + << "total" << (t.silf + t.states + t.starts + t.transitions + t.glyph + t.code + t.misc) + << json::close; + return j; +} +#else +json & graphite2::operator << (json & j, const telemetry &) throw() +{ + return j; +} +#endif + + +json & graphite2::operator << (json & j, const CharInfo & ci) throw() +{ + return j << json::object + << "offset" << ci.base() + << "unicode" << ci.unicodeChar() + << "break" << ci.breakWeight() + << "flags" << ci.flags() + << "slot" << json::flat << json::object + << "before" << ci.before() + << "after" << ci.after() + << json::close + << json::close; +} + + +json & graphite2::operator << (json & j, const dslot & ds) throw() +{ + assert(ds.first); + assert(ds.second); + const Segment & seg = *ds.first; + const Slot & s = *ds.second; + const SlotCollision *cslot = seg.collisionInfo(ds.second); + + j << json::object + << "id" << objectid(ds) + << "gid" << s.gid() + << "charinfo" << json::flat << json::object + << "original" << s.original() + << "before" << s.before() + << "after" << s.after() + << json::close + << "origin" << s.origin() + << "shift" << Position(float(s.getAttr(0, gr_slatShiftX, 0)), + float(s.getAttr(0, gr_slatShiftY, 0))) + << "advance" << s.advancePos() + << "insert" << s.isInsertBefore() + << "break" << s.getAttr(&seg, gr_slatBreak, 0); + if (s.just() > 0) + j << "justification" << s.just(); + if (s.getBidiLevel() > 0) + j << "bidi" << s.getBidiLevel(); + if (!s.isBase()) + j << "parent" << json::flat << json::object + << "id" << objectid(dslot(&seg, s.attachedTo())) + << "level" << s.getAttr(0, gr_slatAttLevel, 0) + << "offset" << s.attachOffset() + << json::close; + j << "user" << json::flat << json::array; + for (int n = 0; n!= seg.numAttrs(); ++n) + j << s.userAttrs()[n]; + j << json::close; + if (s.firstChild()) + { + j << "children" << json::flat << json::array; + for (const Slot *c = s.firstChild(); c; c = c->nextSibling()) + j << objectid(dslot(&seg, c)); + j << json::close; + } + if (cslot) + { + // Note: the reason for using Positions to lump together related attributes is to make the + // JSON output slightly more compact. + j << "collision" << json::flat << json::object +// << "shift" << cslot->shift() -- not used pass level, only within the collision routine itself + << "offset" << cslot->offset() + << "limit" << cslot->limit() + << "flags" << cslot->flags() + << "margin" << Position(cslot->margin(), cslot->marginWt()) + << "exclude" << cslot->exclGlyph() + << "excludeoffset" << cslot->exclOffset(); + if (cslot->seqOrder() != 0) + { + j << "seqclass" << Position(cslot->seqClass(), cslot->seqProxClass()) + << "seqorder" << cslot->seqOrder() + << "seqabove" << Position(cslot->seqAboveXoff(), cslot->seqAboveWt()) + << "seqbelow" << Position(cslot->seqBelowXlim(), cslot->seqBelowWt()) + << "seqvalign" << Position(cslot->seqValignHt(), cslot->seqValignWt()); + } + j << json::close; + } + return j << json::close; +} + + +graphite2::objectid::objectid(const dslot & ds) throw() +{ + const Slot * const p = ds.second; + uint32 s = uint32(reinterpret_cast<size_t>(p)); + sprintf(name, "%.4x-%.2x-%.4hx", uint16(s >> 16), uint16(p ? p->userAttrs()[ds.first->silf()->numUser()] : 0), uint16(s)); + name[sizeof name-1] = 0; +} + +graphite2::objectid::objectid(const Segment * const p) throw() +{ + uint32 s = uint32(reinterpret_cast<size_t>(p)); + sprintf(name, "%.4x-%.2x-%.4hx", uint16(s >> 16), 0, uint16(s)); + name[sizeof name-1] = 0; +} + +#endif diff --git a/gfx/graphite2/src/gr_segment.cpp b/gfx/graphite2/src/gr_segment.cpp new file mode 100644 index 0000000000..7a27e9c562 --- /dev/null +++ b/gfx/graphite2/src/gr_segment.cpp @@ -0,0 +1,175 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Segment.h" +#include "inc/UtfCodec.h" +#include "inc/Segment.h" + +using namespace graphite2; + +namespace +{ + + gr_segment* makeAndInitialize(const Font *font, const Face *face, uint32 script, const Features* pFeats/*must not be NULL*/, gr_encform enc, const void* pStart, size_t nChars, int dir) + { + if (script == 0x20202020) script = 0; + else if ((script & 0x00FFFFFF) == 0x00202020) script = script & 0xFF000000; + else if ((script & 0x0000FFFF) == 0x00002020) script = script & 0xFFFF0000; + else if ((script & 0x000000FF) == 0x00000020) script = script & 0xFFFFFF00; + // if (!font) return NULL; + Segment* pRes=new Segment(nChars, face, script, dir); + + + if (!pRes->read_text(face, pFeats, enc, pStart, nChars) || !pRes->runGraphite()) + { + delete pRes; + return NULL; + } + pRes->finalise(font, true); + + return static_cast<gr_segment*>(pRes); + } + + template <typename utf_iter> + inline size_t count_unicode_chars(utf_iter first, const utf_iter last, const void **error) + { + size_t n_chars = 0; + uint32 usv = 0; + + if (last) + { + if (!first.validate(last)) + { + if (error) *error = last - 1; + return 0; + } + for (;first != last; ++first, ++n_chars) + if ((usv = *first) == 0 || first.error()) break; + } + else + { + while ((usv = *first) != 0 && !first.error()) + { + ++first; + ++n_chars; + } + } + + if (error) *error = first.error() ? first : 0; + return n_chars; + } +} + + +extern "C" { + +size_t gr_count_unicode_characters(gr_encform enc, const void* buffer_begin, const void* buffer_end/*don't go on or past end, If NULL then ignored*/, const void** pError) //Also stops on nul. Any nul is not in the count +{ + assert(buffer_begin); + + switch (enc) + { + case gr_utf8: return count_unicode_chars<utf8::const_iterator>(buffer_begin, buffer_end, pError); break; + case gr_utf16: return count_unicode_chars<utf16::const_iterator>(buffer_begin, buffer_end, pError); break; + case gr_utf32: return count_unicode_chars<utf32::const_iterator>(buffer_begin, buffer_end, pError); break; + default: return 0; + } +} + + +gr_segment* gr_make_seg(const gr_font *font, const gr_face *face, gr_uint32 script, const gr_feature_val* pFeats, gr_encform enc, const void* pStart, size_t nChars, int dir) +{ + if (!face) return nullptr; + + const gr_feature_val * tmp_feats = 0; + if (pFeats == 0) + pFeats = tmp_feats = static_cast<const gr_feature_val*>(face->theSill().cloneFeatures(0)); + gr_segment * seg = makeAndInitialize(font, face, script, pFeats, enc, pStart, nChars, dir); + delete static_cast<const FeatureVal*>(tmp_feats); + + return seg; +} + + +void gr_seg_destroy(gr_segment* p) +{ + delete static_cast<Segment*>(p); +} + + +float gr_seg_advance_X(const gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return pSeg->advance().x; +} + + +float gr_seg_advance_Y(const gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return pSeg->advance().y; +} + + +unsigned int gr_seg_n_cinfo(const gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return static_cast<unsigned int>(pSeg->charInfoCount()); +} + + +const gr_char_info* gr_seg_cinfo(const gr_segment* pSeg/*not NULL*/, unsigned int index/*must be <number_of_CharInfo*/) +{ + assert(pSeg); + return static_cast<const gr_char_info*>(pSeg->charinfo(index)); +} + +unsigned int gr_seg_n_slots(const gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return static_cast<unsigned int>(pSeg->slotCount()); +} + +const gr_slot* gr_seg_first_slot(gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return static_cast<const gr_slot*>(pSeg->first()); +} + +const gr_slot* gr_seg_last_slot(gr_segment* pSeg/*not NULL*/) +{ + assert(pSeg); + return static_cast<const gr_slot*>(pSeg->last()); +} + +float gr_seg_justify(gr_segment* pSeg/*not NULL*/, const gr_slot* pSlot/*not NULL*/, const gr_font *pFont, double width, enum gr_justFlags flags, const gr_slot *pFirst, const gr_slot *pLast) +{ + assert(pSeg); + assert(pSlot); + return pSeg->justify(const_cast<gr_slot *>(pSlot), pFont, float(width), justFlags(flags), const_cast<gr_slot *>(pFirst), const_cast<gr_slot *>(pLast)); +} + +} // extern "C" diff --git a/gfx/graphite2/src/gr_slot.cpp b/gfx/graphite2/src/gr_slot.cpp new file mode 100644 index 0000000000..a3c6b46a7f --- /dev/null +++ b/gfx/graphite2/src/gr_slot.cpp @@ -0,0 +1,173 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#include "graphite2/Segment.h" +#include "inc/Segment.h" +#include "inc/Slot.h" +#include "inc/Font.h" + + +extern "C" { + + +const gr_slot* gr_slot_next_in_segment(const gr_slot* p/*not NULL*/) +{ + assert(p); + return static_cast<const gr_slot*>(p->next()); +} + +const gr_slot* gr_slot_prev_in_segment(const gr_slot* p/*not NULL*/) +{ + assert(p); + return static_cast<const gr_slot*>(p->prev()); +} + +const gr_slot* gr_slot_attached_to(const gr_slot* p/*not NULL*/) //returns NULL iff base. If called repeatedly on result, will get to a base +{ + assert(p); + return static_cast<const gr_slot*>(p->attachedTo()); +} + + +const gr_slot* gr_slot_first_attachment(const gr_slot* p/*not NULL*/) //returns NULL iff no attachments. +{ //if slot_first_attachment(p) is not NULL, then slot_attached_to(slot_first_attachment(p))==p. + assert(p); + return static_cast<const gr_slot*>(p->firstChild()); +} + + +const gr_slot* gr_slot_next_sibling_attachment(const gr_slot* p/*not NULL*/) //returns NULL iff no more attachments. +{ //if slot_next_sibling_attachment(p) is not NULL, then slot_attached_to(slot_next_sibling_attachment(p))==slot_attached_to(p). + assert(p); + return static_cast<const gr_slot*>(p->nextSibling()); +} + + +unsigned short gr_slot_gid(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->glyph(); +} + + +float gr_slot_origin_X(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->origin().x; +} + + +float gr_slot_origin_Y(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->origin().y; +} + + +float gr_slot_advance_X(const gr_slot* p/*not NULL*/, const gr_face *face, const gr_font *font) +{ + assert(p); + float scale = 1.0; + float res = p->advance(); + if (font) + { + scale = font->scale(); + int gid = p->glyph(); + if (face && font->isHinted() && gid < face->glyphs().numGlyphs()) + res = (res - face->glyphs().glyph(gid)->theAdvance().x) * scale + font->advance(gid); + else + res = res * scale; + } + return res; +} + +float gr_slot_advance_Y(const gr_slot *p/*not NULL*/, GR_MAYBE_UNUSED const gr_face *face, const gr_font *font) +{ + assert(p); + float res = p->advancePos().y; + if (font) + return res * font->scale(); + else + return res; +} + +int gr_slot_before(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->before(); +} + + +int gr_slot_after(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->after(); +} + +unsigned int gr_slot_index(const gr_slot *p/*not NULL*/) +{ + assert(p); + return p->index(); +} + +int gr_slot_attr(const gr_slot* p/*not NULL*/, const gr_segment* pSeg/*not NULL*/, gr_attrCode index, gr_uint8 subindex) +{ + assert(p); + return p->getAttr(pSeg, index, subindex); +} + + +int gr_slot_can_insert_before(const gr_slot* p/*not NULL*/) +{ + assert(p); + return (p->isInsertBefore())? 1 : 0; +} + + +int gr_slot_original(const gr_slot* p/*not NULL*/) +{ + assert(p); + return p->original(); +} + +void gr_slot_linebreak_before(gr_slot* p/*not NULL*/) +{ + assert(p); + gr_slot *prev = (gr_slot *)p->prev(); + prev->sibling(NULL); + prev->next(NULL); + p->prev(NULL); +} + +#if 0 //what should this be +size_t id(const gr_slot* p/*not NULL*/) +{ + return (size_t)p->id(); +} +#endif + + +} // extern "C" diff --git a/gfx/graphite2/src/inc/CharInfo.h b/gfx/graphite2/src/inc/CharInfo.h new file mode 100644 index 0000000000..01e7e31ac9 --- /dev/null +++ b/gfx/graphite2/src/inc/CharInfo.h @@ -0,0 +1,66 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include "inc/Main.h" + + +namespace graphite2 { + +class CharInfo +{ + +public: + CharInfo() : m_char(0), m_before(-1), m_after(-1), m_base(0), m_featureid(0), m_break(0), m_flags(0) {} + void init(int cid) { m_char = cid; } + unsigned int unicodeChar() const { return m_char; } + void feats(int offset) { m_featureid = offset; } + int fid() const { return m_featureid; } + int breakWeight() const { return m_break; } + void breakWeight(int val) { m_break = val; } + int after() const { return m_after; } + void after(int val) { m_after = val; } + int before() const { return m_before; } + void before(int val) { m_before = val; } + size_t base() const { return m_base; } + void base(size_t offset) { m_base = offset; } + void addflags(uint8 val) { m_flags |= val; } + uint8 flags() const { return m_flags; } + + CLASS_NEW_DELETE +private: + int m_char; // Unicode character from character stream + int m_before; // slot index before us, comes before + int m_after; // slot index after us, comes after + size_t m_base; // offset into input string corresponding to this charinfo + uint8 m_featureid; // index into features list in the segment + int8 m_break; // breakweight coming from lb table + uint8 m_flags; // 0,1 segment split. +}; + +} // namespace graphite2 + +struct gr_char_info : public graphite2::CharInfo {}; diff --git a/gfx/graphite2/src/inc/CmapCache.h b/gfx/graphite2/src/inc/CmapCache.h new file mode 100644 index 0000000000..7820c958b0 --- /dev/null +++ b/gfx/graphite2/src/inc/CmapCache.h @@ -0,0 +1,82 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "inc/Main.h" +#include "inc/Face.h" + +namespace graphite2 { + +class Face; + +class Cmap +{ +public: + + virtual ~Cmap() throw() {} + + virtual uint16 operator [] (const uint32) const throw() { return 0; } + + virtual operator bool () const throw() { return false; } + + CLASS_NEW_DELETE; +}; + +class DirectCmap : public Cmap +{ + DirectCmap(const DirectCmap &); + DirectCmap & operator = (const DirectCmap &); + +public: + DirectCmap(const Face &); + virtual uint16 operator [] (const uint32 usv) const throw(); + virtual operator bool () const throw(); + + CLASS_NEW_DELETE; +private: + const Face::Table _cmap; + const void * _smp, + * _bmp; +}; + +class CachedCmap : public Cmap +{ + CachedCmap(const CachedCmap &); + CachedCmap & operator = (const CachedCmap &); + +public: + CachedCmap(const Face &); + virtual ~CachedCmap() throw(); + virtual uint16 operator [] (const uint32 usv) const throw(); + virtual operator bool () const throw(); + CLASS_NEW_DELETE; +private: + bool m_isBmpOnly; + uint16 ** m_blocks; +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Code.h b/gfx/graphite2/src/inc/Code.h new file mode 100644 index 0000000000..3cee67c81d --- /dev/null +++ b/gfx/graphite2/src/inc/Code.h @@ -0,0 +1,171 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This class represents loaded graphite stack machine code. It performs +// basic sanity checks, on the incoming code to prevent more obvious problems +// from crashing graphite. +// Author: Tim Eves + +#pragma once + +#include <cassert> +#include <graphite2/Types.h> +#include "inc/Main.h" +#include "inc/Machine.h" + +namespace graphite2 { + +class Silf; +class Face; + +enum passtype { + PASS_TYPE_UNKNOWN = 0, + PASS_TYPE_LINEBREAK, + PASS_TYPE_SUBSTITUTE, + PASS_TYPE_POSITIONING, + PASS_TYPE_JUSTIFICATION +}; + +namespace vm { + +class Machine::Code +{ +public: + enum status_t + { + loaded, + alloc_failed, + invalid_opcode, + unimplemented_opcode_used, + out_of_range_data, + jump_past_end, + arguments_exhausted, + missing_return, + nested_context_item, + underfull_stack + }; + +private: + class decoder; + + instr * _code; + byte * _data; + size_t _data_size, + _instr_count; + byte _max_ref; + mutable status_t _status; + bool _constraint, + _modify, + _delete; + mutable bool _own; + + void release_buffers() throw (); + void failure(const status_t) throw(); + +public: + static size_t estimateCodeDataOut(size_t num_bytecodes, int nRules, int nSlots); + + Code() throw(); + Code(bool is_constraint, const byte * bytecode_begin, const byte * const bytecode_end, + uint8 pre_context, uint16 rule_length, const Silf &, const Face &, + enum passtype pt, byte * * const _out = 0); + Code(const Machine::Code &) throw(); + ~Code() throw(); + + Code & operator=(const Code &rhs) throw(); + operator bool () const throw() { return _code && status() == loaded; } + status_t status() const throw() { return _status; } + bool constraint() const throw() { return _constraint; } + size_t dataSize() const throw() { return _data_size; } + size_t instructionCount() const throw() { return _instr_count; } + bool immutable() const throw() { return !(_delete || _modify); } + bool deletes() const throw() { return _delete; } + size_t maxRef() const throw() { return _max_ref; } + void externalProgramMoved(ptrdiff_t) throw(); + + int32 run(Machine &m, slotref * & map) const; + + CLASS_NEW_DELETE; +}; + +inline +size_t Machine::Code::estimateCodeDataOut(size_t n_bc, int nRules, int nSlots) +{ + // max is: all codes are instructions + 1 for each rule + max tempcopies + // allocate space for separate maximal code and data then merge them later + return (n_bc + nRules + nSlots) * sizeof(instr) + n_bc * sizeof(byte); +} + + +inline Machine::Code::Code() throw() +: _code(0), _data(0), _data_size(0), _instr_count(0), _max_ref(0), + _status(loaded), _constraint(false), _modify(false), _delete(false), + _own(false) +{ +} + +inline Machine::Code::Code(const Machine::Code &obj) throw () + : _code(obj._code), + _data(obj._data), + _data_size(obj._data_size), + _instr_count(obj._instr_count), + _max_ref(obj._max_ref), + _status(obj._status), + _constraint(obj._constraint), + _modify(obj._modify), + _delete(obj._delete), + _own(obj._own) +{ + obj._own = false; +} + +inline Machine::Code & Machine::Code::operator=(const Machine::Code &rhs) throw() { + if (_instr_count > 0) + release_buffers(); + _code = rhs._code; + _data = rhs._data; + _data_size = rhs._data_size; + _instr_count = rhs._instr_count; + _status = rhs._status; + _constraint = rhs._constraint; + _modify = rhs._modify; + _delete = rhs._delete; + _own = rhs._own; + rhs._own = false; + return *this; +} + +inline void Machine::Code::externalProgramMoved(ptrdiff_t dist) throw() +{ + if (_code && !_own) + { + _code += dist / signed(sizeof(instr)); + _data += dist; + } +} + +} // namespace vm +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Collider.h b/gfx/graphite2/src/inc/Collider.h new file mode 100644 index 0000000000..71e8400501 --- /dev/null +++ b/gfx/graphite2/src/inc/Collider.h @@ -0,0 +1,245 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "inc/List.h" +#include "inc/Position.h" +#include "inc/Intervals.h" +#include "inc/debug.h" + +namespace graphite2 { + +class json; +class Slot; +class Segment; + +#define SLOTCOLSETUINTPROP(x, y) uint16 x() const { return _ ##x; } void y (uint16 v) { _ ##x = v; } +#define SLOTCOLSETINTPROP(x, y) int16 x() const { return _ ##x; } void y (int16 v) { _ ##x = v; } +#define SLOTCOLSETPOSITIONPROP(x, y) const Position &x() const { return _ ##x; } void y (const Position &v) { _ ##x = v; } + +// Slot attributes related to collision-fixing +class SlotCollision +{ +public: + enum { + // COLL_TESTONLY = 0, // default - test other glyphs for collision with this one, but don't move this one + COLL_FIX = 1, // fix collisions involving this glyph + COLL_IGNORE = 2, // ignore this glyph altogether + COLL_START = 4, // start of range of possible collisions + COLL_END = 8, // end of range of possible collisions + COLL_KERN = 16, // collisions with this glyph are fixed by adding kerning space after it + COLL_ISCOL = 32, // this glyph has a collision + COLL_KNOWN = 64, // we've figured out what's happening with this glyph + COLL_ISSPACE = 128, // treat this glyph as a space with regard to kerning + COLL_TEMPLOCK = 256, // Lock glyphs that have been given priority positioning + ////COLL_JUMPABLE = 128, // moving glyphs may jump this stationary glyph in any direction - DELETE + ////COLL_OVERLAP = 256, // use maxoverlap to restrict - DELETE + }; + + // Behavior for the collision.order attribute. To GDL this is an enum, to us it's a bitfield, with only 1 bit set + // Allows for easier inversion. + enum { + SEQ_ORDER_LEFTDOWN = 1, + SEQ_ORDER_RIGHTUP = 2, + SEQ_ORDER_NOABOVE = 4, + SEQ_ORDER_NOBELOW = 8, + SEQ_ORDER_NOLEFT = 16, + SEQ_ORDER_NORIGHT = 32 + }; + + SlotCollision(Segment *seg, Slot *slot); + void initFromSlot(Segment *seg, Slot *slot); + + const Rect &limit() const { return _limit; } + void setLimit(const Rect &r) { _limit = r; } + SLOTCOLSETPOSITIONPROP(shift, setShift) + SLOTCOLSETPOSITIONPROP(offset, setOffset) + SLOTCOLSETPOSITIONPROP(exclOffset, setExclOffset) + SLOTCOLSETUINTPROP(margin, setMargin) + SLOTCOLSETUINTPROP(marginWt, setMarginWt) + SLOTCOLSETUINTPROP(flags, setFlags) + SLOTCOLSETUINTPROP(exclGlyph, setExclGlyph) + SLOTCOLSETUINTPROP(seqClass, setSeqClass) + SLOTCOLSETUINTPROP(seqProxClass, setSeqProxClass) + SLOTCOLSETUINTPROP(seqOrder, setSeqOrder) + SLOTCOLSETINTPROP(seqAboveXoff, setSeqAboveXoff) + SLOTCOLSETUINTPROP(seqAboveWt, setSeqAboveWt) + SLOTCOLSETINTPROP(seqBelowXlim, setSeqBelowXlim) + SLOTCOLSETUINTPROP(seqBelowWt, setSeqBelowWt) + SLOTCOLSETUINTPROP(seqValignHt, setSeqValignHt) + SLOTCOLSETUINTPROP(seqValignWt, setSeqValignWt) + + float getKern(int dir) const; + bool ignore() const; + +private: + Rect _limit; + Position _shift; // adjustment within the given pass + Position _offset; // total adjustment for collisions + Position _exclOffset; + uint16 _margin; + uint16 _marginWt; + uint16 _flags; + uint16 _exclGlyph; + uint16 _seqClass; + uint16 _seqProxClass; + uint16 _seqOrder; + int16 _seqAboveXoff; + uint16 _seqAboveWt; + int16 _seqBelowXlim; + uint16 _seqBelowWt; + uint16 _seqValignHt; + uint16 _seqValignWt; + +}; // end of class SlotColllision + +struct BBox; +struct SlantBox; + +class ShiftCollider +{ +public: + typedef std::pair<float, float> fpair; + typedef Vector<fpair> vfpairs; + typedef vfpairs::iterator ivfpairs; + + ShiftCollider(json *dbgout); + ~ShiftCollider() throw() { }; + + bool initSlot(Segment *seg, Slot *aSlot, const Rect &constraint, + float margin, float marginMin, const Position &currShift, + const Position &currOffset, int dir, GR_MAYBE_UNUSED json * const dbgout); + bool mergeSlot(Segment *seg, Slot *slot, const SlotCollision *cinfo, const Position &currShift, bool isAfter, + bool sameCluster, bool &hasCol, bool isExclusion, GR_MAYBE_UNUSED json * const dbgout); + Position resolve(Segment *seg, bool &isCol, GR_MAYBE_UNUSED json * const dbgout); + void addBox_slope(bool isx, const Rect &box, const BBox &bb, const SlantBox &sb, const Position &org, float weight, float m, bool minright, int mode); + void removeBox(const Rect &box, const BBox &bb, const SlantBox &sb, const Position &org, int mode); + const Position &origin() const { return _origin; } + +#if !defined GRAPHITE2_NTRACING + void outputJsonDbg(json * const dbgout, Segment *seg, int axis); + void outputJsonDbgStartSlot(json * const dbgout, Segment *seg); + void outputJsonDbgEndSlot(json * const dbgout, Position resultPos, int bestAxis, bool isCol); + void outputJsonDbgOneVector(json * const dbgout, Segment *seg, int axis, float tleft, float bestCost, float bestVal); + void outputJsonDbgRawRanges(json * const dbgout, int axis); + void outputJsonDbgRemovals(json * const dbgout, int axis, Segment *seg); +#endif + + CLASS_NEW_DELETE; + +protected: + Zones _ranges[4]; // possible movements in 4 directions (horizontally, vertically, diagonally); + Slot * _target; // the glyph to fix + Rect _limit; + Position _currShift; + Position _currOffset; + Position _origin; // Base for all relative calculations + float _margin; + float _marginWt; + float _len[4]; + uint16 _seqClass; + uint16 _seqProxClass; + uint16 _seqOrder; + + //bool _scraping[4]; + +}; // end of class ShiftCollider + +inline +ShiftCollider::ShiftCollider(GR_MAYBE_UNUSED json *dbgout) +: _target(0), + _margin(0.0), + _marginWt(0.0), + _seqClass(0), + _seqProxClass(0), + _seqOrder(0) +{ +#if !defined GRAPHITE2_NTRACING + for (int i = 0; i < 4; ++i) + _ranges[i].setdebug(dbgout); +#endif +} + +class KernCollider +{ +public: + KernCollider(json *dbg); + ~KernCollider() throw() { }; + bool initSlot(Segment *seg, Slot *aSlot, const Rect &constraint, float margin, + const Position &currShift, const Position &offsetPrev, int dir, + float ymin, float ymax, json * const dbgout); + bool mergeSlot(Segment *seg, Slot *slot, const Position &currShift, float currSpace, int dir, json * const dbgout); + Position resolve(Segment *seg, Slot *slot, int dir, json * const dbgout); + void shift(const Position &mv, int dir); + + CLASS_NEW_DELETE; + +private: + Slot * _target; // the glyph to fix + Rect _limit; + float _margin; + Position _offsetPrev; // kern from a previous pass + Position _currShift; // NOT USED?? + float _miny; // y-coordinates offset by global slot position + float _maxy; + Vector<float> _edges; // edges of horizontal slices + float _sliceWidth; // width of each slice + float _mingap; + float _xbound; // max or min edge + bool _hit; + +#if !defined GRAPHITE2_NTRACING + // Debugging + Segment * _seg; + Vector<float> _nearEdges; // closest potential collision in each slice + Vector<Slot*> _slotNear; +#endif +}; // end of class KernCollider + + +inline +float sqr(float x) { + return x * x; +} + +inline +KernCollider::KernCollider(GR_MAYBE_UNUSED json *dbg) +: _target(0), + _margin(0.0f), + _miny(-1e38f), + _maxy(1e38f), + _sliceWidth(0.0f), + _mingap(0.0f), + _xbound(0.0), + _hit(false) +{ +#if !defined GRAPHITE2_NTRACING + _seg = 0; +#endif +}; + +}; // end of namespace graphite2 diff --git a/gfx/graphite2/src/inc/Compression.h b/gfx/graphite2/src/inc/Compression.h new file mode 100644 index 0000000000..9fe10e025d --- /dev/null +++ b/gfx/graphite2/src/inc/Compression.h @@ -0,0 +1,104 @@ +/* GRAPHITE2 LICENSING + + Copyright 2015, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +#pragma once + +#include <cassert> +#include <cstddef> +#include <cstring> + +namespace +{ + +#if defined(_MSC_VER) +typedef unsigned __int8 u8; +typedef unsigned __int16 u16; +typedef unsigned __int32 u32; +typedef unsigned __int64 u64; +#else +#include <stdint.h> +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; +#endif + +ptrdiff_t const MINMATCH = 4, + LASTLITERALS = 5, + MINCODA = LASTLITERALS+1, + MINSRCSIZE = 13; + +template<int S> +inline +void unaligned_copy(void * d, void const * s) { + ::memcpy(d, s, S); +} + +inline +size_t align(size_t p) { + return (p + sizeof(unsigned long)-1) & ~(sizeof(unsigned long)-1); +} + +inline +u8 * safe_copy(u8 * d, u8 const * s, size_t n) { + while (n--) *d++ = *s++; + return d; +} + +inline +u8 * overrun_copy(u8 * d, u8 const * s, size_t n) { + size_t const WS = sizeof(unsigned long); + u8 const * e = s + n; + do + { + unaligned_copy<WS>(d, s); + d += WS; + s += WS; + } + while (s < e); + d-=(s-e); + + return d; +} + + +inline +u8 * fast_copy(u8 * d, u8 const * s, size_t n) { + size_t const WS = sizeof(unsigned long); + size_t wn = n/WS; + while (wn--) + { + unaligned_copy<WS>(d, s); + d += WS; + s += WS; + } + n &= WS-1; + return safe_copy(d, s, n); +} + + +} // end of anonymous namespace diff --git a/gfx/graphite2/src/inc/Decompressor.h b/gfx/graphite2/src/inc/Decompressor.h new file mode 100644 index 0000000000..10f21b7af1 --- /dev/null +++ b/gfx/graphite2/src/inc/Decompressor.h @@ -0,0 +1,54 @@ +/* GRAPHITE2 LICENSING + + Copyright 2015, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +#pragma once + +#include <cstddef> + +namespace lz4 +{ + +// decompress an LZ4 block +// Parameters: +// @in - Input buffer containing an LZ4 block. +// @in_size - Size of the input LZ4 block in bytes. +// @out - Output buffer to hold decompressed results. +// @out_size - The size of the buffer pointed to by @out. +// Invariants: +// @in - This buffer must be at least 1 machine word in length, +// regardless of the actual LZ4 block size. +// @in_size - This must be at least 4 and must also be <= to the +// allocated buffer @in. +// @out - This must be bigger than the input buffer and at least +// 13 bytes. +// @out_size - Must always be big enough to hold the expected size. +// Return: +// -1 - Decompression failed. +// size - Actual number of bytes decompressed. +int decompress(void const *in, size_t in_size, void *out, size_t out_size); + +} // end of namespace shrinker diff --git a/gfx/graphite2/src/inc/Endian.h b/gfx/graphite2/src/inc/Endian.h new file mode 100644 index 0000000000..56ecfd8667 --- /dev/null +++ b/gfx/graphite2/src/inc/Endian.h @@ -0,0 +1,111 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +/* +Description: + A set of fast template based decoders for decoding values of any C integer + type up to long int size laid out with most significant byte first or least + significant byte first (aka big endian or little endian). These are CPU + byte order agnostic and will function the same regardless of the CPUs native + byte order. + + Being template based means if the either le or be class is not used then + template code of unused functions will not be instantiated by the compiler + and thus shouldn't cause any overhead. +*/ + +#include <cstddef> + +#pragma once + + +class be +{ + template<int S> + inline static unsigned long int _peek(const unsigned char * p) { + return _peek<S/2>(p) << (S/2)*8 | _peek<S/2>(p+S/2); + } +public: + template<typename T> + inline static T peek(const void * p) { + return T(_peek<sizeof(T)>(static_cast<const unsigned char *>(p))); + } + + template<typename T> + inline static T read(const unsigned char * &p) { + const T r = T(_peek<sizeof(T)>(p)); + p += sizeof r; + return r; + } + + template<typename T> + inline static T swap(const T x) { + return T(_peek<sizeof(T)>(reinterpret_cast<const unsigned char *>(&x))); + } + + template<typename T> + inline static void skip(const unsigned char * &p, size_t n=1) { + p += sizeof(T)*n; + } +}; + +template<> +inline unsigned long int be::_peek<1>(const unsigned char * p) { return *p; } + + +class le +{ + template<int S> + inline static unsigned long int _peek(const unsigned char * p) { + return _peek<S/2>(p) | _peek<S/2>(p+S/2) << (S/2)*8; + } +public: + template<typename T> + inline static T peek(const void * p) { + return T(_peek<sizeof(T)>(static_cast<const unsigned char *>(p))); + } + + template<typename T> + inline static T read(const unsigned char * &p) { + const T r = T(_peek<sizeof(T)>(p)); + p += sizeof r; + return r; + } + + template<typename T> + inline static T swap(const T x) { + return T(_peek<sizeof(T)>(reinterpret_cast<const unsigned char *>(&x))); + } + + template<typename T> + inline static void skip(const unsigned char * &p, size_t n=1) { + p += sizeof(T)*n; + } +}; + +template<> +inline unsigned long int le::_peek<1>(const unsigned char * p) { return *p; } diff --git a/gfx/graphite2/src/inc/Error.h b/gfx/graphite2/src/inc/Error.h new file mode 100644 index 0000000000..2b7ab763a2 --- /dev/null +++ b/gfx/graphite2/src/inc/Error.h @@ -0,0 +1,134 @@ +/* GRAPHITE2 LICENSING + + Copyright 2013, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +// numbers are explicitly assigned for future proofing + +namespace graphite2 +{ + +class Error +{ +public: + Error() : _e(0) {}; + operator bool() { return (_e != 0); } + int error() { return _e; } + void error(int e) { _e = e; } + bool test(bool pr, int err) { return (_e = int(pr) * err); } + +private: + int _e; +}; + +enum errcontext { + EC_READGLYPHS = 1, // while reading glyphs + EC_READSILF = 2, // in Silf table + EC_ASILF = 3, // in Silf %d + EC_APASS = 4, // in Silf %d, pass %d + EC_PASSCCODE = 5, // in pass constraint code for Silf %d, pass %d + EC_ARULE = 6, // in Silf %d, pass %d, rule %d + EC_ASTARTS = 7, // in Silf %d, pass %d, start state %d + EC_ATRANS = 8, // in Silf %d, pass %d, fsm state %d + EC_ARULEMAP = 9 // in Silf %d, pass %d, state %d +}; + +enum errors { + E_OUTOFMEM = 1, // Out of memory + E_NOGLYPHS = 2, // There are no glyphs in the font + E_BADUPEM = 3, // The units per em for the font is bad (0) + E_BADCMAP = 4, // The font does not contain any useful cmaps + E_NOSILF = 5, // Missing Silf table + E_TOOOLD = 6, // Silf table version is too old + E_BADSIZE = 7, // context object has the wrong structural size +// Silf Subtable Errors take a Silf subtable number * 256 in the context + E_BADMAXGLYPH = 8, // Silf max glyph id is too high + E_BADNUMJUSTS = 9, // Number of Silf justification blocks is too high + E_BADENDJUSTS = 10, // Silf justification blocks take too much of the Silf table space + E_BADCRITFEATURES = 11, // Critical features section in a Silf table is too big + E_BADSCRIPTTAGS = 12, // Silf script tags area is too big + E_BADAPSEUDO = 13, // The pseudo glyph attribute number is too high + E_BADABREAK = 14, // The linebreak glyph attribute number is too high + E_BADABIDI = 15, // The bidi glyph attribute number is too high + E_BADAMIRROR = 16, // The mirrored glyph attribute number is too high + E_BADNUMPASSES = 17, // The number of passes is > 128 + E_BADPASSESSTART = 18, // The Silf table is too small to hold any passes + E_BADPASSBOUND = 19, // The positioning pass number is too low or the substitution pass number is too high + E_BADPPASS = 20, // The positioning pass number is too high + E_BADSPASS = 21, // the substitution pass number is too high + E_BADJPASSBOUND = 22, // the justification pass must be higher than the positioning pass + E_BADJPASS = 23, // the justification pass is too high + E_BADALIG = 24, // the number of initial ligature component glyph attributes is too high + E_BADBPASS = 25, // the bidi pass number is specified and is either too high or too low + E_BADNUMPSEUDO = 26, // The number of pseudo glyphs is too high + E_BADCLASSSIZE = 27, // The size of the classes block is bad + E_TOOMANYLINEAR = 28, // The number of linear classes in the silf table is too high + E_CLASSESTOOBIG = 29, // There are too many classes for the space allocated in the Silf subtable + E_MISALIGNEDCLASSES = 30, // The class offsets in the class table don't line up with the number of classes + E_HIGHCLASSOFFSET = 31, // The class offsets point out of the class table + E_BADCLASSOFFSET = 32, // A class offset is less than one following it + E_BADCLASSLOOKUPINFO = 33, // The search header info for a non-linear class has wrong values in it +// Pass subtable errors. Context has pass number * 65536 + E_BADPASSSTART = 34, // The start offset for a particular pass is bad + E_BADPASSEND = 35, // The end offset for a particular pass is bad + E_BADPASSLENGTH = 36, // The length of the pass is too small + E_BADNUMTRANS = 37, // The number of transition states in the fsm is bad + E_BADNUMSUCCESS = 38, // The number of success states in the fsm is bad + E_BADNUMSTATES = 39, // The number of states in the fsm is bad + E_NORANGES = 40, // There are no columns in the fsm + E_BADRULEMAPLEN = 41, // The size of the success state to rule mapping is bad + E_BADCTXTLENBOUNDS = 42, // The precontext maximum is greater than its minimum + E_BADCTXTLENS = 43, // The lists of rule lengths or pre context lengths is bad + E_BADPASSCCODEPTR = 44, // The pass constraint code position does not align with where the forward reference says it should be + E_BADRULECCODEPTR = 45, // The rule constraint code position does not align with where the forward reference says it should be + E_BADCCODELEN = 46, // Bad rule/pass constraint code length + E_BADACTIONCODEPTR = 47, // The action code position does not align with where the forward reference says it should be + E_MUTABLECCODE = 48, // Constraint code edits slots. It shouldn't. + E_BADSTATE = 49, // Bad state transition referencing an illegal state + E_BADRULEMAPPING = 50, // The structure of the rule mapping is bad + E_BADRANGE = 51, // Bad column range structure including a glyph in more than one column + E_BADRULENUM = 52, // A reference to a rule is out of range (too high) + E_BADACOLLISION = 53, // Bad Silf table collision attribute number (too high) + E_BADEMPTYPASS = 54, // Can't have empty passes (no rules) except for collision passes + E_BADSILFVERSION = 55, // The Silf table has a bad version (probably too high) + E_BADCOLLISIONPASS = 56, // Collision flags set on a non positioning pass + E_BADNUMCOLUMNS = 57, // Arbitrarily limit number of columns in fsm +// Code errors + E_CODEFAILURE = 60, // Base code error. The following subcodes must align with Machine::Code::status_t in Code.h + E_CODEALLOC = 61, // Out of memory + E_INVALIDOPCODE = 62, // Invalid op code + E_UNIMPOPCODE = 63, // Unimplemented op code encountered + E_OUTOFRANGECODE = 64, // Code argument out of range + E_BADJUMPCODE = 65, // Code jumps past end of op codes + E_CODEBADARGS = 66, // Code arguments exhausted + E_CODENORETURN = 67, // Missing return type op code at end of code + E_CODENESTEDCTXT = 68, // Nested context encountered in code +// Compression errors + E_BADSCHEME = 69, + E_SHRINKERFAILED = 70, +}; + +} diff --git a/gfx/graphite2/src/inc/Face.h b/gfx/graphite2/src/inc/Face.h new file mode 100644 index 0000000000..355c5aa0d3 --- /dev/null +++ b/gfx/graphite2/src/inc/Face.h @@ -0,0 +1,225 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <cstdio> + +#include "graphite2/Font.h" + +#include "inc/Main.h" +#include "inc/FeatureMap.h" +#include "inc/TtfUtil.h" +#include "inc/Silf.h" +#include "inc/Error.h" + +namespace graphite2 { + +class Cmap; +class FileFace; +class GlyphCache; +class NameTable; +class json; +class Font; + + +using TtfUtil::Tag; + +// These are the actual tags, as distinct from the consecutive IDs in TtfUtil.h + +class Face +{ + // Prevent any kind of copying + Face(const Face&); + Face& operator=(const Face&); + +public: + class Table; + static float default_glyph_advance(const void* face_ptr, gr_uint16 glyphid); + + Face(const void* appFaceHandle/*non-NULL*/, const gr_face_ops & ops); + virtual ~Face(); + + virtual bool runGraphite(Segment *seg, const Silf *silf) const; + +public: + bool readGlyphs(uint32 faceOptions); + bool readGraphite(const Table & silf); + bool readFeatures(); + void takeFileFace(FileFace* pFileFace/*takes ownership*/); + + const SillMap & theSill() const; + const GlyphCache & glyphs() const; + Cmap & cmap() const; + NameTable * nameTable() const; + void setLogger(FILE *log_file); + json * logger() const throw(); + + const Silf * chooseSilf(uint32 script) const; + uint16 languageForLocale(const char * locale) const; + + // Features + uint16 numFeatures() const; + const FeatureRef * featureById(uint32 id) const; + const FeatureRef * feature(uint16 index) const; + + // Glyph related + int32 getGlyphMetric(uint16 gid, uint8 metric) const; + uint16 findPseudo(uint32 uid) const; + + // Errors + unsigned int error() const { return m_error; } + bool error(Error e) { m_error = e.error(); return false; } + unsigned int error_context() const { return m_error; } + void error_context(unsigned int errcntxt) { m_errcntxt = errcntxt; } + + CLASS_NEW_DELETE; +private: + SillMap m_Sill; + gr_face_ops m_ops; + const void * m_appFaceHandle; // non-NULL + FileFace * m_pFileFace; //owned + mutable GlyphCache * m_pGlyphFaceCache; // owned - never NULL + mutable Cmap * m_cmap; // cmap cache if available + mutable NameTable * m_pNames; + mutable json * m_logger; + unsigned int m_error; + unsigned int m_errcntxt; +protected: + Silf * m_silfs; // silf subtables. + uint16 m_numSilf; // num silf subtables in the silf table +private: + uint16 m_ascent, + m_descent; +#ifdef GRAPHITE2_TELEMETRY +public: + mutable telemetry tele; +#endif +}; + + + +inline +const SillMap & Face::theSill() const +{ + return m_Sill; +} + +inline +uint16 Face::numFeatures() const +{ + return m_Sill.theFeatureMap().numFeats(); +} + +inline +const FeatureRef * Face::featureById(uint32 id) const +{ + return m_Sill.theFeatureMap().findFeatureRef(id); +} + +inline +const FeatureRef *Face::feature(uint16 index) const +{ + return m_Sill.theFeatureMap().feature(index); +} + +inline +const GlyphCache & Face::glyphs() const +{ + return *m_pGlyphFaceCache; +} + +inline +Cmap & Face::cmap() const +{ + return *m_cmap; +}; + +inline +json * Face::logger() const throw() +{ + return m_logger; +} + + + +class Face::Table +{ + const Face * _f; + mutable const byte * _p; + size_t _sz; + bool _compressed; + + Error decompress(); + + void release(); + +public: + Table() throw(); + Table(const Face & face, const Tag n, uint32 version=0xffffffff) throw(); + ~Table() throw(); + Table(const Table && rhs) throw(); + + operator const byte * () const throw(); + + size_t size() const throw(); + Table & operator = (const Table && rhs) throw(); +}; + +inline +Face::Table::Table() throw() +: _f(0), _p(0), _sz(0), _compressed(false) +{ +} + +inline +Face::Table::Table(const Table && rhs) throw() +: _f(rhs._f), _p(rhs._p), _sz(rhs._sz), _compressed(rhs._compressed) +{ + rhs._p = 0; +} + +inline +Face::Table::~Table() throw() +{ + release(); +} + +inline +Face::Table::operator const byte * () const throw() +{ + return _p; +} + +inline +size_t Face::Table::size() const throw() +{ + return _sz; +} + +} // namespace graphite2 + +struct gr_face : public graphite2::Face {}; diff --git a/gfx/graphite2/src/inc/FeatureMap.h b/gfx/graphite2/src/inc/FeatureMap.h new file mode 100644 index 0000000000..0f05e941a2 --- /dev/null +++ b/gfx/graphite2/src/inc/FeatureMap.h @@ -0,0 +1,198 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include "inc/Main.h" +#include "inc/FeatureVal.h" + +namespace graphite2 { + +// Forward declarations for implmentation types +class FeatureMap; +class Face; + + +class FeatureSetting +{ +public: + FeatureSetting(int16 theValue, uint16 labelId) : m_label(labelId), m_value(theValue) {}; + uint16 label() const { return m_label; } + int16 value() const { return m_value; } + + CLASS_NEW_DELETE; +private: + FeatureSetting(const FeatureSetting & fs) : m_label(fs.m_label), m_value(fs.m_value) {}; + + uint16 m_label; + int16 m_value; +}; + +class FeatureRef +{ + typedef uint32 chunk_t; + static const uint8 SIZEOF_CHUNK = sizeof(chunk_t)*8; + +public: + enum flags_t : uint16 { + HIDDEN = 0x0800 + }; + FeatureRef() throw(); + FeatureRef(const Face & face, unsigned short & bits_offset, uint32 max_val, + uint32 name, uint16 uiName, flags_t flags, + FeatureSetting *settings, uint16 num_set) throw(); + ~FeatureRef() throw(); + + bool applyValToFeature(uint32 val, Features& pDest) const; //defined in GrFaceImp.h + void maskFeature(Features & pDest) const { + if (m_index < pDest.size()) //defensive + pDest[m_index] |= m_mask; + } + + uint32 getFeatureVal(const Features& feats) const; //defined in GrFaceImp.h + + uint32 getId() const { return m_id; } + uint16 getNameId() const { return m_nameid; } + uint16 getNumSettings() const { return m_numSet; } + uint16 getSettingName(uint16 index) const { return m_nameValues[index].label(); } + int16 getSettingValue(uint16 index) const { return m_nameValues[index].value(); } + flags_t getFlags() const { return m_flags; } + uint32 maxVal() const { return m_max; } + const Face & getFace() const { assert(m_face); return *m_face;} + const FeatureMap* getFeatureMap() const;// { return m_pFace;} + + CLASS_NEW_DELETE; +private: + FeatureRef(const FeatureRef & rhs); + + const Face * m_face; + FeatureSetting * m_nameValues; // array of name table ids for feature values + chunk_t m_mask, // bit mask to get the value from the vector + m_max; // max value the value can take + uint32 m_id; // feature identifier/name + uint16 m_nameid, // Name table id for feature name + m_numSet; // number of values (number of entries in m_nameValues) + flags_t m_flags; // feature flags see FeatureRef::flags_t. + byte m_bits, // how many bits to shift the value into place + m_index; // index into the array to find the ulong to mask + +private: //unimplemented + FeatureRef& operator=(const FeatureRef&); +}; + +inline +FeatureRef::FeatureRef() throw() +: m_face(0), + m_nameValues(0), + m_mask(0), m_max(0), + m_id(0), m_nameid(0), m_numSet(0), + m_flags(flags_t(0)), + m_bits(0), m_index(0) +{ +} + + +class NameAndFeatureRef +{ + public: + NameAndFeatureRef(uint32 name = 0) : m_name(name) , m_pFRef(NULL){} + NameAndFeatureRef(FeatureRef const & p) : m_name(p.getId()), m_pFRef(&p) {} + + bool operator<(const NameAndFeatureRef& rhs) const //orders by m_name + { return m_name<rhs.m_name; } + + CLASS_NEW_DELETE + + uint32 m_name; + const FeatureRef* m_pFRef; +}; + +class FeatureMap +{ +public: + FeatureMap() : m_numFeats(0), m_feats(NULL), m_pNamedFeats(NULL) {} + ~FeatureMap() { delete[] m_feats; delete[] m_pNamedFeats; } + + bool readFeats(const Face & face); + const FeatureRef *findFeatureRef(uint32 name) const; + FeatureRef *feature(uint16 index) const { return m_feats + index; } + //GrFeatureRef *featureRef(byte index) { return index < m_numFeats ? m_feats + index : NULL; } + const FeatureRef *featureRef(byte index) const { return index < m_numFeats ? m_feats + index : NULL; } + FeatureVal* cloneFeatures(uint32 langname/*0 means default*/) const; //call destroy_Features when done. + uint16 numFeats() const { return m_numFeats; }; + CLASS_NEW_DELETE +private: +friend class SillMap; + uint16 m_numFeats; + + FeatureRef *m_feats; + NameAndFeatureRef* m_pNamedFeats; //owned + FeatureVal m_defaultFeatures; //owned + +private: //defensive on m_feats, m_pNamedFeats, and m_defaultFeatures + FeatureMap(const FeatureMap&); + FeatureMap& operator=(const FeatureMap&); +}; + + +class SillMap +{ +private: + class LangFeaturePair + { + LangFeaturePair(const LangFeaturePair &); + LangFeaturePair & operator = (const LangFeaturePair &); + + public: + LangFeaturePair() : m_lang(0), m_pFeatures(0) {} + ~LangFeaturePair() { delete m_pFeatures; } + + uint32 m_lang; + Features* m_pFeatures; //owns + CLASS_NEW_DELETE + }; +public: + SillMap() : m_langFeats(NULL), m_numLanguages(0) {} + ~SillMap() { delete[] m_langFeats; } + bool readFace(const Face & face); + bool readSill(const Face & face); + FeatureVal* cloneFeatures(uint32 langname/*0 means default*/) const; //call destroy_Features when done. + uint16 numLanguages() const { return m_numLanguages; }; + uint32 getLangName(uint16 index) const { return (index < m_numLanguages)? m_langFeats[index].m_lang : 0; }; + + const FeatureMap & theFeatureMap() const { return m_FeatureMap; }; +private: + FeatureMap m_FeatureMap; //of face + LangFeaturePair * m_langFeats; + uint16 m_numLanguages; + +private: //defensive on m_langFeats + SillMap(const SillMap&); + SillMap& operator=(const SillMap&); +}; + +} // namespace graphite2 + +struct gr_feature_ref : public graphite2::FeatureRef {}; diff --git a/gfx/graphite2/src/inc/FeatureVal.h b/gfx/graphite2/src/inc/FeatureVal.h new file mode 100644 index 0000000000..cd3f93b2b5 --- /dev/null +++ b/gfx/graphite2/src/inc/FeatureVal.h @@ -0,0 +1,68 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include <cstring> +#include <cassert> +#include "inc/Main.h" +#include "inc/List.h" + +namespace graphite2 { + +class FeatureRef; +class FeatureMap; + +class FeatureVal : public Vector<uint32> +{ +public: + FeatureVal() : m_pMap(0) { } + FeatureVal(int num, const FeatureMap & pMap) : Vector<uint32>(num), m_pMap(&pMap) {} + FeatureVal(const FeatureVal & rhs) : Vector<uint32>(rhs), m_pMap(rhs.m_pMap) {} + + FeatureVal & operator = (const FeatureVal & rhs) { Vector<uint32>::operator = (rhs); m_pMap = rhs.m_pMap; return *this; } + + bool operator ==(const FeatureVal & b) const + { + size_t n = size(); + if (n != b.size()) return false; + + for(const_iterator l = begin(), r = b.begin(); n && *l == *r; --n, ++l, ++r); + + return n == 0; + } + + CLASS_NEW_DELETE +private: + friend class FeatureRef; //so that FeatureRefs can manipulate m_vec directly + const FeatureMap* m_pMap; +}; + +typedef FeatureVal Features; + +} // namespace graphite2 + + +struct gr_feature_val : public graphite2::FeatureVal {}; diff --git a/gfx/graphite2/src/inc/FileFace.h b/gfx/graphite2/src/inc/FileFace.h new file mode 100644 index 0000000000..35927847f8 --- /dev/null +++ b/gfx/graphite2/src/inc/FileFace.h @@ -0,0 +1,80 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +//#include "inc/FeatureMap.h" +//#include "inc/GlyphsCache.h" +//#include "inc/Silf.h" + +#ifndef GRAPHITE2_NFILEFACE + +#include <cstdio> +#include <cassert> + +#include "graphite2/Font.h" + +#include "inc/Main.h" +#include "inc/TtfTypes.h" +#include "inc/TtfUtil.h" + +namespace graphite2 { + + +class FileFace +{ + static const void * get_table_fn(const void* appFaceHandle, unsigned int name, size_t *len); + static void rel_table_fn(const void* appFaceHandle, const void *table_buffer); + +public: + static const gr_face_ops ops; + + FileFace(const char *filename); + ~FileFace(); + + operator bool () const throw(); + CLASS_NEW_DELETE; + +private: //defensive + FILE * _file; + size_t _file_len; + + TtfUtil::Sfnt::OffsetSubTable * _header_tbl; + TtfUtil::Sfnt::OffsetSubTable::Entry * _table_dir; + + FileFace(const FileFace&); + FileFace& operator=(const FileFace&); +}; + +inline +FileFace::operator bool() const throw() +{ + return _file && _header_tbl && _table_dir; +} + +} // namespace graphite2 + +#endif //!GRAPHITE2_NFILEFACE diff --git a/gfx/graphite2/src/inc/Font.h b/gfx/graphite2/src/inc/Font.h new file mode 100644 index 0000000000..9bc9ffb510 --- /dev/null +++ b/gfx/graphite2/src/inc/Font.h @@ -0,0 +1,90 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include <cassert> +#include "graphite2/Font.h" +#include "inc/Main.h" +#include "inc/Face.h" + +namespace graphite2 { + +#define INVALID_ADVANCE -1e38f // can't be a static const because non-integral + +class Font +{ +public: + Font(float ppm, const Face & face, const void * appFontHandle=0, const gr_font_ops * ops=0); + virtual ~Font(); + + float advance(unsigned short glyphid) const; + float scale() const; + bool isHinted() const; + const Face & face() const; + operator bool () const throw() { return m_advances; } + + CLASS_NEW_DELETE; +private: + gr_font_ops m_ops; + const void * const m_appFontHandle; + float * m_advances; // One advance per glyph in pixels. Nan if not defined + const Face & m_face; + float m_scale; // scales from design units to ppm + bool m_hinted; + + Font(const Font&); + Font& operator=(const Font&); +}; + +inline +float Font::advance(unsigned short glyphid) const +{ + if (m_advances[glyphid] == INVALID_ADVANCE) + m_advances[glyphid] = (*m_ops.glyph_advance_x)(m_appFontHandle, glyphid); + return m_advances[glyphid]; +} + +inline +float Font::scale() const +{ + return m_scale; +} + +inline +bool Font::isHinted() const +{ + return m_hinted; +} + +inline +const Face & Font::face() const +{ + return m_face; +} + +} // namespace graphite2 + +struct gr_font : public graphite2::Font {}; diff --git a/gfx/graphite2/src/inc/GlyphCache.h b/gfx/graphite2/src/inc/GlyphCache.h new file mode 100644 index 0000000000..7d5324e522 --- /dev/null +++ b/gfx/graphite2/src/inc/GlyphCache.h @@ -0,0 +1,223 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + + +#include "graphite2/Font.h" +#include "inc/Main.h" +#include "inc/Position.h" +#include "inc/GlyphFace.h" + +namespace graphite2 { + +class Face; +class FeatureVal; +class Segment; + + +struct SlantBox +{ + static const SlantBox empty; + +// SlantBox(float psi = 0., float pdi = 0., float psa = 0., float pda = 0.) : si(psi), di(pdi), sa(psa), da(pda) {}; + float width() const { return sa - si; } + float height() const { return da - di; } + float si; // min + float di; // min + float sa; // max + float da; // max +}; + + +struct BBox +{ + BBox(float pxi = 0, float pyi = 0., float pxa = 0., float pya = 0.) : xi(pxi), yi(pyi), xa(pxa), ya(pya) {}; + float width() const { return xa - xi; } + float height() const { return ya - yi; } + float xi; // min + float yi; // min + float xa; // max + float ya; // max +}; + + +class GlyphBox +{ + GlyphBox(const GlyphBox &); + GlyphBox & operator = (const GlyphBox &); + +public: + GlyphBox(uint8 numsubs, unsigned short bitmap, Rect *slanted) : _num(numsubs), _bitmap(bitmap), _slant(*slanted) {}; + + void addSubBox(int subindex, int boundary, Rect *val) { _subs[subindex * 2 + boundary] = *val; } + Rect &subVal(int subindex, int boundary) { return _subs[subindex * 2 + boundary]; } + const Rect &slant() const { return _slant; } + uint8 num() const { return _num; } + const Rect *subs() const { return _subs; } + +private: + uint8 _num; + unsigned short _bitmap; + Rect _slant; + Rect _subs[1]; +}; + +class GlyphCache +{ + class Loader; + + GlyphCache(const GlyphCache&); + GlyphCache& operator=(const GlyphCache&); + +public: + GlyphCache(const Face & face, const uint32 face_options); + ~GlyphCache(); + + unsigned short numGlyphs() const throw(); + unsigned short numAttrs() const throw(); + unsigned short unitsPerEm() const throw(); + + const GlyphFace *glyph(unsigned short glyphid) const; //result may be changed by subsequent call with a different glyphid + const GlyphFace *glyphSafe(unsigned short glyphid) const; + float getBoundingMetric(unsigned short glyphid, uint8 metric) const; + uint8 numSubBounds(unsigned short glyphid) const; + float getSubBoundingMetric(unsigned short glyphid, uint8 subindex, uint8 metric) const; + const Rect & slant(unsigned short glyphid) const { return _boxes[glyphid] ? _boxes[glyphid]->slant() : _empty_slant_box; } + const SlantBox & getBoundingSlantBox(unsigned short glyphid) const; + const BBox & getBoundingBBox(unsigned short glyphid) const; + const SlantBox & getSubBoundingSlantBox(unsigned short glyphid, uint8 subindex) const; + const BBox & getSubBoundingBBox(unsigned short glyphid, uint8 subindex) const; + bool check(unsigned short glyphid) const; + bool hasBoxes() const { return _boxes != 0; } + + CLASS_NEW_DELETE; + +private: + const Rect _empty_slant_box; + const Loader * _glyph_loader; + const GlyphFace * * _glyphs; + GlyphBox * * _boxes; + unsigned short _num_glyphs, + _num_attrs, + _upem; +}; + +inline +unsigned short GlyphCache::numGlyphs() const throw() +{ + return _num_glyphs; +} + +inline +unsigned short GlyphCache::numAttrs() const throw() +{ + return _num_attrs; +} + +inline +unsigned short GlyphCache::unitsPerEm() const throw() +{ + return _upem; +} + +inline +bool GlyphCache::check(unsigned short glyphid) const +{ + return _boxes && glyphid < _num_glyphs; +} + +inline +const GlyphFace *GlyphCache::glyphSafe(unsigned short glyphid) const +{ + return glyphid < _num_glyphs ? glyph(glyphid) : NULL; +} + +inline +float GlyphCache::getBoundingMetric(unsigned short glyphid, uint8 metric) const +{ + if (glyphid >= _num_glyphs) return 0.; + switch (metric) { + case 0: return (float)(glyph(glyphid)->theBBox().bl.x); // x_min + case 1: return (float)(glyph(glyphid)->theBBox().bl.y); // y_min + case 2: return (float)(glyph(glyphid)->theBBox().tr.x); // x_max + case 3: return (float)(glyph(glyphid)->theBBox().tr.y); // y_max + case 4: return (float)(_boxes[glyphid] ? _boxes[glyphid]->slant().bl.x : 0.f); // sum_min + case 5: return (float)(_boxes[glyphid] ? _boxes[glyphid]->slant().bl.y : 0.f); // diff_min + case 6: return (float)(_boxes[glyphid] ? _boxes[glyphid]->slant().tr.x : 0.f); // sum_max + case 7: return (float)(_boxes[glyphid] ? _boxes[glyphid]->slant().tr.y : 0.f); // diff_max + default: return 0.; + } +} + +inline const SlantBox &GlyphCache::getBoundingSlantBox(unsigned short glyphid) const +{ + return _boxes[glyphid] ? *(SlantBox *)(&(_boxes[glyphid]->slant())) : SlantBox::empty; +} + +inline const BBox &GlyphCache::getBoundingBBox(unsigned short glyphid) const +{ + return *(BBox *)(&(glyph(glyphid)->theBBox())); +} + +inline +float GlyphCache::getSubBoundingMetric(unsigned short glyphid, uint8 subindex, uint8 metric) const +{ + GlyphBox *b = _boxes[glyphid]; + if (b == NULL || subindex >= b->num()) return 0; + + switch (metric) { + case 0: return b->subVal(subindex, 0).bl.x; + case 1: return b->subVal(subindex, 0).bl.y; + case 2: return b->subVal(subindex, 0).tr.x; + case 3: return b->subVal(subindex, 0).tr.y; + case 4: return b->subVal(subindex, 1).bl.x; + case 5: return b->subVal(subindex, 1).bl.y; + case 6: return b->subVal(subindex, 1).tr.x; + case 7: return b->subVal(subindex, 1).tr.y; + default: return 0.; + } +} + +inline const SlantBox &GlyphCache::getSubBoundingSlantBox(unsigned short glyphid, uint8 subindex) const +{ + GlyphBox *b = _boxes[glyphid]; + return *(SlantBox *)(b->subs() + 2 * subindex + 1); +} + +inline const BBox &GlyphCache::getSubBoundingBBox(unsigned short glyphid, uint8 subindex) const +{ + GlyphBox *b = _boxes[glyphid]; + return *(BBox *)(b->subs() + 2 * subindex); +} + +inline +uint8 GlyphCache::numSubBounds(unsigned short glyphid) const +{ + return _boxes[glyphid] ? _boxes[glyphid]->num() : 0; +} + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/GlyphFace.h b/gfx/graphite2/src/inc/GlyphFace.h new file mode 100644 index 0000000000..fc29056146 --- /dev/null +++ b/gfx/graphite2/src/inc/GlyphFace.h @@ -0,0 +1,83 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "inc/Main.h" +#include "inc/Position.h" +#include "inc/Sparse.h" + +namespace graphite2 { + +enum metrics { + kgmetLsb = 0, kgmetRsb, + kgmetBbTop, kgmetBbBottom, kgmetBbLeft, kgmetBbRight, + kgmetBbHeight, kgmetBbWidth, + kgmetAdvWidth, kgmetAdvHeight, + kgmetAscent, kgmetDescent +}; + + +class GlyphFace +{ +public: + GlyphFace(); + template<typename I> + GlyphFace(const Rect & bbox, const Position & adv, I first, const I last); + + const Position & theAdvance() const; + const Rect & theBBox() const { return m_bbox; } + const sparse & attrs() const { return m_attrs; } + int32 getMetric(uint8 metric) const; + + CLASS_NEW_DELETE; +private: + Rect m_bbox; // bounding box metrics in design units + Position m_advance; // Advance width and height in design units + sparse m_attrs; +}; + + +// Inlines: class GlyphFace +// +inline +GlyphFace::GlyphFace() +{} + +template<typename I> +GlyphFace::GlyphFace(const Rect & bbox, const Position & adv, I first, const I last) +: m_bbox(bbox), + m_advance(adv), + m_attrs(first, last) +{ +} + +inline +const Position & GlyphFace::theAdvance() const { + return m_advance; +} + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Intervals.h b/gfx/graphite2/src/inc/Intervals.h new file mode 100644 index 0000000000..81d23187b6 --- /dev/null +++ b/gfx/graphite2/src/inc/Intervals.h @@ -0,0 +1,234 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <utility> + +#include "inc/Main.h" +#include "inc/List.h" +#include "inc/json.h" +#include "inc/Position.h" + +// An IntervalSet represents the possible movement of a given glyph in a given direction +// (horizontally, vertically, or diagonally). +// A vector is needed to represent disjoint ranges, eg, -300..-150, 20..200, 500..750. +// Each pair represents the min/max of a sub-range. + +namespace graphite2 { + +class Segment; + +enum zones_t {SD, XY}; + +class Zones +{ + struct Exclusion + { + template<zones_t O> + static Exclusion weighted(float xmin, float xmax, float f, float a0, + float m, float xi, float ai, float c, bool nega); + + float x, // x position + xm, // xmax position + c, // constant + sum(MiXi^2) + sm, // sum(Mi) + smx; // sum(MiXi) + bool open; + + Exclusion(float x, float w, float smi, float smxi, float c); + Exclusion & operator += (Exclusion const & rhs); + uint8 outcode(float p) const; + + Exclusion split_at(float p); + void left_trim(float p); + + bool track_cost(float & cost, float & x, float origin) const; + + private: + float test_position(float origin) const; + float cost(float x) const; + }; + + typedef Vector<Exclusion> exclusions; + + typedef exclusions::iterator iterator; + typedef Exclusion * pointer; + typedef Exclusion & reference; + typedef std::reverse_iterator<iterator> reverse_iterator; + +public: + typedef exclusions::const_iterator const_iterator; + typedef Exclusion const * const_pointer; + typedef Exclusion const & const_reference; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + +#if !defined GRAPHITE2_NTRACING + struct Debug + { + Exclusion _excl; + bool _isdel; + Vector<void *> _env; + + Debug(Exclusion *e, bool isdel, json *dbg) : _excl(*e), _isdel(isdel), _env(dbg->getenvs()) { }; + }; + + typedef Vector<Debug> debugs; + typedef debugs::const_iterator idebugs; + void addDebug(Exclusion *e); + void removeDebug(float pos, float posm); + void setdebug(json *dbgout) { _dbg = dbgout; } + idebugs dbgs_begin() const { return _dbgs.begin(); } + idebugs dbgs_end() const { return _dbgs.end(); } + void jsonDbgOut(Segment *seg) const; + Position position() const { return Position(_pos, _posm); } +#endif + + Zones(); + template<zones_t O> + void initialise(float xmin, float xmax, float margin_len, float margin_weight, float ao); + + void exclude(float xmin, float xmax); + void exclude_with_margins(float xmin, float xmax, int axis); + + template<zones_t O> + void weighted(float xmin, float xmax, float f, float a0, float mi, float xi, float ai, float c, bool nega); + void weightedAxis(int axis, float xmin, float xmax, float f, float a0, float mi, float xi, float ai, float c, bool nega); + + float closest( float origin, float &cost) const; + + const_iterator begin() const { return _exclusions.begin(); } + const_iterator end() const { return _exclusions.end(); } + +private: + exclusions _exclusions; +#if !defined GRAPHITE2_NTRACING + json * _dbg; + debugs _dbgs; +#endif + float _margin_len, + _margin_weight, + _pos, + _posm; + + void insert(Exclusion e); + void remove(float x, float xm); + const_iterator find_exclusion_under(float x) const; +}; + + +inline +Zones::Zones() +: _margin_len(0), _margin_weight(0), _pos(0), _posm(0) +{ +#if !defined GRAPHITE2_NTRACING + _dbg = 0; +#endif + _exclusions.reserve(8); +} + +inline +Zones::Exclusion::Exclusion(float x_, float xm_, float smi, float smxi, float c_) +: x(x_), xm(xm_), c(c_), sm(smi), smx(smxi), open(false) +{ } + +template<zones_t O> +inline +void Zones::initialise(float xmin, float xmax, float margin_len, + float margin_weight, float a0) +{ + _margin_len = margin_len; + _margin_weight = margin_weight; + _pos = xmin; + _posm = xmax; + _exclusions.clear(); + _exclusions.push_back(Exclusion::weighted<O>(xmin, xmax, 1, a0, 0, 0, 0, 0, false)); + _exclusions.front().open = true; +#if !defined GRAPHITE2_NTRACING + _dbgs.clear(); +#endif +} + +inline +void Zones::exclude(float xmin, float xmax) { + remove(xmin, xmax); +} + +template<zones_t O> +inline +void Zones::weighted(float xmin, float xmax, float f, float a0, + float m, float xi, float ai, float c, bool nega) { + insert(Exclusion::weighted<O>(xmin, xmax, f, a0, m, xi, ai, c, nega)); +} + +inline +void Zones::weightedAxis(int axis, float xmin, float xmax, float f, float a0, + float m, float xi, float ai, float c, bool nega) { + if (axis < 2) + weighted<XY>(xmin, xmax, f, a0, m, xi, ai, c, nega); + else + weighted<SD>(xmin, xmax, f, a0, m, xi, ai, c, nega); +} + +#if !defined GRAPHITE2_NTRACING +inline +void Zones::addDebug(Exclusion *e) { + if (_dbg) + _dbgs.push_back(Debug(e, false, _dbg)); +} + +inline +void Zones::removeDebug(float pos, float posm) { + if (_dbg) + { + Exclusion e(pos, posm, 0, 0, 0); + _dbgs.push_back(Debug(&e, true, _dbg)); + } +} +#endif + +template<> +inline +Zones::Exclusion Zones::Exclusion::weighted<XY>(float xmin, float xmax, float f, float a0, + float m, float xi, GR_MAYBE_UNUSED float ai, float c, GR_MAYBE_UNUSED bool nega) { + return Exclusion(xmin, xmax, + m + f, + m * xi, + m * xi * xi + f * a0 * a0 + c); +} + +template<> +inline +Zones::Exclusion Zones::Exclusion::weighted<SD>(float xmin, float xmax, float f, float a0, + float m, float xi, float ai,float c, bool nega) { + float xia = nega ? xi - ai : xi + ai; + return Exclusion(xmin, xmax, + 0.25f * (m + 2.f * f), + 0.25f * m * xia, + 0.25f * (m * xia * xia + 2.f * f * a0 * a0) + c); +} + +} // end of namespace graphite2 diff --git a/gfx/graphite2/src/inc/List.h b/gfx/graphite2/src/inc/List.h new file mode 100644 index 0000000000..a3b7a77961 --- /dev/null +++ b/gfx/graphite2/src/inc/List.h @@ -0,0 +1,168 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +// designed to have a limited subset of the std::vector api +#pragma once + +#include <cstddef> +#include <cassert> +#include <cstring> +#include <cstdlib> +#include <new> + +#include "Main.h" + +namespace graphite2 { + +template <typename T> +inline +ptrdiff_t distance(T* first, T* last) { return last-first; } + + +template <typename T> +class Vector +{ + T * m_first, *m_last, *m_end; +public: + typedef T & reference; + typedef const T & const_reference; + typedef T * iterator; + typedef const T * const_iterator; + + Vector() : m_first(0), m_last(0), m_end(0) {} + Vector(size_t n, const T& value = T()) : m_first(0), m_last(0), m_end(0) { insert(begin(), n, value); } + Vector(const Vector<T> &rhs) : m_first(0), m_last(0), m_end(0) { insert(begin(), rhs.begin(), rhs.end()); } + template <typename I> + Vector(I first, const I last) : m_first(0), m_last(0), m_end(0) { insert(begin(), first, last); } + ~Vector() { clear(); free(m_first); } + + iterator begin() { return m_first; } + const_iterator begin() const { return m_first; } + + iterator end() { return m_last; } + const_iterator end() const { return m_last; } + + bool empty() const { return m_first == m_last; } + size_t size() const { return m_last - m_first; } + size_t capacity() const{ return m_end - m_first; } + + void reserve(size_t n); + void resize(size_t n, const T & v = T()); + + reference front() { assert(size() > 0); return *begin(); } + const_reference front() const { assert(size() > 0); return *begin(); } + reference back() { assert(size() > 0); return *(end()-1); } + const_reference back() const { assert(size() > 0); return *(end()-1); } + + Vector<T> & operator = (const Vector<T> & rhs) { assign(rhs.begin(), rhs.end()); return *this; } + reference operator [] (size_t n) { assert(size() > n); return m_first[n]; } + const_reference operator [] (size_t n) const { assert(size() > n); return m_first[n]; } + + void assign(size_t n, const T& u) { clear(); insert(begin(), n, u); } + void assign(const_iterator first, const_iterator last) { clear(); insert(begin(), first, last); } + iterator insert(iterator p, const T & x) { p = _insert_default(p, 1); new (p) T(x); return p; } + void insert(iterator p, size_t n, const T & x); + void insert(iterator p, const_iterator first, const_iterator last); + void pop_back() { assert(size() > 0); --m_last; } + void push_back(const T &v) { if (m_last == m_end) reserve(size()+1); new (m_last++) T(v); } + + void clear() { erase(begin(), end()); } + iterator erase(iterator p) { return erase(p, p+1); } + iterator erase(iterator first, iterator last); + +private: + iterator _insert_default(iterator p, size_t n); +}; + +template <typename T> +inline +void Vector<T>::reserve(size_t n) +{ + if (n > capacity()) + { + const ptrdiff_t sz = size(); + size_t requested; + if (checked_mul(n,sizeof(T), requested)) std::abort(); + m_first = static_cast<T*>(realloc(m_first, requested)); + if (!m_first) std::abort(); + m_last = m_first + sz; + m_end = m_first + n; + } +} + +template <typename T> +inline +void Vector<T>::resize(size_t n, const T & v) { + const ptrdiff_t d = n-size(); + if (d < 0) erase(end()+d, end()); + else if (d > 0) insert(end(), d, v); +} + +template<typename T> +inline +typename Vector<T>::iterator Vector<T>::_insert_default(iterator p, size_t n) +{ + assert(begin() <= p && p <= end()); + const ptrdiff_t i = p - begin(); + reserve(((size() + n + 7) >> 3) << 3); + p = begin() + i; + // Move tail if there is one + if (p != end()) memmove(p + n, p, distance(p,end())*sizeof(T)); + m_last += n; + return p; +} + +template<typename T> +inline +void Vector<T>::insert(iterator p, size_t n, const T & x) +{ + p = _insert_default(p, n); + // Copy in elements + for (; n; --n, ++p) { new (p) T(x); } +} + +template<typename T> +inline +void Vector<T>::insert(iterator p, const_iterator first, const_iterator last) +{ + p = _insert_default(p, distance(first, last)); + // Copy in elements + for (;first != last; ++first, ++p) { new (p) T(*first); } +} + +template<typename T> +inline +typename Vector<T>::iterator Vector<T>::erase(iterator first, iterator last) +{ + for (iterator e = first; e != last; ++e) e->~T(); + const size_t sz = distance(first, last); + if (m_last != last) memmove(first, last, distance(last,end())*sizeof(T)); + m_last -= sz; + return first; +} + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Machine.h b/gfx/graphite2/src/inc/Machine.h new file mode 100644 index 0000000000..b23819fb98 --- /dev/null +++ b/gfx/graphite2/src/inc/Machine.h @@ -0,0 +1,207 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This general interpreter interface. +// Author: Tim Eves + +// Build one of direct_machine.cpp or call_machine.cpp to implement this +// interface. + +#pragma once +#include <cstring> +#include <limits> +#include <graphite2/Types.h> +#include "inc/Main.h" + +#if defined(__GNUC__) +#if defined(__clang__) || (__GNUC__ * 100 + __GNUC_MINOR__ * 10) < 430 +#define HOT +#if defined(__x86_64) +#define REGPARM(n) __attribute__((regparm(n))) +#else +#define REGPARM(n) +#endif +#else +#define HOT __attribute__((hot)) +#if defined(__x86_64) +#define REGPARM(n) __attribute__((hot, regparm(n))) +#else +#define REGPARM(n) +#endif +#endif +#else +#define HOT +#define REGPARM(n) +#endif + +#if defined(__MINGW32__) +// MinGW's <limits> at some point includes winnt.h which #define's a +// DELETE macro, which conflicts with enum opcode below, so we undefine +// it here. +#undef DELETE +#endif + +namespace graphite2 { + +// Forward declarations +class Segment; +class Slot; +class SlotMap; + + +namespace vm +{ + + +typedef void * instr; +typedef Slot * slotref; + +enum {VARARGS = 0xff, MAX_NAME_LEN=32}; + +enum opcode { + NOP = 0, + + PUSH_BYTE, PUSH_BYTEU, PUSH_SHORT, PUSH_SHORTU, PUSH_LONG, + + ADD, SUB, MUL, DIV, + MIN_, MAX_, + NEG, + TRUNC8, TRUNC16, + + COND, + + AND, OR, NOT, + EQUAL, NOT_EQ, + LESS, GTR, LESS_EQ, GTR_EQ, + + NEXT, NEXT_N, COPY_NEXT, + PUT_GLYPH_8BIT_OBS, PUT_SUBS_8BIT_OBS, PUT_COPY, + INSERT, DELETE, + ASSOC, + CNTXT_ITEM, + + ATTR_SET, ATTR_ADD, ATTR_SUB, + ATTR_SET_SLOT, + IATTR_SET_SLOT, + PUSH_SLOT_ATTR, PUSH_GLYPH_ATTR_OBS, + PUSH_GLYPH_METRIC, PUSH_FEAT, + PUSH_ATT_TO_GATTR_OBS, PUSH_ATT_TO_GLYPH_METRIC, + PUSH_ISLOT_ATTR, + + PUSH_IGLYPH_ATTR, // not implemented + + POP_RET, RET_ZERO, RET_TRUE, + IATTR_SET, IATTR_ADD, IATTR_SUB, + PUSH_PROC_STATE, PUSH_VERSION, + PUT_SUBS, PUT_SUBS2, PUT_SUBS3, + PUT_GLYPH, PUSH_GLYPH_ATTR, PUSH_ATT_TO_GLYPH_ATTR, + BITOR, BITAND, BITNOT, + BITSET, SET_FEAT, + MAX_OPCODE, + // private opcodes for internal use only, comes after all other on disk opcodes + TEMP_COPY = MAX_OPCODE +}; + +struct opcode_t +{ + instr impl[2]; + uint8 param_sz; + char name[MAX_NAME_LEN]; +}; + + +class Machine +{ +public: + typedef int32 stack_t; + static size_t const STACK_ORDER = 10, + STACK_MAX = 1 << STACK_ORDER, + STACK_GUARD = 2; + + class Code; + + enum status_t { + finished = 0, + stack_underflow, + stack_not_empty, + stack_overflow, + slot_offset_out_bounds, + died_early + }; + + Machine(SlotMap &) throw(); + static const opcode_t * getOpcodeTable() throw(); + + CLASS_NEW_DELETE; + + SlotMap & slotMap() const throw(); + status_t status() const throw(); +// operator bool () const throw(); + +private: + void check_final_stack(const stack_t * const sp); + stack_t run(const instr * program, const byte * data, + slotref * & map) HOT; + + SlotMap & _map; + stack_t _stack[STACK_MAX + 2*STACK_GUARD]; + status_t _status; +}; + +inline Machine::Machine(SlotMap & map) throw() +: _map(map), _status(finished) +{ + // Initialise stack guard +1 entries as the stack pointer points to the + // current top of stack, hence the first push will never write entry 0. + // Initialising the guard space like this is unnecessary and is only + // done to keep valgrind happy during fuzz testing. Hopefully loop + // unrolling will flatten this. + for (size_t n = STACK_GUARD + 1; n; --n) _stack[n-1] = 0; +} + +inline SlotMap& Machine::slotMap() const throw() +{ + return _map; +} + +inline Machine::status_t Machine::status() const throw() +{ + return _status; +} + +inline void Machine::check_final_stack(const stack_t * const sp) +{ + if (_status != finished) return; + + stack_t const * const base = _stack + STACK_GUARD, + * const limit = base + STACK_MAX; + if (sp < base) _status = stack_underflow; // This should be impossible now. + else if (sp >= limit) _status = stack_overflow; // So should this. + else if (sp != base) _status = stack_not_empty; +} + +} // namespace vm +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Main.h b/gfx/graphite2/src/inc/Main.h new file mode 100644 index 0000000000..ebf02dd553 --- /dev/null +++ b/gfx/graphite2/src/inc/Main.h @@ -0,0 +1,199 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <cstdlib> +#include "graphite2/Types.h" + +#ifdef GRAPHITE2_CUSTOM_HEADER +#include GRAPHITE2_CUSTOM_HEADER +#endif + +namespace graphite2 { + +typedef gr_uint8 uint8; +typedef gr_uint8 byte; +typedef gr_uint16 uint16; +typedef gr_uint32 uint32; +typedef gr_int8 int8; +typedef gr_int16 int16; +typedef gr_int32 int32; +typedef size_t uintptr; + +#ifdef GRAPHITE2_TELEMETRY +struct telemetry +{ + class category; + + static size_t * _category; + static void set_category(size_t & t) throw() { _category = &t; } + static void stop() throw() { _category = 0; } + static void count_bytes(size_t n) throw() { if (_category) *_category += n; } + + size_t misc, + silf, + glyph, + code, + states, + starts, + transitions; + + telemetry() : misc(0), silf(0), glyph(0), code(0), states(0), starts(0), transitions(0) {} +}; + +class telemetry::category +{ + size_t * _prev; +public: + category(size_t & t) : _prev(_category) { _category = &t; } + ~category() { _category = _prev; } +}; + +#else +struct telemetry {}; +#endif + +// Checked multiplaction to catch overflow or underflow when allocating memory +#if defined(__has_builtin) + #if __has_builtin(__builtin_mul_overflow) + #define HAVE_BUILTIN_OVERFLOW + #endif +#elif defined(__GNUC__) && (__GNUC__ >= 5) && !defined(__INTEL_COMPILER) + #define HAVE_BUILTIN_OVERFLOW +#endif +#if defined(__has_include) + #if __has_include(<intsafe.h>) && !defined(__CYGWIN__) + #define HAVE_INTSAFE_H + #endif +#elif defined(_WIN32) + #define HAVE_INTSAFE_H +#endif + +// Need to import intsafe into the top level namespace +#if defined(HAVE_INTSAFE_H) +} // namespace graphite2 + +#include <intsafe.h> + +namespace graphite2 { +#endif + +#if defined(HAVE_BUILTIN_OVERFLOW) +inline +bool checked_mul(const size_t a, const size_t b, size_t & t) { + return __builtin_mul_overflow(a, b, &t); +} +#elif defined(HAVE_INTSAFE_H) +inline +bool checked_mul(const size_t a, const size_t b, size_t & t) { + return SizeTMult(a, b, &t) == INTSAFE_E_ARITHMETIC_OVERFLOW; +} +#else +inline +bool checked_mul(const size_t a, const size_t b, size_t & t) { + t = a*b; + return (((a | b) & (~size_t(0) << (sizeof(size_t) << 2))) && (t / a != b)); +} +#endif + +// typesafe wrapper around malloc for simple types +// use free(pointer) to deallocate + +template <typename T> T * gralloc(size_t n) +{ + size_t total; + if (checked_mul(n, sizeof(T), total)) + return 0; +#ifdef GRAPHITE2_TELEMETRY + telemetry::count_bytes(total); +#endif + return static_cast<T*>(malloc(total)); +} + +template <typename T> T * grzeroalloc(size_t n) +{ +#ifdef GRAPHITE2_TELEMETRY + telemetry::count_bytes(sizeof(T) * n); +#endif + return static_cast<T*>(calloc(n, sizeof(T))); +} + +template <typename T> +inline T min(const T a, const T b) +{ + return a < b ? a : b; +} + +template <typename T> +inline T max(const T a, const T b) +{ + return a > b ? a : b; +} + +} // namespace graphite2 + +#define CLASS_NEW_DELETE \ + void * operator new (size_t size){ return gralloc<byte>(size);} \ + void * operator new (size_t, void * p) throw() { return p; } \ + void * operator new[] (size_t size) {return gralloc<byte>(size);} \ + void * operator new[] (size_t, void * p) throw() { return p; } \ + void operator delete (void * p) throw() { free(p);} \ + void operator delete (void *, void *) throw() {} \ + void operator delete[] (void * p)throw() { free(p); } \ + void operator delete[] (void *, void *) throw() {} + +#if defined(__GNUC__) || defined(__clang__) +#define GR_MAYBE_UNUSED __attribute__((unused)) +#else +#define GR_MAYBE_UNUSED +#endif + +#ifndef __has_cpp_attribute +# define __has_cpp_attribute(x) 0 +#endif + +#if __has_cpp_attribute(clang::fallthrough) +# define GR_FALLTHROUGH [[clang::fallthrough]] +#elif __has_cpp_attribute(gnu::fallthrough) +# define GR_FALLTHROUGH [[gnu::fallthrough]] +#elif defined(_MSC_VER) + /* + * MSVC's __fallthrough annotations are checked by /analyze (Code Analysis): + * https://msdn.microsoft.com/en-us/library/ms235402%28VS.80%29.aspx + */ + #include <sal.h> + #define GR_FALLTHROUGH __fallthrough +#elif __GNUC__ >= 7 + #define GR_FALLTHROUGH __attribute__ ((fallthrough)) +#else + #define GR_FALLTHROUGH /* fallthrough */ +#endif + +#ifdef _MSC_VER +#pragma warning(disable: 4800) +#pragma warning(disable: 4355) +#endif diff --git a/gfx/graphite2/src/inc/NameTable.h b/gfx/graphite2/src/inc/NameTable.h new file mode 100644 index 0000000000..0fdbeb4d85 --- /dev/null +++ b/gfx/graphite2/src/inc/NameTable.h @@ -0,0 +1,65 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <graphite2/Segment.h> +#include "inc/TtfTypes.h" +#include "inc/locale2lcid.h" + +namespace graphite2 { + +class NameTable +{ + NameTable(const NameTable &); + NameTable & operator = (const NameTable &); + +public: + NameTable(const void * data, size_t length, uint16 platfromId=3, uint16 encodingID = 1); + ~NameTable() { free(const_cast<TtfUtil::Sfnt::FontNames *>(m_table)); } + enum eNameFallback { + eNoFallback = 0, + eEnUSFallbackOnly = 1, + eEnOrAnyFallback = 2 + }; + uint16 setPlatformEncoding(uint16 platfromId=3, uint16 encodingID = 1); + void * getName(uint16 & languageId, uint16 nameId, gr_encform enc, uint32 & length); + uint16 getLanguageId(const char * bcp47Locale); + + CLASS_NEW_DELETE +private: + uint16 m_platformId; + uint16 m_encodingId; + uint16 m_languageCount; + uint16 m_platformOffset; // offset of first NameRecord with for platform 3, encoding 1 + uint16 m_platformLastRecord; + uint16 m_nameDataLength; + const TtfUtil::Sfnt::FontNames * m_table; + const uint8 * m_nameData; + Locale2Lang m_locale2Lang; +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Pass.h b/gfx/graphite2/src/inc/Pass.h new file mode 100644 index 0000000000..e687a87d8c --- /dev/null +++ b/gfx/graphite2/src/inc/Pass.h @@ -0,0 +1,118 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <cstdlib> +#include "inc/Code.h" + +namespace graphite2 { + +class Segment; +class Face; +class Silf; +struct Rule; +struct RuleEntry; +struct State; +class FiniteStateMachine; +class Error; +class ShiftCollider; +class KernCollider; +class json; + +enum passtype; + +class Pass +{ +public: + Pass(); + ~Pass(); + + bool readPass(const byte * pPass, size_t pass_length, size_t subtable_base, Face & face, + enum passtype pt, uint32 version, Error &e); + bool runGraphite(vm::Machine & m, FiniteStateMachine & fsm, bool reverse) const; + void init(Silf *silf) { m_silf = silf; } + byte collisionLoops() const { return m_numCollRuns; } + bool reverseDir() const { return m_isReverseDir; } + + CLASS_NEW_DELETE +private: + void findNDoRule(Slot* & iSlot, vm::Machine &, FiniteStateMachine& fsm) const; + int doAction(const vm::Machine::Code* codeptr, Slot * & slot_out, vm::Machine &) const; + bool testPassConstraint(vm::Machine & m) const; + bool testConstraint(const Rule & r, vm::Machine &) const; + bool readRules(const byte * rule_map, const size_t num_entries, + const byte *precontext, const uint16 * sort_key, + const uint16 * o_constraint, const byte *constraint_data, + const uint16 * o_action, const byte * action_data, + Face &, enum passtype pt, Error &e); + bool readStates(const byte * starts, const byte * states, const byte * o_rule_map, Face &, Error &e); + bool readRanges(const byte * ranges, size_t num_ranges, Error &e); + uint16 glyphToCol(const uint16 gid) const; + bool runFSM(FiniteStateMachine & fsm, Slot * slot) const; + void dumpRuleEventConsidered(const FiniteStateMachine & fsm, const RuleEntry & re) const; + void dumpRuleEventOutput(const FiniteStateMachine & fsm, const Rule & r, Slot * os) const; + void adjustSlot(int delta, Slot * & slot_out, SlotMap &) const; + bool collisionShift(Segment *seg, int dir, json * const dbgout) const; + bool collisionKern(Segment *seg, int dir, json * const dbgout) const; + bool collisionFinish(Segment *seg, GR_MAYBE_UNUSED json * const dbgout) const; + bool resolveCollisions(Segment *seg, Slot *slot, Slot *start, ShiftCollider &coll, bool isRev, + int dir, bool &moved, bool &hasCol, json * const dbgout) const; + float resolveKern(Segment *seg, Slot *slot, Slot *start, int dir, + float &ymin, float &ymax, json *const dbgout) const; + + const Silf * m_silf; + uint16 * m_cols; + Rule * m_rules; // rules + RuleEntry * m_ruleMap; + uint16 * m_startStates; // prectxt length + uint16 * m_transitions; + State * m_states; + vm::Machine::Code * m_codes; + byte * m_progs; + + byte m_numCollRuns; + byte m_kernColls; + byte m_iMaxLoop; + uint16 m_numGlyphs; + uint16 m_numRules; + uint16 m_numStates; + uint16 m_numTransition; + uint16 m_numSuccess; + uint16 m_successStart; + uint16 m_numColumns; + byte m_minPreCtxt; + byte m_maxPreCtxt; + byte m_colThreshold; + bool m_isReverseDir; + vm::Machine::Code m_cPConstraint; + +private: //defensive + Pass(const Pass&); + Pass& operator=(const Pass&); +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Position.h b/gfx/graphite2/src/inc/Position.h new file mode 100644 index 0000000000..510e4f4c41 --- /dev/null +++ b/gfx/graphite2/src/inc/Position.h @@ -0,0 +1,68 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +namespace graphite2 { + +class Position +{ +public: + Position() : x(0), y(0) { } + Position(const float inx, const float iny) : x(inx), y(iny) {} + Position operator + (const Position& a) const { return Position(x + a.x, y + a.y); } + Position operator - (const Position& a) const { return Position(x - a.x, y - a.y); } + Position operator * (const float m) const { return Position(x * m, y * m); } + Position &operator += (const Position &a) { x += a.x; y += a.y; return *this; } + Position &operator *= (const float m) { x *= m; y *= m; return *this; } + + float x; + float y; +}; + +class Rect +{ +public : + Rect() {} + Rect(const Position& botLeft, const Position& topRight): bl(botLeft), tr(topRight) {} + Rect widen(const Rect& other) { return Rect(Position(bl.x > other.bl.x ? other.bl.x : bl.x, bl.y > other.bl.y ? other.bl.y : bl.y), Position(tr.x > other.tr.x ? tr.x : other.tr.x, tr.y > other.tr.y ? tr.y : other.tr.y)); } + Rect operator + (const Position &a) const { return Rect(Position(bl.x + a.x, bl.y + a.y), Position(tr.x + a.x, tr.y + a.y)); } + Rect operator - (const Position &a) const { return Rect(Position(bl.x - a.x, bl.y - a.y), Position(tr.x - a.x, tr.y - a.y)); } + Rect operator * (float m) const { return Rect(Position(bl.x, bl.y) * m, Position(tr.x, tr.y) * m); } + float width() const { return tr.x - bl.x; } + float height() const { return tr.y - bl.y; } + + bool hitTest(Rect &other); + + // returns Position(overlapx, overlapy) where overlap<0 if overlapping else positive) + Position overlap(Position &offset, Rect &other, Position &otherOffset); + //Position constrainedAvoid(Position &offset, Rect &box, Rect &sdbox, Position &other, Rect &obox, Rect &osdbox); + + Position bl; + Position tr; +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Rule.h b/gfx/graphite2/src/inc/Rule.h new file mode 100644 index 0000000000..5964e003a6 --- /dev/null +++ b/gfx/graphite2/src/inc/Rule.h @@ -0,0 +1,305 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ + +#pragma once + +#include "inc/Code.h" +#include "inc/Slot.h" + +namespace graphite2 { + +struct Rule { + const vm::Machine::Code * constraint, + * action; + unsigned short sort; + byte preContext; +#ifndef NDEBUG + uint16 rule_idx; +#endif + + Rule(); + ~Rule() {} + + CLASS_NEW_DELETE; + +private: + Rule(const Rule &); + Rule & operator = (const Rule &); +}; + +inline +Rule::Rule() +: constraint(0), + action(0), + sort(0), + preContext(0) +{ +#ifndef NDEBUG + rule_idx = 0; +#endif +} + + +struct RuleEntry +{ + const Rule * rule; + + inline + bool operator < (const RuleEntry &r) const + { + const unsigned short lsort = rule->sort, rsort = r.rule->sort; + return lsort > rsort || (lsort == rsort && rule < r.rule); + } + + inline + bool operator == (const RuleEntry &r) const + { + return rule == r.rule; + } +}; + + +struct State +{ + const RuleEntry * rules, + * rules_end; + + bool empty() const; +}; + +inline +bool State::empty() const +{ + return rules_end == rules; +} + + +class SlotMap +{ +public: + enum {MAX_SLOTS=64}; + SlotMap(Segment & seg, uint8 direction, size_t maxSize); + + Slot * * begin(); + Slot * * end(); + size_t size() const; + unsigned short context() const; + void reset(Slot &, unsigned short); + + Slot * const & operator[](int n) const; + Slot * & operator [] (int); + void pushSlot(Slot * const slot); + void collectGarbage(Slot *& aSlot); + + Slot * highwater() { return m_highwater; } + void highwater(Slot *s) { m_highwater = s; m_highpassed = false; } + bool highpassed() const { return m_highpassed; } + void highpassed(bool v) { m_highpassed = v; } + + uint8 dir() const { return m_dir; } + int decMax() { return --m_maxSize; } + + Segment & segment; +private: + Slot * m_slot_map[MAX_SLOTS+1]; + unsigned short m_size; + unsigned short m_precontext; + Slot * m_highwater; + int m_maxSize; + uint8 m_dir; + bool m_highpassed; +}; + + +class FiniteStateMachine +{ +public: + enum {MAX_RULES=128}; + +private: + class Rules + { + public: + Rules(); + void clear(); + const RuleEntry * begin() const; + const RuleEntry * end() const; + size_t size() const; + + void accumulate_rules(const State &state); + + private: + RuleEntry * m_begin, + * m_end, + m_rules[MAX_RULES*2]; + }; + +public: + FiniteStateMachine(SlotMap & map, json * logger); + void reset(Slot * & slot, const short unsigned int max_pre_ctxt); + + Rules rules; + SlotMap & slots; + json * const dbgout; +}; + + +inline +FiniteStateMachine::FiniteStateMachine(SlotMap& map, json * logger) +: slots(map), + dbgout(logger) +{ +} + +inline +void FiniteStateMachine::reset(Slot * & slot, const short unsigned int max_pre_ctxt) +{ + rules.clear(); + int ctxt = 0; + for (; ctxt != max_pre_ctxt && slot->prev(); ++ctxt, slot = slot->prev()); + slots.reset(*slot, ctxt); +} + +inline +FiniteStateMachine::Rules::Rules() + : m_begin(m_rules), m_end(m_rules) +{ +} + +inline +void FiniteStateMachine::Rules::clear() +{ + m_end = m_begin; +} + +inline +const RuleEntry * FiniteStateMachine::Rules::begin() const +{ + return m_begin; +} + +inline +const RuleEntry * FiniteStateMachine::Rules::end() const +{ + return m_end; +} + +inline +size_t FiniteStateMachine::Rules::size() const +{ + return m_end - m_begin; +} + +inline +void FiniteStateMachine::Rules::accumulate_rules(const State &state) +{ + // Only bother if there are rules in the State object. + if (state.empty()) return; + + // Merge the new sorted rules list into the current sorted result set. + const RuleEntry * lre = begin(), * rre = state.rules; + RuleEntry * out = m_rules + (m_begin == m_rules)*MAX_RULES; + const RuleEntry * const lrend = out + MAX_RULES, + * const rrend = state.rules_end; + m_begin = out; + while (lre != end() && out != lrend) + { + if (*lre < *rre) *out++ = *lre++; + else if (*rre < *lre) { *out++ = *rre++; } + else { *out++ = *lre++; ++rre; } + + if (rre == rrend) + { + while (lre != end() && out != lrend) { *out++ = *lre++; } + m_end = out; + return; + } + } + while (rre != rrend && out != lrend) { *out++ = *rre++; } + m_end = out; +} + +inline +SlotMap::SlotMap(Segment & seg, uint8 direction, size_t maxSize) +: segment(seg), m_size(0), m_precontext(0), m_highwater(0), + m_maxSize(int(maxSize)), m_dir(direction), m_highpassed(false) +{ + m_slot_map[0] = 0; +} + +inline +Slot * * SlotMap::begin() +{ + return &m_slot_map[1]; // allow map to go 1 before slot_map when inserting + // at start of segment. +} + +inline +Slot * * SlotMap::end() +{ + return m_slot_map + m_size + 1; +} + +inline +size_t SlotMap::size() const +{ + return m_size; +} + +inline +short unsigned int SlotMap::context() const +{ + return m_precontext; +} + +inline +void SlotMap::reset(Slot & slot, short unsigned int ctxt) +{ + m_size = 0; + m_precontext = ctxt; + *m_slot_map = slot.prev(); +} + +inline +void SlotMap::pushSlot(Slot*const slot) +{ + m_slot_map[++m_size] = slot; +} + +inline +Slot * const & SlotMap::operator[](int n) const +{ + return m_slot_map[n + 1]; +} + +inline +Slot * & SlotMap::operator[](int n) +{ + return m_slot_map[n + 1]; +} + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Segment.h b/gfx/graphite2/src/inc/Segment.h new file mode 100644 index 0000000000..6cf83408d4 --- /dev/null +++ b/gfx/graphite2/src/inc/Segment.h @@ -0,0 +1,236 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "inc/Main.h" + +#include <cassert> + +#include "inc/CharInfo.h" +#include "inc/Face.h" +#include "inc/FeatureVal.h" +#include "inc/GlyphCache.h" +#include "inc/GlyphFace.h" +#include "inc/Slot.h" +#include "inc/Position.h" +#include "inc/List.h" +#include "inc/Collider.h" + +#define MAX_SEG_GROWTH_FACTOR 64 + +namespace graphite2 { + +typedef Vector<Features> FeatureList; +typedef Vector<Slot *> SlotRope; +typedef Vector<int16 *> AttributeRope; +typedef Vector<SlotJustify *> JustifyRope; + +class Font; +class Segment; +class Silf; + +enum SpliceParam { +/** sub-Segments longer than this are not cached + * (in Unicode code points) */ + eMaxSpliceSize = 96 +}; + +enum justFlags { + gr_justStartInline = 1, + gr_justEndInline = 2 +}; + +class SegmentScopeState +{ +private: + friend class Segment; + Slot * realFirstSlot; + Slot * slotBeforeScope; + Slot * slotAfterScope; + Slot * realLastSlot; + size_t numGlyphsOutsideScope; +}; + +class Segment +{ + // Prevent copying of any kind. + Segment(const Segment&); + Segment& operator=(const Segment&); + +public: + + enum { + SEG_INITCOLLISIONS = 1, + SEG_HASCOLLISIONS = 2 + }; + + size_t slotCount() const { return m_numGlyphs; } //one slot per glyph + void extendLength(ptrdiff_t num) { m_numGlyphs += num; } + Position advance() const { return m_advance; } + bool runGraphite() { if (m_silf) return m_face->runGraphite(this, m_silf); else return true;}; + void chooseSilf(uint32 script) { m_silf = m_face->chooseSilf(script); } + const Silf *silf() const { return m_silf; } + size_t charInfoCount() const { return m_numCharinfo; } + const CharInfo *charinfo(unsigned int index) const { return index < m_numCharinfo ? m_charinfo + index : NULL; } + CharInfo *charinfo(unsigned int index) { return index < m_numCharinfo ? m_charinfo + index : NULL; } + + Segment(size_t numchars, const Face* face, uint32 script, int dir); + ~Segment(); + uint8 flags() const { return m_flags; } + void flags(uint8 f) { m_flags = f; } + Slot *first() { return m_first; } + void first(Slot *p) { m_first = p; } + Slot *last() { return m_last; } + void last(Slot *p) { m_last = p; } + void appendSlot(int i, int cid, int gid, int fid, size_t coffset); + Slot *newSlot(); + void freeSlot(Slot *); + SlotJustify *newJustify(); + void freeJustify(SlotJustify *aJustify); + Position positionSlots(const Font *font=0, Slot *first=0, Slot *last=0, bool isRtl = false, bool isFinal = true); + void associateChars(int offset, size_t num); + void linkClusters(Slot *first, Slot *last); + uint16 getClassGlyph(uint16 cid, uint16 offset) const { return m_silf->getClassGlyph(cid, offset); } + uint16 findClassIndex(uint16 cid, uint16 gid) const { return m_silf->findClassIndex(cid, gid); } + int addFeatures(const Features& feats) { m_feats.push_back(feats); return int(m_feats.size()) - 1; } + uint32 getFeature(int index, uint8 findex) const { const FeatureRef* pFR=m_face->theSill().theFeatureMap().featureRef(findex); if (!pFR) return 0; else return pFR->getFeatureVal(m_feats[index]); } + void setFeature(int index, uint8 findex, uint32 val) { + const FeatureRef* pFR=m_face->theSill().theFeatureMap().featureRef(findex); + if (pFR) + { + if (val > pFR->maxVal()) val = pFR->maxVal(); + pFR->applyValToFeature(val, m_feats[index]); + } } + int8 dir() const { return m_dir; } + void dir(int8 val) { m_dir = val; } + bool currdir() const { return ((m_dir >> 6) ^ m_dir) & 1; } + uint8 passBits() const { return m_passBits; } + void mergePassBits(const uint8 val) { m_passBits &= val; } + int16 glyphAttr(uint16 gid, uint16 gattr) const { const GlyphFace * p = m_face->glyphs().glyphSafe(gid); return p ? p->attrs()[gattr] : 0; } + int32 getGlyphMetric(Slot *iSlot, uint8 metric, uint8 attrLevel, bool rtl) const; + float glyphAdvance(uint16 gid) const { return m_face->glyphs().glyph(gid)->theAdvance().x; } + const Rect &theGlyphBBoxTemporary(uint16 gid) const { return m_face->glyphs().glyph(gid)->theBBox(); } //warning value may become invalid when another glyph is accessed + Slot *findRoot(Slot *is) const { return is->attachedTo() ? findRoot(is->attachedTo()) : is; } + int numAttrs() const { return m_silf->numUser(); } + int defaultOriginal() const { return m_defaultOriginal; } + const Face * getFace() const { return m_face; } + const Features & getFeatures(unsigned int /*charIndex*/) { assert(m_feats.size() == 1); return m_feats[0]; } + void bidiPass(int paradir, uint8 aMirror); + int8 getSlotBidiClass(Slot *s) const; + void doMirror(uint16 aMirror); + Slot *addLineEnd(Slot *nSlot); + void delLineEnd(Slot *s); + bool hasJustification() const { return m_justifies.size() != 0; } + void reverseSlots(); + + bool isWhitespace(const int cid) const; + bool hasCollisionInfo() const { return (m_flags & SEG_HASCOLLISIONS) && m_collisions; } + SlotCollision *collisionInfo(const Slot *s) const { return m_collisions ? m_collisions + s->index() : 0; } + CLASS_NEW_DELETE + +public: //only used by: GrSegment* makeAndInitialize(const GrFont *font, const GrFace *face, uint32 script, const FeaturesHandle& pFeats/*must not be IsNull*/, encform enc, const void* pStart, size_t nChars, int dir); + bool read_text(const Face *face, const Features* pFeats/*must not be NULL*/, gr_encform enc, const void*pStart, size_t nChars); + void finalise(const Font *font, bool reverse=false); + float justify(Slot *pSlot, const Font *font, float width, enum justFlags flags, Slot *pFirst, Slot *pLast); + bool initCollisions(); + +private: + Position m_advance; // whole segment advance + SlotRope m_slots; // Vector of slot buffers + AttributeRope m_userAttrs; // Vector of userAttrs buffers + JustifyRope m_justifies; // Slot justification info buffers + FeatureList m_feats; // feature settings referenced by charinfos in this segment + Slot * m_freeSlots; // linked list of free slots + SlotJustify * m_freeJustifies; // Slot justification blocks free list + CharInfo * m_charinfo; // character info, one per input character + SlotCollision * m_collisions; + const Face * m_face; // GrFace + const Silf * m_silf; + Slot * m_first; // first slot in segment + Slot * m_last; // last slot in segment + size_t m_bufSize, // how big a buffer to create when need more slots + m_numGlyphs, + m_numCharinfo; // size of the array and number of input characters + int m_defaultOriginal; // number of whitespace chars in the string + int8 m_dir; + uint8 m_flags, // General purpose flags + m_passBits; // if bit set then skip pass +}; + +inline +int8 Segment::getSlotBidiClass(Slot *s) const +{ + int8 res = s->getBidiClass(); + if (res != -1) return res; + res = int8(glyphAttr(s->gid(), m_silf->aBidi())); + s->setBidiClass(res); + return res; +} + +inline +void Segment::finalise(const Font *font, bool reverse) +{ + if (!m_first || !m_last) return; + + m_advance = positionSlots(font, m_first, m_last, m_silf->dir(), true); + //associateChars(0, m_numCharinfo); + if (reverse && currdir() != (m_dir & 1)) + reverseSlots(); + linkClusters(m_first, m_last); +} + +inline +int32 Segment::getGlyphMetric(Slot *iSlot, uint8 metric, uint8 attrLevel, bool rtl) const { + if (attrLevel > 0) + { + Slot *is = findRoot(iSlot); + return is->clusterMetric(this, metric, attrLevel, rtl); + } + else + return m_face->getGlyphMetric(iSlot->gid(), metric); +} + +inline +bool Segment::isWhitespace(const int cid) const +{ + return ((cid >= 0x0009) * (cid <= 0x000D) + + (cid == 0x0020) + + (cid == 0x0085) + + (cid == 0x00A0) + + (cid == 0x1680) + + (cid == 0x180E) + + (cid >= 0x2000) * (cid <= 0x200A) + + (cid == 0x2028) + + (cid == 0x2029) + + (cid == 0x202F) + + (cid == 0x205F) + + (cid == 0x3000)) != 0; +} + +} // namespace graphite2 + +struct gr_segment : public graphite2::Segment {}; diff --git a/gfx/graphite2/src/inc/Silf.h b/gfx/graphite2/src/inc/Silf.h new file mode 100644 index 0000000000..edc0c3a16d --- /dev/null +++ b/gfx/graphite2/src/inc/Silf.h @@ -0,0 +1,128 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "graphite2/Font.h" +#include "inc/Main.h" +#include "inc/Pass.h" + +namespace graphite2 { + +class Face; +class Segment; +class FeatureVal; +class VMScratch; +class Error; + +class Pseudo +{ +public: + uint32 uid; + uint32 gid; + CLASS_NEW_DELETE; +}; + +class Justinfo +{ +public: + Justinfo(uint8 stretch, uint8 shrink, uint8 step, uint8 weight) : + m_astretch(stretch), m_ashrink(shrink), m_astep(step), + m_aweight(weight) {}; + uint8 attrStretch() const { return m_astretch; } + uint8 attrShrink() const { return m_ashrink; } + uint8 attrStep() const { return m_astep; } + uint8 attrWeight() const { return m_aweight; } + +private: + uint8 m_astretch; + uint8 m_ashrink; + uint8 m_astep; + uint8 m_aweight; +}; + +class Silf +{ + // Prevent copying + Silf(const Silf&); + Silf& operator=(const Silf&); + +public: + Silf() throw(); + ~Silf() throw(); + + bool readGraphite(const byte * const pSilf, size_t lSilf, Face &face, uint32 version); + bool runGraphite(Segment *seg, uint8 firstPass=0, uint8 lastPass=0, int dobidi = 0) const; + uint16 findClassIndex(uint16 cid, uint16 gid) const; + uint16 getClassGlyph(uint16 cid, unsigned int index) const; + uint16 findPseudo(uint32 uid) const; + uint8 numUser() const { return m_aUser; } + uint8 aPseudo() const { return m_aPseudo; } + uint8 aBreak() const { return m_aBreak; } + uint8 aMirror() const {return m_aMirror; } + uint8 aPassBits() const { return m_aPassBits; } + uint8 aBidi() const { return m_aBidi; } + uint8 aCollision() const { return m_aCollision; } + uint8 substitutionPass() const { return m_sPass; } + uint8 positionPass() const { return m_pPass; } + uint8 justificationPass() const { return m_jPass; } + uint8 bidiPass() const { return m_bPass; } + uint8 numPasses() const { return m_numPasses; } + uint8 maxCompPerLig() const { return m_iMaxComp; } + uint16 numClasses() const { return m_nClass; } + byte flags() const { return m_flags; } + byte dir() const { return m_dir; } + uint8 numJustLevels() const { return m_numJusts; } + Justinfo *justAttrs() const { return m_justs; } + uint16 endLineGlyphid() const { return m_gEndLine; } + const gr_faceinfo *silfInfo() const { return &m_silfinfo; } + + CLASS_NEW_DELETE; + +private: + size_t readClassMap(const byte *p, size_t data_len, uint32 version, Error &e); + template<typename T> inline uint32 readClassOffsets(const byte *&p, size_t data_len, Error &e); + + Pass * m_passes; + Pseudo * m_pseudos; + uint32 * m_classOffsets; + uint16 * m_classData; + Justinfo * m_justs; + uint8 m_numPasses; + uint8 m_numJusts; + uint8 m_sPass, m_pPass, m_jPass, m_bPass, + m_flags, m_dir; + + uint8 m_aPseudo, m_aBreak, m_aUser, m_aBidi, m_aMirror, m_aPassBits, + m_iMaxComp, m_aCollision; + uint16 m_aLig, m_numPseudo, m_nClass, m_nLinear, + m_gEndLine; + gr_faceinfo m_silfinfo; + + void releaseBuffers() throw(); +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/Slot.h b/gfx/graphite2/src/inc/Slot.h new file mode 100644 index 0000000000..df39d9a3bb --- /dev/null +++ b/gfx/graphite2/src/inc/Slot.h @@ -0,0 +1,170 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include "graphite2/Types.h" +#include "graphite2/Segment.h" +#include "inc/Main.h" +#include "inc/Font.h" +#include "inc/Position.h" + +namespace graphite2 { + +typedef gr_attrCode attrCode; + +class GlyphFace; +class Segment; + +struct SlotJustify +{ + static const int NUMJUSTPARAMS = 5; + + SlotJustify(const SlotJustify &); + SlotJustify & operator = (const SlotJustify &); + +public: + static size_t size_of(size_t levels) { return sizeof(SlotJustify) + ((levels > 1 ? levels : 1)*NUMJUSTPARAMS - 1)*sizeof(int16); } + + void LoadSlot(const Slot *s, const Segment *seg); + + SlotJustify *next; + int16 values[1]; +}; + +class Slot +{ + enum Flag + { + DELETED = 1, + INSERTED = 2, + COPIED = 4, + POSITIONED = 8, + ATTACHED = 16 + }; + +public: + struct iterator; + + unsigned short gid() const { return m_glyphid; } + Position origin() const { return m_position; } + float advance() const { return m_advance.x; } + void advance(Position &val) { m_advance = val; } + Position advancePos() const { return m_advance; } + int before() const { return m_before; } + int after() const { return m_after; } + uint32 index() const { return m_index; } + void index(uint32 val) { m_index = val; } + + Slot(int16 *m_userAttr = NULL); + void set(const Slot & slot, int charOffset, size_t numUserAttr, size_t justLevels, size_t numChars); + Slot *next() const { return m_next; } + void next(Slot *s) { m_next = s; } + Slot *prev() const { return m_prev; } + void prev(Slot *s) { m_prev = s; } + uint16 glyph() const { return m_realglyphid ? m_realglyphid : m_glyphid; } + void setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph = NULL); + void setRealGid(uint16 realGid) { m_realglyphid = realGid; } + void adjKern(const Position &pos) { m_shift = m_shift + pos; m_advance = m_advance + pos; } + void origin(const Position &pos) { m_position = pos + m_shift; } + void originate(int ind) { m_original = ind; } + int original() const { return m_original; } + void before(int ind) { m_before = ind; } + void after(int ind) { m_after = ind; } + bool isBase() const { return (!m_parent); } + void update(int numSlots, int numCharInfo, Position &relpos); + Position finalise(const Segment* seg, const Font* font, Position & base, Rect & bbox, uint8 attrLevel, float & clusterMin, bool rtl, bool isFinal, int depth = 0); + bool isDeleted() const { return (m_flags & DELETED) ? true : false; } + void markDeleted(bool state) { if (state) m_flags |= DELETED; else m_flags &= ~DELETED; } + bool isCopied() const { return (m_flags & COPIED) ? true : false; } + void markCopied(bool state) { if (state) m_flags |= COPIED; else m_flags &= ~COPIED; } + bool isPositioned() const { return (m_flags & POSITIONED) ? true : false; } + void markPositioned(bool state) { if (state) m_flags |= POSITIONED; else m_flags &= ~POSITIONED; } + bool isInsertBefore() const { return !(m_flags & INSERTED); } + uint8 getBidiLevel() const { return m_bidiLevel; } + void setBidiLevel(uint8 level) { m_bidiLevel = level; } + int8 getBidiClass(const Segment *seg); + int8 getBidiClass() const { return m_bidiCls; } + void setBidiClass(int8 cls) { m_bidiCls = cls; } + int16 *userAttrs() const { return m_userAttr; } + void userAttrs(int16 *p) { m_userAttr = p; } + void markInsertBefore(bool state) { if (!state) m_flags |= INSERTED; else m_flags &= ~INSERTED; } + void setAttr(Segment* seg, attrCode ind, uint8 subindex, int16 val, const SlotMap & map); + int getAttr(const Segment *seg, attrCode ind, uint8 subindex) const; + int getJustify(const Segment *seg, uint8 level, uint8 subindex) const; + void setJustify(Segment *seg, uint8 level, uint8 subindex, int16 value); + bool isLocalJustify() const { return m_justs != NULL; }; + void attachTo(Slot *ap) { m_parent = ap; } + Slot *attachedTo() const { return m_parent; } + Position attachOffset() const { return m_attach - m_with; } + Slot* firstChild() const { return m_child; } + void firstChild(Slot *ap) { m_child = ap; } + bool child(Slot *ap); + Slot* nextSibling() const { return m_sibling; } + void nextSibling(Slot *ap) { m_sibling = ap; } + bool sibling(Slot *ap); + bool removeChild(Slot *ap); + int32 clusterMetric(const Segment* seg, uint8 metric, uint8 attrLevel, bool rtl); + void positionShift(Position a) { m_position += a; } + void floodShift(Position adj, int depth = 0); + float just() const { return m_just; } + void just(float j) { m_just = j; } + Slot *nextInCluster(const Slot *s) const; + bool isChildOf(const Slot *base) const; + + CLASS_NEW_DELETE + +private: + Slot *m_next; // linked list of slots + Slot *m_prev; + unsigned short m_glyphid; // glyph id + uint16 m_realglyphid; + uint32 m_original; // charinfo that originated this slot (e.g. for feature values) + uint32 m_before; // charinfo index of before association + uint32 m_after; // charinfo index of after association + uint32 m_index; // slot index given to this slot during finalising + Slot *m_parent; // index to parent we are attached to + Slot *m_child; // index to first child slot that attaches to us + Slot *m_sibling; // index to next child that attaches to our parent + Position m_position; // absolute position of glyph + Position m_shift; // .shift slot attribute + Position m_advance; // .advance slot attribute + Position m_attach; // attachment point on us + Position m_with; // attachment point position on parent + float m_just; // Justification inserted space + uint8 m_flags; // holds bit flags + byte m_attLevel; // attachment level + int8 m_bidiCls; // bidirectional class + byte m_bidiLevel; // bidirectional level + int16 *m_userAttr; // pointer to user attributes + SlotJustify *m_justs; // pointer to justification parameters + + friend class Segment; +}; + +} // namespace graphite2 + +struct gr_slot : public graphite2::Slot {}; diff --git a/gfx/graphite2/src/inc/Sparse.h b/gfx/graphite2/src/inc/Sparse.h new file mode 100644 index 0000000000..fcda890171 --- /dev/null +++ b/gfx/graphite2/src/inc/Sparse.h @@ -0,0 +1,168 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include <iterator> +#include <utility> + +#include "inc/Main.h" + +namespace graphite2 { + + +// A read-only packed fast sparse array of uint16 with uint16 keys. +// Like most container classes this has capacity and size properties and these +// refer to the number of stored entries and the number of addressable entries +// as normal. However due the sparse nature the capacity is always <= than the +// size. +class sparse +{ +public: + typedef uint16 key_type; + typedef uint16 mapped_type; + typedef std::pair<const key_type, mapped_type> value_type; + +private: + typedef unsigned long mask_t; + + static const unsigned char SIZEOF_CHUNK = (sizeof(mask_t) - sizeof(key_type))*8; + + struct chunk + { + mask_t mask:SIZEOF_CHUNK; + key_type offset; + }; + + static const chunk empty_chunk; + sparse(const sparse &); + sparse & operator = (const sparse &); + +public: + template<typename I> + sparse(I first, const I last); + sparse() throw(); + ~sparse() throw(); + + operator bool () const throw(); + mapped_type operator [] (const key_type k) const throw(); + + size_t capacity() const throw(); + size_t size() const throw(); + + size_t _sizeof() const throw(); + + CLASS_NEW_DELETE; + +private: + union { + chunk * map; + mapped_type * values; + } m_array; + key_type m_nchunks; +}; + + +inline +sparse::sparse() throw() : m_nchunks(0) +{ + m_array.map = const_cast<graphite2::sparse::chunk *>(&empty_chunk); +} + + +template <typename I> +sparse::sparse(I attr, const I last) +: m_nchunks(0) +{ + m_array.map = 0; + + // Find the maximum extent of the key space. + size_t n_values=0; + long lastkey = -1; + for (I i = attr; i != last; ++i, ++n_values) + { + const typename std::iterator_traits<I>::value_type v = *i; + if (v.second == 0) { --n_values; continue; } + if (v.first <= lastkey) { m_nchunks = 0; return; } + + lastkey = v.first; + const key_type k = v.first / SIZEOF_CHUNK; + if (k >= m_nchunks) m_nchunks = k+1; + } + if (m_nchunks == 0) + { + m_array.map=const_cast<graphite2::sparse::chunk *>(&empty_chunk); + return; + } + + m_array.values = grzeroalloc<mapped_type>((m_nchunks*sizeof(chunk) + sizeof(mapped_type)-1) + / sizeof(mapped_type) + + n_values); + + if (m_array.values == 0) + return; + + // coverity[forward_null : FALSE] Since m_array is union and m_array.values is not NULL + chunk * ci = m_array.map; + ci->offset = (m_nchunks*sizeof(chunk) + sizeof(mapped_type)-1)/sizeof(mapped_type); + mapped_type * vi = m_array.values + ci->offset; + for (; attr != last; ++attr, ++vi) + { + const typename std::iterator_traits<I>::value_type v = *attr; + if (v.second == 0) { --vi; continue; } + + chunk * const ci_ = m_array.map + v.first/SIZEOF_CHUNK; + + if (ci != ci_) + { + ci = ci_; + ci->offset = key_type(vi - m_array.values); + } + + ci->mask |= 1UL << (SIZEOF_CHUNK - 1 - (v.first % SIZEOF_CHUNK)); + *vi = v.second; + } +} + + +inline +sparse::operator bool () const throw() +{ + return m_array.map != 0; +} + +inline +size_t sparse::size() const throw() +{ + return m_nchunks*SIZEOF_CHUNK; +} + +inline +size_t sparse::_sizeof() const throw() +{ + return sizeof(sparse) + capacity()*sizeof(mapped_type) + m_nchunks*sizeof(chunk); +} + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/TtfTypes.h b/gfx/graphite2/src/inc/TtfTypes.h new file mode 100644 index 0000000000..ae67915304 --- /dev/null +++ b/gfx/graphite2/src/inc/TtfTypes.h @@ -0,0 +1,419 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +/*--------------------------------------------------------------------*//*:Ignore this sentence. + +File: TtfTypes.h +Responsibility: Tim Eves +Last reviewed: Not yet. + +Description: +Provides types required to represent the TTF basic types. +-------------------------------------------------------------------------------*//*:End Ignore*/ + + +//********************************************************************************************** +// Include files +//********************************************************************************************** +namespace graphite2 +{ +namespace TtfUtil +{ +//********************************************************************************************** +// Forward declarations +//********************************************************************************************** + + +//********************************************************************************************** +// Type declarations +//********************************************************************************************** +typedef unsigned char uint8; +typedef uint8 byte; +typedef signed char int8; +typedef unsigned short uint16; +typedef short int16; +typedef unsigned int uint32; +typedef int int32; + +typedef int16 short_frac; +typedef int32 fixed; +typedef int16 fword; +typedef uint16 ufword; +typedef int16 f2dot14; +typedef uint32 long_date_time[2]; + +//********************************************************************************************** +// Constants and enum types +//**********************************************************************************************/ +enum +{ + OneFix = 1<<16 +}; + +//********************************************************************************************** +// Table declarations +//********************************************************************************************** +namespace Sfnt +{ +#pragma pack(push,1) // We need this or the structure members aren't aligned + // correctly. Fortunately this form of pragma is supposed + // to be recognised by VS C++ too (at least according to + // MSDN). + + struct OffsetSubTable + { + uint32 scaler_type; + uint16 num_tables, + search_range, + entry_selector, + range_shift; + struct Entry + { + uint32 tag, + checksum, + offset, + length; + } table_directory[1]; + + enum ScalerType + { + TrueTypeMac = 0x74727565U, + TrueTypeWin = 0x00010000U, + Type1 = 0x74797031U + }; + }; + + + + + struct CharacterCodeMap + { + uint16 version, + num_subtables; + struct + { + uint16 platform_id, + platform_specific_id; + uint32 offset; + } encoding[1]; + }; + + struct CmapSubTable + { + uint16 format, + length, + language; + }; + + struct CmapSubTableFormat4 : CmapSubTable + { + uint16 seg_count_x2, + search_range, + entry_selector, + range_shift, + end_code[1]; + // There are arrarys after this which need their + // start positions calculated since end_code is + // seg_count uint16s long. + }; + + struct CmapSubTableFormat12 + { + fixed format; + uint32 length, + language, + num_groups; + struct + { + uint32 start_char_code, + end_char_code, + start_glyph_id; + } group[1]; + }; + + + + struct FontHeader + { + fixed version, + font_revision; + uint32 check_sum_adjustment, + magic_number; + uint16 flags, + units_per_em; + long_date_time created, + modified; + fword x_min, + y_min, + x_max, + y_max; + uint16 mac_style, + lowest_rec_ppem; + int16 font_direction_hint, + index_to_loc_format, + glyph_data_format; + enum + { + MagicNumber = 0x5F0F3CF5, + GlypDataFormat = 0 + }; + enum {ShortIndexLocFormat, LongIndexLocFormat}; + }; + + + + + struct PostScriptGlyphName + { + fixed format, + italic_angle; + fword underline_position, + underline_thickness; + uint32 is_fixed_pitch, + min_mem_type42, + max_mem_type42, + min_mem_type1, + max_mem_type1; + enum + { + Format1 = 0x10000, + Format2 = 0x20000, + Format25 = 0x28000, + Format3 = 0x30000, + Format4 = 0x40000 + }; + }; + + struct PostScriptGlyphName2 : PostScriptGlyphName + { + uint16 number_of_glyphs, + glyph_name_index[1]; + }; + + struct PostScriptGlyphName25 : PostScriptGlyphName + { + uint16 number_of_glyphs; + int8 offset[1]; + }; + + struct PostScriptGlyphName3 : PostScriptGlyphName {}; + + struct PostScriptGlyphName4 : PostScriptGlyphName + { + uint16 glyph_to_char_map[1]; + }; + + + struct HorizontalHeader + { + fixed version; + fword ascent, + descent, + line_gap; + ufword advance_width_max; + fword min_left_side_bearing, + max_left_side_bearing, + x_max_element; + int16 caret_slope_rise, + caret_slope_run; + fword caret_offset; + int16 reserved[4], + metric_data_format; + uint16 num_long_hor_metrics; + }; + + struct MaximumProfile + { + fixed version; + uint16 num_glyphs, + max_points, + max_contours, + max_component_points, + max_component_contours, + max_zones, + max_twilight_points, + max_storage, + max_function_defs, + max_instruction_defs, + max_stack_elements, + max_size_of_instructions, + max_component_elements, + max_component_depth; + }; + + + typedef byte Panose[10]; + + struct Compatibility0 + { + uint16 version; + int16 x_avg_char_width; + uint16 weight_class, + width_class; + int16 fs_type, + y_subscript_x_size, + y_subscript_y_size, + y_subscript_x_offset, + y_subscript_y_offset, + y_superscript_x_size, + y_superscript_y_size, + y_superscript_x_offset, + y_superscript_y_offset, + y_strikeout_size, + y_strikeout_position, + family_class; + Panose panose; + uint32 unicode_range[4]; + int8 ach_vend_id[4]; + uint16 fs_selection, + fs_first_char_index, + fs_last_char_index, // Acording to Apple's spec this is where v0 should end + typo_ascender, + typo_descender, + type_linegap, + win_ascent, + win_descent; + + enum + { + Italic =0x01, + Underscore=0x02, + Negative =0x04, + Outlined =0x08, + StrikeOut =0x10, + Bold =0x20 + }; + }; + + struct Compatibility1 : Compatibility0 + { + uint32 codepage_range[2]; + }; + + struct Compatibility2 : Compatibility1 + { + int16 x_height, + cap_height; + uint16 default_char, + break_char, + max_context; + }; + + struct Compatibility3 : Compatibility2 {}; + + typedef Compatibility3 Compatibility; + + + struct NameRecord + { + uint16 platform_id, + platform_specific_id, + language_id, + name_id, + length, + offset; + enum {Unicode, Mactintosh, Reserved, Microsoft}; + enum + { + Copyright, Family, Subfamily, UniqueSubfamily, + Fullname, Version, PostScript + }; + }; + + struct LangTagRecord + { + uint16 length, + offset; + }; + + struct FontNames + { + uint16 format, + count, + string_offset; + NameRecord name_record[1]; + }; + + + struct HorizontalMetric + { + uint16 advance_width; + int16 left_side_bearing; + }; + + + struct Glyph + { + int16 number_of_contours; + fword x_min, + y_min, + x_max, + y_max; + }; + + struct SimpleGlyph : Glyph + { + uint16 end_pts_of_contours[1]; + enum + { + OnCurve = 0x01, + XShort = 0x02, + YShort = 0x04, + Repeat = 0x08, + XIsSame = 0x10, + XIsPos = 0x10, + YIsSame = 0x20, + YIsPos = 0x20 + }; + }; + + struct CompoundGlyph : Glyph + { + uint16 flags, + glyph_index; + enum + { + Arg1Arg2Words = 0x01, + ArgsAreXYValues = 0x02, + RoundXYToGrid = 0x04, + HaveScale = 0x08, + MoreComponents = 0x20, + HaveXAndYScale = 0x40, + HaveTwoByTwo = 0x80, + HaveInstructions = 0x100, + UseMyMetrics = 0x200, + OverlapCompund = 0x400, + ScaledOffset = 0x800, + UnscaledOffset = 0x1000 + }; + }; + +#pragma pack(pop) +} // end of namespace Sfnt + +} // end of namespace TtfUtil +} // end of namespace graphite2 diff --git a/gfx/graphite2/src/inc/TtfUtil.h b/gfx/graphite2/src/inc/TtfUtil.h new file mode 100644 index 0000000000..3952bc06fb --- /dev/null +++ b/gfx/graphite2/src/inc/TtfUtil.h @@ -0,0 +1,208 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +/*--------------------------------------------------------------------*//*:Ignore this sentence. + +File: TtfUtil.h +Responsibility: Alan Ward +Last reviewed: Not yet. + +Description: + Utility class for handling TrueType font files. +----------------------------------------------------------------------------------------------*/ + + +#include <cstddef> + +namespace graphite2 +{ +namespace TtfUtil +{ + +#define OVERFLOW_OFFSET_CHECK(p, o) (o + reinterpret_cast<size_t>(p) < reinterpret_cast<size_t>(p)) + +typedef long fontTableId32; +typedef unsigned short gid16; + +#define TTF_TAG(a,b,c,d) ((a << 24UL) + (b << 16UL) + (c << 8UL) + (d)) + +// Enumeration used to specify a table in a TTF file +class Tag +{ + unsigned int _v; +public: + Tag(const char n[5]) throw() : _v(TTF_TAG(n[0],n[1],n[2],n[3])) {} + Tag(const unsigned int tag) throw() : _v(tag) {} + + operator unsigned int () const throw () { return _v; } + + enum + { + Feat = TTF_TAG('F','e','a','t'), + Glat = TTF_TAG('G','l','a','t'), + Gloc = TTF_TAG('G','l','o','c'), + Sile = TTF_TAG('S','i','l','e'), + Silf = TTF_TAG('S','i','l','f'), + Sill = TTF_TAG('S','i','l','l'), + cmap = TTF_TAG('c','m','a','p'), + cvt = TTF_TAG('c','v','t',' '), + cryp = TTF_TAG('c','r','y','p'), + head = TTF_TAG('h','e','a','d'), + fpgm = TTF_TAG('f','p','g','m'), + gdir = TTF_TAG('g','d','i','r'), + glyf = TTF_TAG('g','l','y','f'), + hdmx = TTF_TAG('h','d','m','x'), + hhea = TTF_TAG('h','h','e','a'), + hmtx = TTF_TAG('h','m','t','x'), + loca = TTF_TAG('l','o','c','a'), + kern = TTF_TAG('k','e','r','n'), + LTSH = TTF_TAG('L','T','S','H'), + maxp = TTF_TAG('m','a','x','p'), + name = TTF_TAG('n','a','m','e'), + OS_2 = TTF_TAG('O','S','/','2'), + post = TTF_TAG('p','o','s','t'), + prep = TTF_TAG('p','r','e','p') + }; +}; + +/*---------------------------------------------------------------------------------------------- + Class providing utility methods to parse a TrueType font file (TTF). + Callling application handles all file input and memory allocation. + Assumes minimal knowledge of TTF file format. +----------------------------------------------------------------------------------------------*/ + ////////////////////////////////// tools to find & check TTF tables + bool GetHeaderInfo(size_t & lOffset, size_t & lSize); + bool CheckHeader(const void * pHdr); + bool GetTableDirInfo(const void * pHdr, size_t & lOffset, size_t & lSize); + bool GetTableInfo(const Tag TableTag, const void * pHdr, const void * pTableDir, + size_t & lOffset, size_t & lSize); + bool CheckTable(const Tag TableId, const void * pTable, size_t lTableSize); + + ////////////////////////////////// simple font wide info + size_t GlyphCount(const void * pMaxp); +#ifdef ALL_TTFUTILS + size_t MaxCompositeComponentCount(const void * pMaxp); + size_t MaxCompositeLevelCount(const void * pMaxp); + size_t LocaGlyphCount(size_t lLocaSize, const void * pHead); // throw (std::domain_error); +#endif + int DesignUnits(const void * pHead); +#ifdef ALL_TTFUTILS + int HeadTableCheckSum(const void * pHead); + void HeadTableCreateTime(const void * pHead, unsigned int * pnDateBC, unsigned int * pnDateAD); + void HeadTableModifyTime(const void * pHead, unsigned int * pnDateBC, unsigned int * pnDateAD); + bool IsItalic(const void * pHead); + int FontAscent(const void * pOs2); + int FontDescent(const void * pOs2); + bool FontOs2Style(const void *pOs2, bool & fBold, bool & fItalic); + bool Get31EngFamilyInfo(const void * pName, size_t & lOffset, size_t & lSize); + bool Get31EngFullFontInfo(const void * pName, size_t & lOffset, size_t & lSize); + bool Get30EngFamilyInfo(const void * pName, size_t & lOffset, size_t & lSize); + bool Get30EngFullFontInfo(const void * pName, size_t & lOffset, size_t & lSize); + int PostLookup(const void * pPost, size_t lPostSize, const void * pMaxp, + const char * pPostName); +#endif + + ////////////////////////////////// utility methods helpful for name table + bool GetNameInfo(const void * pName, int nPlatformId, int nEncodingId, + int nLangId, int nNameId, size_t & lOffset, size_t & lSize); + //size_t NameTableLength(const byte * pTable); +#ifdef ALL_TTFUTILS + int GetLangsForNames(const void * pName, int nPlatformId, int nEncodingId, + int *nameIdList, int cNameIds, short *langIdList); + void SwapWString(void * pWStr, size_t nSize = 0); // throw (std::invalid_argument); +#endif + + ////////////////////////////////// cmap lookup tools + const void * FindCmapSubtable(const void * pCmap, int nPlatformId = 3, + int nEncodingId = 1, size_t length = 0); + bool CheckCmapSubtable4(const void * pCmap31, const void * pCmapEnd /*, unsigned int maxgid*/); + gid16 CmapSubtable4Lookup(const void * pCmapSubtabel4, unsigned int nUnicodeId, int rangeKey = 0); + unsigned int CmapSubtable4NextCodepoint(const void *pCmap31, unsigned int nUnicodeId, + int * pRangeKey = 0); + bool CheckCmapSubtable12(const void *pCmap310, const void * pCmapEnd /*, unsigned int maxgid*/); + gid16 CmapSubtable12Lookup(const void * pCmap310, unsigned int uUnicodeId, int rangeKey = 0); + unsigned int CmapSubtable12NextCodepoint(const void *pCmap310, unsigned int nUnicodeId, + int * pRangeKey = 0); + + ///////////////////////////////// horizontal metric data for a glyph + bool HorMetrics(gid16 nGlyphId, const void * pHmtx, size_t lHmtxSize, + const void * pHhea, int & nLsb, unsigned int & nAdvWid); + + ////////////////////////////////// primitives for loca and glyf lookup + size_t LocaLookup(gid16 nGlyphId, const void * pLoca, size_t lLocaSize, + const void * pHead); // throw (std::out_of_range); + void * GlyfLookup(const void * pGlyf, size_t lGlyfOffset, size_t lTableLen); + + ////////////////////////////////// primitves for simple glyph data + bool GlyfBox(const void * pSimpleGlyf, int & xMin, int & yMin, + int & xMax, int & yMax); + +#ifdef ALL_TTFUTILS + int GlyfContourCount(const void * pSimpleGlyf); + bool GlyfContourEndPoints(const void * pSimpleGlyf, int * prgnContourEndPoint, + int cnPointsTotal, size_t & cnPoints); + bool GlyfPoints(const void * pSimpleGlyf, int * prgnX, int * prgnY, + char * prgbFlag, int cnPointsTotal, int & cnPoints); + + // primitive to find the glyph ids in a composite glyph + bool GetComponentGlyphIds(const void * pSimpleGlyf, int * prgnCompId, + size_t cnCompIdTotal, size_t & cnCompId); + // primitive to find the placement data for a component in a composite glyph + bool GetComponentPlacement(const void * pSimpleGlyf, int nCompId, + bool fOffset, int & a, int & b); + // primitive to find the transform data for a component in a composite glyph + bool GetComponentTransform(const void * pSimpleGlyf, int nCompId, + float & flt11, float & flt12, float & flt21, float & flt22, bool & fTransOffset); +#endif + + ////////////////////////////////// operate on composite or simple glyph (auto glyf lookup) + void * GlyfLookup(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead); // primitive used by below methods + +#ifdef ALL_TTFUTILS + // below are primary user methods for handling glyf data + bool IsSpace(gid16 nGlyphId, const void * pLoca, size_t lLocaSize, const void * pHead); + bool IsDeepComposite(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead); + + bool GlyfBox(gid16 nGlyphId, const void * pGlyf, const void * pLoca, size_t lGlyfSize, size_t lLocaSize, + const void * pHead, int & xMin, int & yMin, int & xMax, int & yMax); + bool GlyfContourCount(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void *pHead, size_t & cnContours); + bool GlyfContourEndPoints(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead, int * prgnContourEndPoint, size_t cnPoints); + bool GlyfPoints(gid16 nGlyphId, const void * pGlyf, const void * pLoca, + size_t lGlyfSize, size_t lLocaSize, const void * pHead, const int * prgnContourEndPoint, size_t cnEndPoints, + int * prgnX, int * prgnY, bool * prgfOnCurve, size_t cnPoints); + + // utitily method used by high-level GlyfPoints + bool SimplifyFlags(char * prgbFlags, int cnPoints); + bool CalcAbsolutePoints(int * prgnX, int * prgnY, int cnPoints); +#endif + +} // end of namespace TtfUtil +} // end of namespace graphite2 diff --git a/gfx/graphite2/src/inc/UtfCodec.h b/gfx/graphite2/src/inc/UtfCodec.h new file mode 100644 index 0000000000..24a343d8d9 --- /dev/null +++ b/gfx/graphite2/src/inc/UtfCodec.h @@ -0,0 +1,251 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +#include <cstdlib> +#include "inc/Main.h" + +namespace graphite2 { + +typedef uint32 uchar_t; + +template <int N> +struct _utf_codec +{ + typedef uchar_t codeunit_t; + + static void put(codeunit_t * cp, const uchar_t , int8 & len) throw(); + static uchar_t get(const codeunit_t * cp, int8 & len) throw(); + static bool validate(const codeunit_t * s, const codeunit_t * const e) throw(); +}; + + +template <> +struct _utf_codec<32> +{ +private: + static const uchar_t limit = 0x110000; +public: + typedef uint32 codeunit_t; + + inline + static void put(codeunit_t * cp, const uchar_t usv, int8 & l) throw() + { + *cp = usv; l = 1; + } + + inline + static uchar_t get(const codeunit_t * cp, int8 & l) throw() + { + if (cp[0] < limit) { l = 1; return cp[0]; } + else { l = -1; return 0xFFFD; } + } + + inline + static bool validate(const codeunit_t * s, const codeunit_t * const e) throw() + { + return s <= e; + } +}; + + +template <> +struct _utf_codec<16> +{ +private: + static const int32 lead_offset = 0xD800 - (0x10000 >> 10); + static const int32 surrogate_offset = 0x10000 - (0xD800 << 10) - 0xDC00; +public: + typedef uint16 codeunit_t; + + inline + static void put(codeunit_t * cp, const uchar_t usv, int8 & l) throw() + { + if (usv < 0x10000) { l = 1; cp[0] = codeunit_t(usv); } + else + { + cp[0] = codeunit_t(lead_offset + (usv >> 10)); + cp[1] = codeunit_t(0xDC00 + (usv & 0x3FF)); + l = 2; + } + } + + inline + static uchar_t get(const codeunit_t * cp, int8 & l) throw() + { + const uint32 uh = cp[0]; + l = 1; + + if (uh < 0xD800|| uh > 0xDFFF) { return uh; } + if (uh > 0xDBFF) { l = -1; return 0xFFFD; } + const uint32 ul = cp[1]; + if (ul < 0xDC00 || ul > 0xDFFF) { l = -1; return 0xFFFD; } + ++l; + return (uh<<10) + ul + surrogate_offset; + } + + inline + static bool validate(const codeunit_t * s, const codeunit_t * const e) throw() + { + const ptrdiff_t n = e-s; + if (n <= 0) return n == 0; + const uint32 u = *(e-1); // Get the last codepoint + return (u < 0xD800 || u > 0xDBFF); + } +}; + + +template <> +struct _utf_codec<8> +{ +private: + static const int8 sz_lut[16]; + static const byte mask_lut[5]; + static const uchar_t limit = 0x110000; + +public: + typedef uint8 codeunit_t; + + inline + static void put(codeunit_t * cp, const uchar_t usv, int8 & l) throw() + { + if (usv < 0x80) {l = 1; cp[0] = usv; return; } + if (usv < 0x0800) {l = 2; cp[0] = 0xC0 + (usv >> 6); cp[1] = 0x80 + (usv & 0x3F); return; } + if (usv < 0x10000) {l = 3; cp[0] = 0xE0 + (usv >> 12); cp[1] = 0x80 + ((usv >> 6) & 0x3F); cp[2] = 0x80 + (usv & 0x3F); return; } + else {l = 4; cp[0] = 0xF0 + (usv >> 18); cp[1] = 0x80 + ((usv >> 12) & 0x3F); cp[2] = 0x80 + ((usv >> 6) & 0x3F); cp[3] = 0x80 + (usv & 0x3F); return; } + } + + inline + static uchar_t get(const codeunit_t * cp, int8 & l) throw() + { + const int8 seq_sz = sz_lut[*cp >> 4]; + uchar_t u = *cp & mask_lut[seq_sz]; + l = 1; + bool toolong = false; + + switch(seq_sz) { + case 4: u <<= 6; u |= *++cp & 0x3F; if (*cp >> 6 != 2) break; ++l; toolong = (u < 0x10); GR_FALLTHROUGH; + // no break + case 3: u <<= 6; u |= *++cp & 0x3F; if (*cp >> 6 != 2) break; ++l; toolong |= (u < 0x20); GR_FALLTHROUGH; + // no break + case 2: u <<= 6; u |= *++cp & 0x3F; if (*cp >> 6 != 2) break; ++l; toolong |= (u < 0x80); GR_FALLTHROUGH; + // no break + case 1: break; + case 0: l = -1; return 0xFFFD; + } + + if (l != seq_sz || toolong || u >= limit) + { + l = -l; + return 0xFFFD; + } + return u; + } + + inline + static bool validate(const codeunit_t * s, const codeunit_t * const e) throw() + { + const ptrdiff_t n = e-s; + if (n <= 0) return n == 0; + s += (n-1); + if (*s < 0x80) return true; + if (*s >= 0xC0) return false; + if (n == 1) return true; + if (*--s < 0x80) return true; + if (*s >= 0xE0) return false; + if (n == 2 || *s >= 0xC0) return true; + if (*--s < 0x80) return true; + if (*s >= 0xF0) return false; + return true; + } + +}; + + +template <typename C> +class _utf_iterator +{ + typedef _utf_codec<sizeof(C)*8> codec; + + C * cp; + mutable int8 sl; + +public: + typedef C codeunit_type; + typedef uchar_t value_type; + typedef uchar_t * pointer; + + class reference + { + const _utf_iterator & _i; + + reference(const _utf_iterator & i): _i(i) {} + public: + operator value_type () const throw () { return codec::get(_i.cp, _i.sl); } + reference & operator = (const value_type usv) throw() { codec::put(_i.cp, usv, _i.sl); return *this; } + + friend class _utf_iterator; + }; + + + _utf_iterator(const void * us=0) : cp(reinterpret_cast<C *>(const_cast<void *>(us))), sl(1) { } + + _utf_iterator & operator ++ () { cp += abs(sl); return *this; } + _utf_iterator operator ++ (int) { _utf_iterator tmp(*this); operator++(); return tmp; } + + bool operator == (const _utf_iterator & rhs) const throw() { return cp >= rhs.cp; } + bool operator != (const _utf_iterator & rhs) const throw() { return !operator==(rhs); } + + reference operator * () const throw() { return *this; } + pointer operator ->() const throw() { return &operator *(); } + + operator codeunit_type * () const throw() { return cp; } + + bool error() const throw() { return sl < 1; } + bool validate(const _utf_iterator & e) { return codec::validate(cp, e.cp); } +}; + +template <typename C> +struct utf +{ + typedef typename _utf_codec<sizeof(C)*8>::codeunit_t codeunit_t; + + typedef _utf_iterator<C> iterator; + typedef _utf_iterator<const C> const_iterator; + + inline + static bool validate(codeunit_t * s, codeunit_t * e) throw() { + return _utf_codec<sizeof(C)*8>::validate(s,e); + } +}; + + +typedef utf<uint32> utf32; +typedef utf<uint16> utf16; +typedef utf<uint8> utf8; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/bits.h b/gfx/graphite2/src/inc/bits.h new file mode 100644 index 0000000000..9365986a10 --- /dev/null +++ b/gfx/graphite2/src/inc/bits.h @@ -0,0 +1,150 @@ +/* GRAPHITE2 LICENSING + + Copyright 2012, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once + +namespace graphite2 +{ + + +#if defined GRAPHITE2_BUILTINS && (defined __GNUC__ || defined __clang__) + +template<typename T> +inline unsigned int bit_set_count(T v) +{ + return __builtin_popcount(v); +} + +template<> +inline unsigned int bit_set_count(int16 v) +{ + return __builtin_popcount(static_cast<uint16>(v)); +} + +template<> +inline unsigned int bit_set_count(int8 v) +{ + return __builtin_popcount(static_cast<uint8>(v)); +} + +template<> +inline unsigned int bit_set_count(unsigned long v) +{ + return __builtin_popcountl(v); +} + +template<> +inline unsigned int bit_set_count(signed long v) +{ + return __builtin_popcountl(v); +} + +template<> +inline unsigned int bit_set_count(unsigned long long v) +{ + return __builtin_popcountll(v); +} + +template<> +inline unsigned int bit_set_count(signed long long v) +{ + return __builtin_popcountll(v); +} + +#else + +template<typename T> +inline unsigned int bit_set_count(T v) +{ + static size_t const ONES = ~0; + + v = v - ((v >> 1) & T(ONES/3)); // temp + v = (v & T(ONES/15*3)) + ((v >> 2) & T(ONES/15*3)); // temp + v = (v + (v >> 4)) & T(ONES/255*15); // temp + return (T)(v * T(ONES/255)) >> (sizeof(T)-1)*8; // count +} + +#endif + +//TODO: Changed these to uintmax_t when we go to C++11 +template<int S> +inline size_t _mask_over_val(size_t v) +{ + v = _mask_over_val<S/2>(v); + v |= v >> S*4; + return v; +} + +//TODO: Changed these to uintmax_t when we go to C++11 +template<> +inline size_t _mask_over_val<1>(size_t v) +{ + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + return v; +} + +template<typename T> +inline T mask_over_val(T v) +{ + return T(_mask_over_val<sizeof(T)>(v)); +} + +template<typename T> +inline unsigned long next_highest_power2(T v) +{ + return _mask_over_val<sizeof(T)>(v-1)+1; +} + +template<typename T> +inline unsigned int log_binary(T v) +{ + return bit_set_count(mask_over_val(v))-1; +} + +template<typename T> +inline T has_zero(const T x) +{ + return (x - T(~T(0)/255)) & ~x & T(~T(0)/255*128); +} + +template<typename T> +inline T zero_bytes(const T x, unsigned char n) +{ + const T t = T(~T(0)/255*n); + return T((has_zero(x^t) >> 7)*n); +} + +#if 0 +inline float float_round(float x, uint32 m) +{ + *reinterpret_cast<unsigned int *>(&x) &= m; + return *reinterpret_cast<float *>(&x); +} +#endif + +} diff --git a/gfx/graphite2/src/inc/debug.h b/gfx/graphite2/src/inc/debug.h new file mode 100644 index 0000000000..97175eb2cc --- /dev/null +++ b/gfx/graphite2/src/inc/debug.h @@ -0,0 +1,89 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// debug.h +// +// Created on: 22 Dec 2011 +// Author: tim + +#pragma once + +#if !defined GRAPHITE2_NTRACING + +#include <utility> +#include "inc/json.h" +#include "inc/Position.h" + +namespace graphite2 +{ + +class CharInfo; +class Segment; +class Slot; + +typedef std::pair<const Segment * const, const Slot * const> dslot; +struct objectid +{ + char name[16]; + objectid(const dslot &) throw(); + objectid(const Segment * const p) throw(); +}; + + +json & operator << (json & j, const Position &) throw(); +json & operator << (json & j, const Rect &) throw(); +json & operator << (json & j, const CharInfo &) throw(); +json & operator << (json & j, const dslot &) throw(); +json & operator << (json & j, const objectid &) throw(); +json & operator << (json & j, const telemetry &) throw(); + + + +inline +json & operator << (json & j, const Position & p) throw() +{ + return j << json::flat << json::array << p.x << p.y << json::close; +} + + +inline +json & operator << (json & j, const Rect & p) throw() +{ + return j << json::flat << json::array << p.bl.x << p.bl.y << p.tr.x << p.tr.y << json::close; +} + + +inline +json & operator << (json & j, const objectid & sid) throw() +{ + return j << sid.name; +} + + +} // namespace graphite2 + +#endif //!defined GRAPHITE2_NTRACING + diff --git a/gfx/graphite2/src/inc/json.h b/gfx/graphite2/src/inc/json.h new file mode 100644 index 0000000000..554cd9a3d1 --- /dev/null +++ b/gfx/graphite2/src/inc/json.h @@ -0,0 +1,178 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// JSON pretty printer for graphite font debug output logging. +// Created on: 15 Dec 2011 +// Author: Tim Eves + +#pragma once + +#include "inc/Main.h" +#include <cassert> +#include <cstdio> +#include <cstdint> +#include "inc/List.h" + +namespace graphite2 { + +class json +{ + // Prevent copying + json(const json &); + json & operator = (const json &); + + typedef void (*_context_t)(json &); + + FILE * const _stream; + char _contexts[128], // context stack + * _context, // current context (top of stack) + * _flatten; // if !0 points to context above which + // pretty printed output should occur. + Vector<void *> _env; + + void context(const char current) throw(); + void indent(const int d=0) throw(); + void push_context(const char, const char) throw(); + void pop_context() throw(); + +public: + class closer; + + using string = const char *; + using number = double; + enum class integer : std::intmax_t {}; + enum class integer_u : std::uintmax_t {}; + using boolean = bool; + static const std::nullptr_t null; + + void setenv(unsigned int index, void *val) { _env.reserve(index + 1); if (index >= _env.size()) _env.insert(_env.end(), _env.size() - index + 1, 0); _env[index] = val; } + void *getenv(unsigned int index) const { return _env[index]; } + const Vector<void *> &getenvs() const { return _env; } + + static void flat(json &) throw(); + static void close(json &) throw(); + static void object(json &) throw(); + static void array(json &) throw(); + static void item(json &) throw(); + + json(FILE * stream) throw(); + ~json() throw (); + + FILE * stream() const throw(); + + json & operator << (string) throw(); + json & operator << (number) throw(); + json & operator << (integer) throw(); + json & operator << (integer_u) throw(); + json & operator << (boolean) throw(); + json & operator << (std::nullptr_t) throw(); + json & operator << (_context_t) throw(); + + operator bool() const throw(); + bool good() const throw(); + bool eof() const throw(); + + CLASS_NEW_DELETE; +}; + +class json::closer +{ + // Prevent copying. + closer(const closer &); + closer & operator = (const closer &); + + json * const _j; +public: + closer(json * const j) : _j(j) {} + ~closer() throw() { if (_j) *_j << close; } +}; + +inline +json::json(FILE * s) throw() +: _stream(s), _context(_contexts), _flatten(0) +{ + if (good()) + fflush(s); +} + + +inline +json::~json() throw () +{ + while (_context > _contexts) pop_context(); +} + +inline +FILE * json::stream() const throw() { return _stream; } + + +inline +json & json::operator << (json::_context_t ctxt) throw() +{ + ctxt(*this); + return *this; +} + +inline +json & operator << (json & j, signed char d) throw() { return j << json::integer(d); } + +inline +json & operator << (json & j, unsigned char d) throw() { return j << json::integer_u(d); } + +inline +json & operator << (json & j, short int d) throw() { return j << json::integer(d); } + +inline +json & operator << (json & j, unsigned short int d) throw() { return j << json::integer_u(d); } + +inline +json & operator << (json & j, int d) throw() { return j << json::integer(d); } + +inline +json & operator << (json & j, unsigned int d) throw() { return j << json::integer_u(d); } + +inline +json & operator << (json & j, long int d) throw() { return j << json::integer(d); } + +inline +json & operator << (json & j, unsigned long int d) throw() { return j << json::integer_u(d); } + +inline +json & operator << (json & j, long long int d) throw() { return j << json::integer(d); } + +inline +json & operator << (json & j, unsigned long long int d) throw() { return j << json::integer_u(d); } + +inline +json::operator bool() const throw() { return good(); } + +inline +bool json::good() const throw() { return _stream && ferror(_stream) == 0; } + +inline +bool json::eof() const throw() { return feof(_stream) != 0; } + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/locale2lcid.h b/gfx/graphite2/src/inc/locale2lcid.h new file mode 100644 index 0000000000..25d5c0a3c8 --- /dev/null +++ b/gfx/graphite2/src/inc/locale2lcid.h @@ -0,0 +1,450 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +#include <cstring> +#include <cassert> + +#include "inc/Main.h" + + +namespace graphite2 { + +struct IsoLangEntry +{ + unsigned short mnLang; + char maLangStr[4]; + char maCountry[3]; +}; + +// Windows Language ID, Locale ISO-639 language, country code as used in +// naming table of OpenType fonts +const IsoLangEntry LANG_ENTRIES[] = { + { 0x0401, "ar","SA" }, // Arabic Saudi Arabia + { 0x0402, "bg","BG" }, // Bulgarian Bulgaria + { 0x0403, "ca","ES" }, // Catalan Catalan + { 0x0404, "zh","TW" }, // Chinese Taiwan + { 0x0405, "cs","CZ" }, // Czech Czech Republic + { 0x0406, "da","DK" }, // Danish Denmark + { 0x0407, "de","DE" }, // German Germany + { 0x0408, "el","GR" }, // Greek Greece + { 0x0409, "en","US" }, // English United States + { 0x040A, "es","ES" }, // Spanish (Traditional Sort) Spain + { 0x040B, "fi","FI" }, // Finnish Finland + { 0x040C, "fr","FR" }, // French France + { 0x040D, "he","IL" }, // Hebrew Israel + { 0x040E, "hu","HU" }, // Hungarian Hungary + { 0x040F, "is","IS" }, // Icelandic Iceland + { 0x0410, "it","IT" }, // Italian Italy + { 0x0411, "jp","JP" }, // Japanese Japan + { 0x0412, "ko","KR" }, // Korean Korea + { 0x0413, "nl","NL" }, // Dutch Netherlands + { 0x0414, "no","NO" }, // Norwegian (Bokmal) Norway + { 0x0415, "pl","PL" }, // Polish Poland + { 0x0416, "pt","BR" }, // Portuguese Brazil + { 0x0417, "rm","CH" }, // Romansh Switzerland + { 0x0418, "ro","RO" }, // Romanian Romania + { 0x0419, "ru","RU" }, // Russian Russia + { 0x041A, "hr","HR" }, // Croatian Croatia + { 0x041B, "sk","SK" }, // Slovak Slovakia + { 0x041C, "sq","AL" }, // Albanian Albania + { 0x041D, "sv","SE" }, // Swedish Sweden + { 0x041E, "th","TH" }, // Thai Thailand + { 0x041F, "tr","TR" }, // Turkish Turkey + { 0x0420, "ur","PK" }, // Urdu Islamic Republic of Pakistan + { 0x0421, "id","ID" }, // Indonesian Indonesia + { 0x0422, "uk","UA" }, // Ukrainian Ukraine + { 0x0423, "be","BY" }, // Belarusian Belarus + { 0x0424, "sl","SI" }, // Slovenian Slovenia + { 0x0425, "et","EE" }, // Estonian Estonia + { 0x0426, "lv","LV" }, // Latvian Latvia + { 0x0427, "lt","LT" }, // Lithuanian Lithuania + { 0x0428, "tg","TJ" }, // Tajik (Cyrillic) Tajikistan + { 0x042A, "vi","VN" }, // Vietnamese Vietnam + { 0x042B, "hy","AM" }, // Armenian Armenia + { 0x042C, "az","AZ" }, // Azeri (Latin) Azerbaijan + { 0x042D, "eu","" }, // Basque Basque + { 0x042E, "hsb","DE" }, // Upper Sorbian Germany + { 0x042F, "mk","MK" }, // Macedonian (FYROM) Former Yugoslav Republic of Macedonia + { 0x0432, "tn","ZA" }, // Setswana South Africa + { 0x0434, "xh","ZA" }, // isiXhosa South Africa + { 0x0435, "zu","ZA" }, // isiZulu South Africa + { 0x0436, "af","ZA" }, // Afrikaans South Africa + { 0x0437, "ka","GE" }, // Georgian Georgia + { 0x0438, "fo","FO" }, // Faroese Faroe Islands + { 0x0439, "hi","IN" }, // Hindi India + { 0x043A, "mt","MT" }, // Maltese Malta + { 0x043B, "se","NO" }, // Sami (Northern) Norway + { 0x043E, "ms","MY" }, // Malay Malaysia + { 0x043F, "kk","KZ" }, // Kazakh Kazakhstan + { 0x0440, "ky","KG" }, // Kyrgyz Kyrgyzstan + { 0x0441, "sw","KE" }, // Kiswahili Kenya + { 0x0442, "tk","TM" }, // Turkmen Turkmenistan + { 0x0443, "uz","UZ" }, // Uzbek (Latin) Uzbekistan + { 0x0444, "tt","RU" }, // Tatar Russia + { 0x0445, "bn","IN" }, // Bengali India + { 0x0446, "pa","IN" }, // Punjabi India + { 0x0447, "gu","IN" }, // Gujarati India + { 0x0448, "or","IN" }, // Oriya India + { 0x0448, "wo","SN" }, // Wolof Senegal + { 0x0449, "ta","IN" }, // Tamil India + { 0x044A, "te","IN" }, // Telugu India + { 0x044B, "kn","IN" }, // Kannada India + { 0x044C, "ml","IN" }, // Malayalam India + { 0x044D, "as","IN" }, // Assamese India + { 0x044E, "mr","IN" }, // Marathi India + { 0x044F, "sa","IN" }, // Sanskrit India + { 0x0450, "mn","MN" }, // Mongolian (Cyrillic) Mongolia + { 0x0451, "bo","CN" }, // Tibetan PRC + { 0x0452, "cy","GB" }, // Welsh United Kingdom + { 0x0453, "km","KH" }, // Khmer Cambodia + { 0x0454, "lo","LA" }, // Lao Lao P.D.R. + { 0x0455, "my","MM" }, // Burmese Myanmar - not listed in Microsoft docs anymore + { 0x0456, "gl","ES" }, // Galician Galician + { 0x0457, "kok","IN" }, // Konkani India + { 0x045A, "syr","TR" }, // Syriac Syria + { 0x045B, "si","LK" }, // Sinhala Sri Lanka + { 0x045D, "iu","CA" }, // Inuktitut Canada + { 0x045E, "am","ET" }, // Amharic Ethiopia + { 0x0461, "ne","NP" }, // Nepali Nepal + { 0x0462, "fy","NL" }, // Frisian Netherlands + { 0x0463, "ps","AF" }, // Pashto Afghanistan + { 0x0464, "fil","PH" }, // Filipino Philippines + { 0x0465, "dv","MV" }, // Divehi Maldives + { 0x0468, "ha","NG" }, // Hausa (Latin) Nigeria + { 0x046A, "yo","NG" }, // Yoruba Nigeria + { 0x046B, "qu","BO" }, // Quechua Bolivia + { 0x046C, "st","ZA" }, // Sesotho sa Leboa South Africa + { 0x046D, "ba","RU" }, // Bashkir Russia + { 0x046E, "lb","LU" }, // Luxembourgish Luxembourg + { 0x046F, "kl","GL" }, // Greenlandic Greenland + { 0x0470, "ig","NG" }, // Igbo Nigeria + { 0x0478, "ii","CN" }, // Yi PRC + { 0x047A, "arn","CL" }, // Mapudungun Chile + { 0x047C, "moh","CA" }, // Mohawk Mohawk + { 0x047E, "br","FR" }, // Breton France + { 0x0480, "ug","CN" }, // Uighur PRC + { 0x0481, "mi","NZ" }, // Maori New Zealand + { 0x0482, "oc","FR" }, // Occitan France + { 0x0483, "co","FR" }, // Corsican France + { 0x0484, "gsw","FR" }, // Alsatian France + { 0x0485, "sah","RU" }, // Yakut Russia + { 0x0486, "qut","GT" }, // K'iche Guatemala + { 0x0487, "rw","RW" }, // Kinyarwanda Rwanda + { 0x048C, "gbz","AF" }, // Dari Afghanistan + { 0x0801, "ar","IQ" }, // Arabic Iraq + { 0x0804, "zn","CH" }, // Chinese People's Republic of China + { 0x0807, "de","CH" }, // German Switzerland + { 0x0809, "en","GB" }, // English United Kingdom + { 0x080A, "es","MX" }, // Spanish Mexico + { 0x080C, "fr","BE" }, // French Belgium + { 0x0810, "it","CH" }, // Italian Switzerland + { 0x0813, "nl","BE" }, // Dutch Belgium + { 0x0814, "nn","NO" }, // Norwegian (Nynorsk) Norway + { 0x0816, "pt","PT" }, // Portuguese Portugal + { 0x081A, "sh","RS" }, // Serbian (Latin) Serbia + { 0x081D, "sv","FI" }, // Sweden Finland + { 0x082C, "az","AZ" }, // Azeri (Cyrillic) Azerbaijan + { 0x082E, "dsb","DE" }, // Lower Sorbian Germany + { 0x083B, "se","SE" }, // Sami (Northern) Sweden + { 0x083C, "ga","IE" }, // Irish Ireland + { 0x083E, "ms","BN" }, // Malay Brunei Darussalam + { 0x0843, "uz","UZ" }, // Uzbek (Cyrillic) Uzbekistan + { 0x0845, "bn","BD" }, // Bengali Bangladesh + { 0x0850, "mn","MN" }, // Mongolian (Traditional) People's Republic of China + { 0x085D, "iu","CA" }, // Inuktitut (Latin) Canada + { 0x085F, "ber","DZ" }, // Tamazight (Latin) Algeria + { 0x086B, "es","EC" }, // Quechua Ecuador + { 0x0C01, "ar","EG" }, // Arabic Egypt + { 0x0C04, "zh","HK" }, // Chinese Hong Kong S.A.R. + { 0x0C07, "de","AT" }, // German Austria + { 0x0C09, "en","AU" }, // English Australia + { 0x0C0A, "es","ES" }, // Spanish (Modern Sort) Spain + { 0x0C0C, "fr","CA" }, // French Canada + { 0x0C1A, "sr","CS" }, // Serbian (Cyrillic) Serbia + { 0x0C3B, "se","FI" }, // Sami (Northern) Finland + { 0x0C6B, "qu","PE" }, // Quechua Peru + { 0x1001, "ar","LY" }, // Arabic Libya + { 0x1004, "zh","SG" }, // Chinese Singapore + { 0x1007, "de","LU" }, // German Luxembourg + { 0x1009, "en","CA" }, // English Canada + { 0x100A, "es","GT" }, // Spanish Guatemala + { 0x100C, "fr","CH" }, // French Switzerland + { 0x101A, "hr","BA" }, // Croatian (Latin) Bosnia and Herzegovina + { 0x103B, "smj","NO" }, // Sami (Lule) Norway + { 0x1401, "ar","DZ" }, // Arabic Algeria + { 0x1404, "zh","MO" }, // Chinese Macao S.A.R. + { 0x1407, "de","LI" }, // German Liechtenstein + { 0x1409, "en","NZ" }, // English New Zealand + { 0x140A, "es","CR" }, // Spanish Costa Rica + { 0x140C, "fr","LU" }, // French Luxembourg + { 0x141A, "bs","BA" }, // Bosnian (Latin) Bosnia and Herzegovina + { 0x143B, "smj","SE" }, // Sami (Lule) Sweden + { 0x1801, "ar","MA" }, // Arabic Morocco + { 0x1809, "en","IE" }, // English Ireland + { 0x180A, "es","PA" }, // Spanish Panama + { 0x180C, "fr","MC" }, // French Principality of Monoco + { 0x181A, "sh","BA" }, // Serbian (Latin) Bosnia and Herzegovina + { 0x183B, "sma","NO" }, // Sami (Southern) Norway + { 0x1C01, "ar","TN" }, // Arabic Tunisia + { 0x1C09, "en","ZA" }, // English South Africa + { 0x1C0A, "es","DO" }, // Spanish Dominican Republic + { 0x1C1A, "sr","BA" }, // Serbian (Cyrillic) Bosnia and Herzegovina + { 0x1C3B, "sma","SE" }, // Sami (Southern) Sweden + { 0x2001, "ar","OM" }, // Arabic Oman + { 0x2009, "en","JM" }, // English Jamaica + { 0x200A, "es","VE" }, // Spanish Venezuela + { 0x201A, "bs","BA" }, // Bosnian (Cyrillic) Bosnia and Herzegovina + { 0x203B, "sms","FI" }, // Sami (Skolt) Finland + { 0x2401, "ar","YE" }, // Arabic Yemen + { 0x2409, "en","BS" }, // English Caribbean + { 0x240A, "es","CO" }, // Spanish Colombia + { 0x243B, "smn","FI" }, // Sami (Inari) Finland + { 0x2801, "ar","SY" }, // Arabic Syria + { 0x2809, "en","BZ" }, // English Belize + { 0x280A, "es","PE" }, // Spanish Peru + { 0x2C01, "ar","JO" }, // Arabic Jordan + { 0x2C09, "en","TT" }, // English Trinidad and Tobago + { 0x2C0A, "es","AR" }, // Spanish Argentina + { 0x3001, "ar","LB" }, // Arabic Lebanon + { 0x3009, "en","ZW" }, // English Zimbabwe + { 0x300A, "es","EC" }, // Spanish Ecuador + { 0x3401, "ar","KW" }, // Arabic Kuwait + { 0x3409, "en","PH" }, // English Republic of the Philippines + { 0x340A, "es","CL" }, // Spanish Chile + { 0x3801, "ar","AE" }, // Arabic U.A.E. + { 0x380A, "es","UY" }, // Spanish Uruguay + { 0x3C01, "ar","BH" }, // Arabic Bahrain + { 0x3C0A, "es","PY" }, // Spanish Paraguay + { 0x4001, "ar","QA" }, // Arabic Qatar + { 0x4009, "en","IN" }, // English India + { 0x400A, "es","BO" }, // Spanish Bolivia + { 0x4409, "en","MY" }, // English Malaysia + { 0x440A, "es","SV" }, // Spanish El Salvador + { 0x4809, "en","SG" }, // English Singapore + { 0x480A, "es","HN" }, // Spanish Honduras + { 0x4C0A, "es","NI" }, // Spanish Nicaragua + { 0x500A, "es","PR" }, // Spanish Puerto Rico + { 0x540A, "es","US" } // Spanish United States +}; + +class Locale2Lang +{ + Locale2Lang(const Locale2Lang &); + Locale2Lang & operator = (const Locale2Lang &); + +public: + Locale2Lang() : mSeedPosition(128) + { + memset((void*)mLangLookup, 0, sizeof(mLangLookup)); + // create a tri lookup on first 2 letters of language code + static const int maxIndex = sizeof(LANG_ENTRIES)/sizeof(IsoLangEntry); + for (int i = 0; i < maxIndex; i++) + { + size_t a = LANG_ENTRIES[i].maLangStr[0] - 'a'; + size_t b = LANG_ENTRIES[i].maLangStr[1] - 'a'; + if (mLangLookup[a][b]) + { + const IsoLangEntry ** old = mLangLookup[a][b]; + int len = 1; + while (old[len]) len++; + len += 2; + mLangLookup[a][b] = gralloc<const IsoLangEntry *>(len); + if (!mLangLookup[a][b]) + { + mLangLookup[a][b] = old; + continue; + } + mLangLookup[a][b][--len] = NULL; + mLangLookup[a][b][--len] = &LANG_ENTRIES[i]; + while (--len >= 0) + { + assert(len >= 0); + mLangLookup[a][b][len] = old[len]; + } + free(old); + } + else + { + mLangLookup[a][b] = gralloc<const IsoLangEntry *>(2); + if (!mLangLookup[a][b]) continue; + mLangLookup[a][b][1] = NULL; + mLangLookup[a][b][0] = &LANG_ENTRIES[i]; + } + } + while (2 * mSeedPosition < maxIndex) + mSeedPosition *= 2; + }; + ~Locale2Lang() + { + for (int i = 0; i != 26; ++i) + for (int j = 0; j != 26; ++j) + free(mLangLookup[i][j]); + } + unsigned short getMsId(const char * locale) const + { + size_t length = strlen(locale); + size_t langLength = length; + const char * language = locale; + const char * script = NULL; + const char * region = NULL; + size_t regionLength = 0; + const char * dash = strchr(locale, '-'); + if (dash && (dash != locale)) + { + langLength = (dash - locale); + size_t nextPartLength = length - langLength - 1; + if (nextPartLength >= 2) + { + script = ++dash; + dash = strchr(dash, '-'); + if (dash) + { + nextPartLength = (dash - script); + region = ++dash; + } + if (nextPartLength == 2 && + (locale[langLength+1] > 0x40) && (locale[langLength+1] < 0x5B) && + (locale[langLength+2] > 0x40) && (locale[langLength+2] < 0x5B)) + { + region = script; + regionLength = nextPartLength; + script = NULL; + } + else if (nextPartLength == 4) + { + if (dash) + { + dash = strchr(dash, '-'); + if (dash) + { + nextPartLength = (dash - region); + } + else + { + nextPartLength = langLength - (region - locale); + } + regionLength = nextPartLength; + } + } + } + } + size_t a = 'e' - 'a'; + size_t b = 'n' - 'a'; + unsigned short langId = 0; + int i = 0; + switch (langLength) + { + case 2: + { + a = language[0] - 'a'; + b = language[1] - 'a'; + if ((a < 26) && (b < 26) && mLangLookup[a][b]) + { + while (mLangLookup[a][b][i]) + { + if (mLangLookup[a][b][i]->maLangStr[2] != '\0') + { + ++i; + continue; + } + if (region && (strncmp(mLangLookup[a][b][i]->maCountry, region, regionLength) == 0)) + { + langId = mLangLookup[a][b][i]->mnLang; + break; + } + else if (langId == 0) + { + // possible fallback code + langId = mLangLookup[a][b][i]->mnLang; + } + ++i; + } + } + } + break; + case 3: + { + a = language[0] - 'a'; + b = language[1] - 'a'; + if (mLangLookup[a][b]) + { + while (mLangLookup[a][b][i]) + { + if (mLangLookup[a][b][i]->maLangStr[2] != language[2]) + { + ++i; + continue; + } + if (region && (strncmp(mLangLookup[a][b][i]->maCountry, region, regionLength) == 0)) + { + langId = mLangLookup[a][b][i]->mnLang; + break; + } + else if (langId == 0) + { + // possible fallback code + langId = mLangLookup[a][b][i]->mnLang; + } + ++i; + } + } + } + break; + default: + break; + } + if (langId == 0) langId = 0x409; + return langId; + } + const IsoLangEntry * findEntryById(unsigned short langId) const + { + static const int maxIndex = sizeof(LANG_ENTRIES)/sizeof(IsoLangEntry); + int window = mSeedPosition; + int guess = mSeedPosition - 1; + while (LANG_ENTRIES[guess].mnLang != langId) + { + window /= 2; + if (window == 0) return NULL; + guess += (LANG_ENTRIES[guess].mnLang > langId)? -window : window; + while (guess >= maxIndex) + { + window /= 2; + guess -= window; + assert(window); + } + } + return &LANG_ENTRIES[guess]; + } + + CLASS_NEW_DELETE; + +private: + const IsoLangEntry ** mLangLookup[26][26]; + int mSeedPosition; +}; + +} // namespace graphite2 diff --git a/gfx/graphite2/src/inc/opcode_table.h b/gfx/graphite2/src/inc/opcode_table.h new file mode 100644 index 0000000000..cb5acde9a4 --- /dev/null +++ b/gfx/graphite2/src/inc/opcode_table.h @@ -0,0 +1,124 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// This file will be pulled into and integrated into a machine implmentation +// DO NOT build directly +#pragma once + +#define do2(n) do_(n) ,do_(n) +#define NILOP 0U + +// types or parameters are: (.. is inclusive) +// number - any byte +// output_class - 0 .. silf.m_nClass +// input_class - 0 .. silf.m_nClass +// sattrnum - 0 .. 29 (gr_slatJWidth) , 55 (gr_slatUserDefn) +// attrid - 0 .. silf.numUser() where sattrnum == 55; 0..silf.m_iMaxComp where sattrnum == 15 otherwise 0 +// gattrnum - 0 .. face->getGlyphFaceCache->numAttrs() +// gmetric - 0 .. 11 (kgmetDescent) +// featidx - 0 .. face.numFeatures() +// level - any byte +static const opcode_t opcode_table[] = +{ + {{do2(nop)}, 0, "NOP"}, + + {{do2(push_byte)}, 1, "PUSH_BYTE"}, // number + {{do2(push_byte_u)}, 1, "PUSH_BYTE_U"}, // number + {{do2(push_short)}, 2, "PUSH_SHORT"}, // number number + {{do2(push_short_u)}, 2, "PUSH_SHORT_U"}, // number number + {{do2(push_long)}, 4, "PUSH_LONG"}, // number number number number + + {{do2(add)}, 0, "ADD"}, + {{do2(sub)}, 0, "SUB"}, + {{do2(mul)}, 0, "MUL"}, + {{do2(div_)}, 0, "DIV"}, + {{do2(min_)}, 0, "MIN"}, + {{do2(max_)}, 0, "MAX"}, + {{do2(neg)}, 0, "NEG"}, + {{do2(trunc8)}, 0, "TRUNC8"}, + {{do2(trunc16)}, 0, "TRUNC16"}, + + {{do2(cond)}, 0, "COND"}, + {{do2(and_)}, 0, "AND"}, // 0x10 + {{do2(or_)}, 0, "OR"}, + {{do2(not_)}, 0, "NOT"}, + {{do2(equal)}, 0, "EQUAL"}, + {{do2(not_eq_)}, 0, "NOT_EQ"}, + {{do2(less)}, 0, "LESS"}, + {{do2(gtr)}, 0, "GTR"}, + {{do2(less_eq)}, 0, "LESS_EQ"}, + {{do2(gtr_eq)}, 0, "GTR_EQ"}, // 0x18 + + {{do_(next), NILOP}, 0, "NEXT"}, + {{NILOP, NILOP}, 1, "NEXT_N"}, // number <= smap.end - map + {{do_(next), NILOP}, 0, "COPY_NEXT"}, + {{do_(put_glyph_8bit_obs), NILOP}, 1, "PUT_GLYPH_8BIT_OBS"}, // output_class + {{do_(put_subs_8bit_obs), NILOP}, 3, "PUT_SUBS_8BIT_OBS"}, // slot input_class output_class + {{do_(put_copy), NILOP}, 1, "PUT_COPY"}, // slot + {{do_(insert), NILOP}, 0, "INSERT"}, + {{do_(delete_), NILOP}, 0, "DELETE"}, // 0x20 + {{do_(assoc), NILOP}, VARARGS, "ASSOC"}, + {{NILOP ,do_(cntxt_item)}, 2, "CNTXT_ITEM"}, // slot offset + + {{do_(attr_set), NILOP}, 1, "ATTR_SET"}, // sattrnum + {{do_(attr_add), NILOP}, 1, "ATTR_ADD"}, // sattrnum + {{do_(attr_sub), NILOP}, 1, "ATTR_SUB"}, // sattrnum + {{do_(attr_set_slot), NILOP}, 1, "ATTR_SET_SLOT"}, // sattrnum + {{do_(iattr_set_slot), NILOP}, 2, "IATTR_SET_SLOT"}, // sattrnum attrid + {{do2(push_slot_attr)}, 2, "PUSH_SLOT_ATTR"}, // sattrnum slot + {{do2(push_glyph_attr_obs)}, 2, "PUSH_GLYPH_ATTR_OBS"}, // gattrnum slot + {{do2(push_glyph_metric)}, 3, "PUSH_GLYPH_METRIC"}, // gmetric slot level + {{do2(push_feat)}, 2, "PUSH_FEAT"}, // featidx slot + + {{do2(push_att_to_gattr_obs)}, 2, "PUSH_ATT_TO_GATTR_OBS"}, // gattrnum slot + {{do2(push_att_to_glyph_metric)}, 3, "PUSH_ATT_TO_GLYPH_METRIC"}, // gmetric slot level + {{do2(push_islot_attr)}, 3, "PUSH_ISLOT_ATTR"}, // sattrnum slot attrid + + {{NILOP,NILOP}, 3, "PUSH_IGLYPH_ATTR"}, + + {{do2(pop_ret)}, 0, "POP_RET"}, // 0x30 + {{do2(ret_zero)}, 0, "RET_ZERO"}, + {{do2(ret_true)}, 0, "RET_TRUE"}, + + {{do_(iattr_set), NILOP}, 2, "IATTR_SET"}, // sattrnum attrid + {{do_(iattr_add), NILOP}, 2, "IATTR_ADD"}, // sattrnum attrid + {{do_(iattr_sub), NILOP}, 2, "IATTR_SUB"}, // sattrnum attrid + {{do2(push_proc_state)}, 1, "PUSH_PROC_STATE"}, // dummy + {{do2(push_version)}, 0, "PUSH_VERSION"}, + {{do_(put_subs), NILOP}, 5, "PUT_SUBS"}, // slot input_class input_class output_class output_class + {{NILOP,NILOP}, 0, "PUT_SUBS2"}, + {{NILOP,NILOP}, 0, "PUT_SUBS3"}, + {{do_(put_glyph), NILOP}, 2, "PUT_GLYPH"}, // output_class output_class + {{do2(push_glyph_attr)}, 3, "PUSH_GLYPH_ATTR"}, // gattrnum gattrnum slot + {{do2(push_att_to_glyph_attr)}, 3, "PUSH_ATT_TO_GLYPH_ATTR"}, // gattrnum gattrnum slot + {{do2(bor)}, 0, "BITOR"}, + {{do2(band)}, 0, "BITAND"}, + {{do2(bnot)}, 0, "BITNOT"}, // 0x40 + {{do2(setbits)}, 4, "BITSET"}, + {{do_(set_feat), NILOP}, 2, "SET_FEAT"}, // featidx slot + // private opcodes for internal use only, comes after all other on disk opcodes. + {{do_(temp_copy), NILOP}, 0, "TEMP_COPY"} +}; diff --git a/gfx/graphite2/src/inc/opcodes.h b/gfx/graphite2/src/inc/opcodes.h new file mode 100644 index 0000000000..ff2f1741e2 --- /dev/null +++ b/gfx/graphite2/src/inc/opcodes.h @@ -0,0 +1,691 @@ +/* GRAPHITE2 LICENSING + + Copyright 2010, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +#pragma once +// This file will be pulled into and integrated into a machine implmentation +// DO NOT build directly and under no circumstances ever #include headers in +// here or you will break the direct_machine. +// +// Implementers' notes +// ================== +// You have access to a few primitives and the full C++ code: +// declare_params(n) Tells the interpreter how many bytes of parameter +// space to claim for this instruction uses and +// initialises the param pointer. You *must* before the +// first use of param. +// use_params(n) Claim n extra bytes of param space beyond what was +// claimed using delcare_param. +// param A const byte pointer for the parameter space claimed by +// this instruction. +// binop(op) Implement a binary operation on the stack using the +// specified C++ operator. +// NOT_IMPLEMENTED Any instruction body containing this will exit the +// program with an assertion error. Instructions that are +// not implemented should also be marked NILOP in the +// opcodes tables this will cause the code class to spot +// them in a live code stream and throw a runtime_error +// instead. +// push(n) Push the value n onto the stack. +// pop() Pop the top most value and return it. +// +// You have access to the following named fast 'registers': +// sp = The pointer to the current top of stack, the last value +// pushed. +// seg = A reference to the Segment this code is running over. +// is = The current slot index +// isb = The original base slot index at the start of this rule +// isf = The first positioned slot +// isl = The last positioned slot +// ip = The current instruction pointer +// endPos = Position of advance of last cluster +// dir = writing system directionality of the font + + +// #define NOT_IMPLEMENTED assert(false) +// #define NOT_IMPLEMENTED + +#define binop(op) const uint32 a = pop(); *sp = uint32(*sp) op a +#define sbinop(op) const int32 a = pop(); *sp = int32(*sp) op a +#define use_params(n) dp += n + +#define declare_params(n) const byte * param = dp; \ + use_params(n); + +#define push(n) { *++sp = n; } +#define pop() (*sp--) +#define slotat(x) (map[(x)]) +#define DIE { is=seg.last(); status = Machine::died_early; EXIT(1); } +#define POSITIONED 1 + +STARTOP(nop) + do {} while (0); +ENDOP + +STARTOP(push_byte) + declare_params(1); + push(int8(*param)); +ENDOP + +STARTOP(push_byte_u) + declare_params(1); + push(uint8(*param)); +ENDOP + +STARTOP(push_short) + declare_params(2); + const int16 r = int16(param[0]) << 8 + | uint8(param[1]); + push(r); +ENDOP + +STARTOP(push_short_u) + declare_params(2); + const uint16 r = uint16(param[0]) << 8 + | uint8(param[1]); + push(r); +ENDOP + +STARTOP(push_long) + declare_params(4); + const int32 r = int32(param[0]) << 24 + | uint32(param[1]) << 16 + | uint32(param[2]) << 8 + | uint8(param[3]); + push(r); +ENDOP + +STARTOP(add) + binop(+); +ENDOP + +STARTOP(sub) + binop(-); +ENDOP + +STARTOP(mul) + binop(*); +ENDOP + +STARTOP(div_) + const int32 b = pop(); + const int32 a = int32(*sp); + if (b == 0 || (a == std::numeric_limits<int32>::min() && b == -1)) DIE; + *sp = int32(*sp) / b; +ENDOP + +STARTOP(min_) + const int32 a = pop(), b = *sp; + if (a < b) *sp = a; +ENDOP + +STARTOP(max_) + const int32 a = pop(), b = *sp; + if (a > b) *sp = a; +ENDOP + +STARTOP(neg) + *sp = uint32(-int32(*sp)); +ENDOP + +STARTOP(trunc8) + *sp = uint8(*sp); +ENDOP + +STARTOP(trunc16) + *sp = uint16(*sp); +ENDOP + +STARTOP(cond) + const uint32 f = pop(), t = pop(), c = pop(); + push(c ? t : f); +ENDOP + +STARTOP(and_) + binop(&&); +ENDOP + +STARTOP(or_) + binop(||); +ENDOP + +STARTOP(not_) + *sp = !*sp; +ENDOP + +STARTOP(equal) + binop(==); +ENDOP + +STARTOP(not_eq_) + binop(!=); +ENDOP + +STARTOP(less) + sbinop(<); +ENDOP + +STARTOP(gtr) + sbinop(>); +ENDOP + +STARTOP(less_eq) + sbinop(<=); +ENDOP + +STARTOP(gtr_eq) + sbinop(>=); +ENDOP + +STARTOP(next) + if (map - &smap[0] >= int(smap.size())) DIE + if (is) + { + if (is == smap.highwater()) + smap.highpassed(true); + is = is->next(); + } + ++map; +ENDOP + +//STARTOP(next_n) +// use_params(1); +// NOT_IMPLEMENTED; + //declare_params(1); + //const size_t num = uint8(*param); +//ENDOP + +//STARTOP(copy_next) +// if (is) is = is->next(); +// ++map; +// ENDOP + +STARTOP(put_glyph_8bit_obs) + declare_params(1); + const unsigned int output_class = uint8(*param); + is->setGlyph(&seg, seg.getClassGlyph(output_class, 0)); +ENDOP + +STARTOP(put_subs_8bit_obs) + declare_params(3); + const int slot_ref = int8(param[0]); + const unsigned int input_class = uint8(param[1]), + output_class = uint8(param[2]); + uint16 index; + slotref slot = slotat(slot_ref); + if (slot) + { + index = seg.findClassIndex(input_class, slot->gid()); + is->setGlyph(&seg, seg.getClassGlyph(output_class, index)); + } +ENDOP + +STARTOP(put_copy) + declare_params(1); + const int slot_ref = int8(*param); + if (is && !is->isDeleted()) + { + slotref ref = slotat(slot_ref); + if (ref && ref != is) + { + int16 *tempUserAttrs = is->userAttrs(); + if (is->attachedTo() || is->firstChild()) DIE + Slot *prev = is->prev(); + Slot *next = is->next(); + memcpy(tempUserAttrs, ref->userAttrs(), seg.numAttrs() * sizeof(uint16)); + memcpy(is, ref, sizeof(Slot)); + is->firstChild(NULL); + is->nextSibling(NULL); + is->userAttrs(tempUserAttrs); + is->next(next); + is->prev(prev); + if (is->attachedTo()) + is->attachedTo()->child(is); + } + is->markCopied(false); + is->markDeleted(false); + } +ENDOP + +STARTOP(insert) + if (smap.decMax() <= 0) DIE; + Slot *newSlot = seg.newSlot(); + if (!newSlot) DIE; + Slot *iss = is; + while (iss && iss->isDeleted()) iss = iss->next(); + if (!iss) + { + if (seg.last()) + { + seg.last()->next(newSlot); + newSlot->prev(seg.last()); + newSlot->before(seg.last()->before()); + seg.last(newSlot); + } + else + { + seg.first(newSlot); + seg.last(newSlot); + } + } + else if (iss->prev()) + { + iss->prev()->next(newSlot); + newSlot->prev(iss->prev()); + newSlot->before(iss->prev()->after()); + } + else + { + newSlot->prev(NULL); + newSlot->before(iss->before()); + seg.first(newSlot); + } + newSlot->next(iss); + if (iss) + { + iss->prev(newSlot); + newSlot->originate(iss->original()); + newSlot->after(iss->before()); + } + else if (newSlot->prev()) + { + newSlot->originate(newSlot->prev()->original()); + newSlot->after(newSlot->prev()->after()); + } + else + { + newSlot->originate(seg.defaultOriginal()); + } + if (is == smap.highwater()) + smap.highpassed(false); + is = newSlot; + seg.extendLength(1); + if (map != &smap[-1]) + --map; +ENDOP + +STARTOP(delete_) + if (!is || is->isDeleted()) DIE + is->markDeleted(true); + if (is->prev()) + is->prev()->next(is->next()); + else + seg.first(is->next()); + + if (is->next()) + is->next()->prev(is->prev()); + else + seg.last(is->prev()); + + + if (is == smap.highwater()) + smap.highwater(is->next()); + if (is->prev()) + is = is->prev(); + seg.extendLength(-1); +ENDOP + +STARTOP(assoc) + declare_params(1); + unsigned int num = uint8(*param); + const int8 * assocs = reinterpret_cast<const int8 *>(param+1); + use_params(num); + int max = -1; + int min = -1; + + while (num-- > 0) + { + int sr = *assocs++; + slotref ts = slotat(sr); + if (ts && (min == -1 || ts->before() < min)) min = ts->before(); + if (ts && ts->after() > max) max = ts->after(); + } + if (min > -1) // implies max > -1 + { + is->before(min); + is->after(max); + } +ENDOP + +STARTOP(cntxt_item) + // It turns out this is a cunningly disguised condition forward jump. + declare_params(3); + const int is_arg = int8(param[0]); + const size_t iskip = uint8(param[1]), + dskip = uint8(param[2]); + + if (mapb + is_arg != map) + { + ip += iskip; + dp += dskip; + push(true); + } +ENDOP + +STARTOP(attr_set) + declare_params(1); + const attrCode slat = attrCode(uint8(*param)); + const int val = pop(); + is->setAttr(&seg, slat, 0, val, smap); +ENDOP + +STARTOP(attr_add) + declare_params(1); + const attrCode slat = attrCode(uint8(*param)); + const uint32_t val = pop(); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + uint32_t res = uint32_t(is->getAttr(&seg, slat, 0)); + is->setAttr(&seg, slat, 0, int32_t(val + res), smap); +ENDOP + +STARTOP(attr_sub) + declare_params(1); + const attrCode slat = attrCode(uint8(*param)); + const uint32_t val = pop(); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + uint32_t res = uint32_t(is->getAttr(&seg, slat, 0)); + is->setAttr(&seg, slat, 0, int32_t(res - val), smap); +ENDOP + +STARTOP(attr_set_slot) + declare_params(1); + const attrCode slat = attrCode(uint8(*param)); + const int offset = int(map - smap.begin())*int(slat == gr_slatAttTo); + const int val = pop() + offset; + is->setAttr(&seg, slat, offset, val, smap); +ENDOP + +STARTOP(iattr_set_slot) + declare_params(2); + const attrCode slat = attrCode(uint8(param[0])); + const uint8 idx = uint8(param[1]); + const int val = int(pop() + (map - smap.begin())*int(slat == gr_slatAttTo)); + is->setAttr(&seg, slat, idx, val, smap); +ENDOP + +STARTOP(push_slot_attr) + declare_params(2); + const attrCode slat = attrCode(uint8(param[0])); + const int slot_ref = int8(param[1]); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + slotref slot = slotat(slot_ref); + if (slot) + { + int res = slot->getAttr(&seg, slat, 0); + push(res); + } +ENDOP + +STARTOP(push_glyph_attr_obs) + declare_params(2); + const unsigned int glyph_attr = uint8(param[0]); + const int slot_ref = int8(param[1]); + slotref slot = slotat(slot_ref); + if (slot) + push(int32(seg.glyphAttr(slot->gid(), glyph_attr))); +ENDOP + +STARTOP(push_glyph_metric) + declare_params(3); + const unsigned int glyph_attr = uint8(param[0]); + const int slot_ref = int8(param[1]); + const signed int attr_level = uint8(param[2]); + slotref slot = slotat(slot_ref); + if (slot) + push(seg.getGlyphMetric(slot, glyph_attr, attr_level, dir)); +ENDOP + +STARTOP(push_feat) + declare_params(2); + const unsigned int feat = uint8(param[0]); + const int slot_ref = int8(param[1]); + slotref slot = slotat(slot_ref); + if (slot) + { + uint8 fid = seg.charinfo(slot->original())->fid(); + push(seg.getFeature(fid, feat)); + } +ENDOP + +STARTOP(push_att_to_gattr_obs) + declare_params(2); + const unsigned int glyph_attr = uint8(param[0]); + const int slot_ref = int8(param[1]); + slotref slot = slotat(slot_ref); + if (slot) + { + slotref att = slot->attachedTo(); + if (att) slot = att; + push(int32(seg.glyphAttr(slot->gid(), glyph_attr))); + } +ENDOP + +STARTOP(push_att_to_glyph_metric) + declare_params(3); + const unsigned int glyph_attr = uint8(param[0]); + const int slot_ref = int8(param[1]); + const signed int attr_level = uint8(param[2]); + slotref slot = slotat(slot_ref); + if (slot) + { + slotref att = slot->attachedTo(); + if (att) slot = att; + push(int32(seg.getGlyphMetric(slot, glyph_attr, attr_level, dir))); + } +ENDOP + +STARTOP(push_islot_attr) + declare_params(3); + const attrCode slat = attrCode(uint8(param[0])); + const int slot_ref = int8(param[1]), + idx = uint8(param[2]); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + slotref slot = slotat(slot_ref); + if (slot) + { + int res = slot->getAttr(&seg, slat, idx); + push(res); + } +ENDOP + +#if 0 +STARTOP(push_iglyph_attr) // not implemented + NOT_IMPLEMENTED; +ENDOP +#endif + +STARTOP(pop_ret) + const uint32 ret = pop(); + EXIT(ret); +ENDOP + +STARTOP(ret_zero) + EXIT(0); +ENDOP + +STARTOP(ret_true) + EXIT(1); +ENDOP + +STARTOP(iattr_set) + declare_params(2); + const attrCode slat = attrCode(uint8(param[0])); + const uint8 idx = uint8(param[1]); + const int val = pop(); + is->setAttr(&seg, slat, idx, val, smap); +ENDOP + +STARTOP(iattr_add) + declare_params(2); + const attrCode slat = attrCode(uint8(param[0])); + const uint8 idx = uint8(param[1]); + const uint32_t val = pop(); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + uint32_t res = uint32_t(is->getAttr(&seg, slat, idx)); + is->setAttr(&seg, slat, idx, int32_t(val + res), smap); +ENDOP + +STARTOP(iattr_sub) + declare_params(2); + const attrCode slat = attrCode(uint8(param[0])); + const uint8 idx = uint8(param[1]); + const uint32_t val = pop(); + if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0) + { + seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir()); + flags |= POSITIONED; + } + uint32_t res = uint32_t(is->getAttr(&seg, slat, idx)); + is->setAttr(&seg, slat, idx, int32_t(res - val), smap); +ENDOP + +STARTOP(push_proc_state) + use_params(1); + push(1); +ENDOP + +STARTOP(push_version) + push(0x00030000); +ENDOP + +STARTOP(put_subs) + declare_params(5); + const int slot_ref = int8(param[0]); + const unsigned int input_class = uint8(param[1]) << 8 + | uint8(param[2]); + const unsigned int output_class = uint8(param[3]) << 8 + | uint8(param[4]); + slotref slot = slotat(slot_ref); + if (slot) + { + int index = seg.findClassIndex(input_class, slot->gid()); + is->setGlyph(&seg, seg.getClassGlyph(output_class, index)); + } +ENDOP + +#if 0 +STARTOP(put_subs2) // not implemented + NOT_IMPLEMENTED; +ENDOP + +STARTOP(put_subs3) // not implemented + NOT_IMPLEMENTED; +ENDOP +#endif + +STARTOP(put_glyph) + declare_params(2); + const unsigned int output_class = uint8(param[0]) << 8 + | uint8(param[1]); + is->setGlyph(&seg, seg.getClassGlyph(output_class, 0)); +ENDOP + +STARTOP(push_glyph_attr) + declare_params(3); + const unsigned int glyph_attr = uint8(param[0]) << 8 + | uint8(param[1]); + const int slot_ref = int8(param[2]); + slotref slot = slotat(slot_ref); + if (slot) + push(int32(seg.glyphAttr(slot->gid(), glyph_attr))); +ENDOP + +STARTOP(push_att_to_glyph_attr) + declare_params(3); + const unsigned int glyph_attr = uint8(param[0]) << 8 + | uint8(param[1]); + const int slot_ref = int8(param[2]); + slotref slot = slotat(slot_ref); + if (slot) + { + slotref att = slot->attachedTo(); + if (att) slot = att; + push(int32(seg.glyphAttr(slot->gid(), glyph_attr))); + } +ENDOP + +STARTOP(temp_copy) + slotref newSlot = seg.newSlot(); + if (!newSlot || !is) DIE; + int16 *tempUserAttrs = newSlot->userAttrs(); + memcpy(newSlot, is, sizeof(Slot)); + memcpy(tempUserAttrs, is->userAttrs(), seg.numAttrs() * sizeof(uint16)); + newSlot->userAttrs(tempUserAttrs); + newSlot->markCopied(true); + *map = newSlot; +ENDOP + +STARTOP(band) + binop(&); +ENDOP + +STARTOP(bor) + binop(|); +ENDOP + +STARTOP(bnot) + *sp = ~*sp; +ENDOP + +STARTOP(setbits) + declare_params(4); + const uint16 m = uint16(param[0]) << 8 + | uint8(param[1]); + const uint16 v = uint16(param[2]) << 8 + | uint8(param[3]); + *sp = ((*sp) & ~m) | v; +ENDOP + +STARTOP(set_feat) + declare_params(2); + const unsigned int feat = uint8(param[0]); + const int slot_ref = int8(param[1]); + slotref slot = slotat(slot_ref); + if (slot) + { + uint8 fid = seg.charinfo(slot->original())->fid(); + seg.setFeature(fid, feat, pop()); + } +ENDOP diff --git a/gfx/graphite2/src/json.cpp b/gfx/graphite2/src/json.cpp new file mode 100644 index 0000000000..25f2190f71 --- /dev/null +++ b/gfx/graphite2/src/json.cpp @@ -0,0 +1,147 @@ +/* GRAPHITE2 LICENSING + + Copyright 2011, SIL International + All rights reserved. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of 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 + Lesser General Public License for more details. + + You should also have received a copy of the GNU Lesser General Public + License along with this library in the file named "LICENSE". + If not, write to the Free Software Foundation, 51 Franklin Street, + Suite 500, Boston, MA 02110-1335, USA or visit their web page on the + internet at http://www.fsf.org/licenses/lgpl.html. + +Alternatively, the contents of this file may be used under the terms of the +Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public +License, as published by the Free Software Foundation, either version 2 +of the License or (at your option) any later version. +*/ +// JSON debug logging +// Author: Tim Eves + +#if !defined GRAPHITE2_NTRACING + +#include <cstdio> +#include <limits> +#include "inc/json.h" + +#if defined(_MSC_VER) +#define FORMAT_INTMAX "%lli" +#define FORMAT_UINTMAX "%llu" +#else +#define FORMAT_INTMAX "%ji" +#define FORMAT_UINTMAX "%ju" +#endif + +using namespace graphite2; + +namespace +{ + enum + { + seq = ',', + obj='}', member=':', empty_obj='{', + arr=']', empty_arr='[' + }; +} + +const std::nullptr_t json::null = nullptr; + +inline +void json::context(const char current) throw() +{ + fprintf(_stream, "%c", *_context); + indent(); + *_context = current; +} + + +void json::indent(const int d) throw() +{ + if (*_context == member || (_flatten && _flatten < _context)) + fputc(' ', _stream); + else + fprintf(_stream, "\n%*s", 4*int(_context - _contexts + d), ""); +} + + +inline +void json::push_context(const char prefix, const char suffix) throw() +{ + assert(_context - _contexts < ptrdiff_t(sizeof _contexts)); + + if (_context == _contexts) + *_context = suffix; + else + context(suffix); + *++_context = prefix; +} + + +void json::pop_context() throw() +{ + assert(_context > _contexts); + + if (*_context == seq) indent(-1); + else fputc(*_context, _stream); + + fputc(*--_context, _stream); + if (_context == _contexts) fputc('\n', _stream); + fflush(_stream); + + if (_flatten >= _context) _flatten = 0; + *_context = seq; +} + + +// These four functions cannot be inlined as pointers to these +// functions are needed for operator << (_context_t) to work. +void json::flat(json & j) throw() { if (!j._flatten) j._flatten = j._context; } +void json::close(json & j) throw() { j.pop_context(); } +void json::object(json & j) throw() { j.push_context('{', '}'); } +void json::array(json & j) throw() { j.push_context('[', ']'); } +void json::item(json & j) throw() +{ + while (j._context > j._contexts+1 && j._context[-1] != arr) + j.pop_context(); +} + + +json & json::operator << (json::string s) throw() +{ + const char ctxt = _context[-1] == obj ? *_context == member ? seq : member : seq; + context(ctxt); + fprintf(_stream, "\"%s\"", s); + if (ctxt == member) fputc(' ', _stream); + + return *this; +} + +json & json::operator << (json::number f) throw() +{ + context(seq); + if (std::numeric_limits<json::number>::infinity() == f) + fputs("Infinity", _stream); + else if (-std::numeric_limits<json::number>::infinity() == f) + fputs("-Infinity", _stream); + else if (std::numeric_limits<json::number>::quiet_NaN() == f || + std::numeric_limits<json::number>::signaling_NaN() == f) + fputs("NaN", _stream); + else + fprintf(_stream, "%g", f); + return *this; +} +json & json::operator << (json::integer d) throw() { context(seq); fprintf(_stream, FORMAT_INTMAX, intmax_t(d)); return *this; } +json & json::operator << (json::integer_u d) throw() { context(seq); fprintf(_stream, FORMAT_UINTMAX, uintmax_t(d)); return *this; } +json & json::operator << (json::boolean b) throw() { context(seq); fputs(b ? "true" : "false", _stream); return *this; } +json & json::operator << (std::nullptr_t) throw() { context(seq); fputs("null",_stream); return *this; } + +#endif diff --git a/gfx/graphite2/src/moz.build b/gfx/graphite2/src/moz.build new file mode 100755 index 0000000000..02fb5c3b07 --- /dev/null +++ b/gfx/graphite2/src/moz.build @@ -0,0 +1,35 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +include("sources.mozbuild") + +# This should contain all of the _PUBLIC_HEADERS from files.mk +EXPORTS.graphite2 += [ + '../geckoextra/include/GraphiteExtra.h', + '../geckoextra/include/GraphiteStructsForRLBox.h', + '../include/graphite2/Font.h', + '../include/graphite2/Log.h', + '../include/graphite2/Segment.h', + '../include/graphite2/Types.h', +] + +if CONFIG['CC_TYPE'] in ('clang', 'gcc'): + UNIFIED_SOURCES += [ + 'direct_machine.cpp' + ] +else: + UNIFIED_SOURCES += [ + 'call_machine.cpp' + ] +UNIFIED_SOURCES += graphite_sources + +for k, v in graphite_defines: + DEFINES[k] = v + +# We allow warnings for third-party code that can be updated from upstream. +AllowCompilerWarnings() + +FINAL_LIBRARY = 'gkmedias' diff --git a/gfx/graphite2/src/sources.mozbuild b/gfx/graphite2/src/sources.mozbuild new file mode 100755 index 0000000000..f1b4e26447 --- /dev/null +++ b/gfx/graphite2/src/sources.mozbuild @@ -0,0 +1,54 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +# This should contain all of the _SOURCES from files.mk, except *_machine.cpp +graphite_sources = [ + '../geckoextra/src/GraphiteExtra.cpp', + 'CmapCache.cpp', + 'Code.cpp', + 'Collider.cpp', + 'Decompressor.cpp', + 'Face.cpp', + 'FeatureMap.cpp', + # 'FileFace.cpp', # Unused file. + 'Font.cpp', + 'GlyphCache.cpp', + 'GlyphFace.cpp', + 'gr_char_info.cpp', + 'gr_face.cpp', + 'gr_features.cpp', + 'gr_font.cpp', + # 'gr_logging.cpp', # Unused file. + 'gr_segment.cpp', + 'gr_slot.cpp', + 'Intervals.cpp', + # 'json.cpp', # Unused file. + 'Justifier.cpp', + 'NameTable.cpp', + 'Pass.cpp', + 'Position.cpp', + 'Segment.cpp', + 'Silf.cpp', + 'Slot.cpp', + 'Sparse.cpp', + 'TtfUtil.cpp', + 'UtfCodec.cpp', +] + +graphite_defines = [ + ('PACKAGE_VERSION', '"moz"'), + ('PACKAGE_BUGREPORT', '"http://bugzilla.mozilla.org/"'), + # tell graphite2 not to export symbols, we'll be linking it directly with + # thebes + ('GRAPHITE2_STATIC', True), + # provide a custom header that overrides malloc() and friends, + # to ensure safe OOM handling. + ('GRAPHITE2_CUSTOM_HEADER', '"MozGrMalloc.h"'), +] + +# disable features we don't need in the graphite2 code, to reduce code size +for var in ('GRAPHITE2_NFILEFACE', 'GRAPHITE2_NTRACING', 'GRAPHITE2_NSEGCACHE'): + graphite_defines.append((var, True)) |