{"diffoscope-json-version": 1, "source1": "/srv/reproducible-results/rbuild-debian/r-b-build.DDpJ2nCv/b1/libgnatcoll_21.0.0-4_arm64.changes", "source2": "/srv/reproducible-results/rbuild-debian/r-b-build.DDpJ2nCv/b2/libgnatcoll_21.0.0-4_arm64.changes", "unified_diff": null, "details": [{"source1": "Files", "source2": "Files", "unified_diff": "@@ -1,5 +1,5 @@\n \n- d0f60c37451c5a632eb360f1e1c14207 515324 doc optional libgnatcoll-doc_21.0.0-4_all.deb\n- a55dd161a2deefd95e86e8035affa962 3183064 debug optional libgnatcoll19-dbgsym_21.0.0-4_arm64.deb\n+ 23fda4cb2d47c4dc7c0c5ae359320674 546124 doc optional libgnatcoll-doc_21.0.0-4_all.deb\n+ 520aebbd73a2a565db24c5b4094e20b3 3183088 debug optional libgnatcoll19-dbgsym_21.0.0-4_arm64.deb\n 51918aaf481f6ddbdda4124d5e7bada6 2167196 libdevel optional libgnatcoll19-dev_21.0.0-4_arm64.deb\n- 9e1bf14642c9d35829506ee189505deb 1340348 libs optional libgnatcoll19_21.0.0-4_arm64.deb\n+ 8d56bbebf451f8403f3aa9e78bdd1eb7 1340348 libs optional libgnatcoll19_21.0.0-4_arm64.deb\n"}, {"source1": "libgnatcoll-doc_21.0.0-4_all.deb", "source2": "libgnatcoll-doc_21.0.0-4_all.deb", "unified_diff": null, "details": [{"source1": "file list", "source2": "file list", "unified_diff": "@@ -1,3 +1,3 @@\n -rw-r--r-- 0 0 0 4 2020-12-22 09:58:09.000000 debian-binary\n--rw-r--r-- 0 0 0 3380 2020-12-22 09:58:09.000000 control.tar.xz\n--rw-r--r-- 0 0 0 511752 2020-12-22 09:58:09.000000 data.tar.xz\n+-rw-r--r-- 0 0 0 3388 2020-12-22 09:58:09.000000 control.tar.xz\n+-rw-r--r-- 0 0 0 542544 2020-12-22 09:58:09.000000 data.tar.xz\n"}, {"source1": "control.tar.xz", "source2": "control.tar.xz", "unified_diff": null, "details": [{"source1": "control.tar", "source2": "control.tar", "unified_diff": null, "details": [{"source1": "./control", "source2": "./control", "unified_diff": "@@ -1,13 +1,13 @@\n Package: libgnatcoll-doc\n Source: libgnatcoll\n Version: 21.0.0-4\n Architecture: all\n Maintainer: Nicolas Boulenguez The package GNATCOLL.Boyer_Moore provides one such optimize algorithm,\n although there exists several others which might be more efficient depending\n on the pattern. It deals with string searching, and does not handle regular expressions for\n instance. This algorithm needs to preprocess its key (the searched string), but does\n not need to perform any specific analysis of the string to be searched.\n-Its execution time can be sub-linear: it doesn't need to actually check\n+Its execution time can be sub-linear: it doesn\u2019t need to actually check\n every character of the string to be searched, and will skip over some of\n them. The worst case for this algorithm has been proved to need approximately\n 3 * N comparisons, hence the algorithm has a complexity of O(n). The longer the key, the faster the algorithm in general, since that provides\n more context as to how many characters can be skipped when a non-matching\n character is found.. We will not go into the details of the algorithm, although a general\n description follows: when the pattern is being preprocessed, Boyer-Moore\n computes how many characters can be skipped if an incorrect match is\n found at that point, depending on which character was read.\n In addition, this algorithm tries to match the key starting from its end,\n which in general provides a greater number of characters to skip. For instance, if you are looking for "ABC" in the string "ABDEFG" at the\n-first position, the algorithm will compare "C" and "D". Since "D" does not\n-appear in the key "ABC", it knows that it can immediately skip 3 characters\n-and start the search after "D". For instance, if you are looking for \u201cABC\u201d in the string \u201cABDEFG\u201d at the\n+first position, the algorithm will compare \u201cC\u201d and \u201cD\u201d. Since \u201cD\u201d does not\n+appear in the key \u201cABC\u201d, it knows that it can immediately skip 3 characters\n+and start the search after \u201cD\u201d. Using this package is extremely easy, and it has only a limited API: Parallel compilation (default is 0, which uses all available cores) For cross-compilation, auto-detected for native platforms For out-of-tree build Controls whether shared and static-pic library variants should be built: yes (default) or no. If you only intend to use static libraries, specify 'no'. Controls whether shared and static-pic library variants should be built: yes (default) or no. If you only intend to use static libraries, specify \u2018no\u2019. Module-specific: Whether MMAP is supported: yes (default) or no; this has no effect on Windows where embedded MMAP implementation is always provided. Whether MADVISE: yes (default) or no; this has no effect on Windows where MADVISE functionality is unavailable Note that this command does not try to recompile GNATColl, so you must build\n it first. This command will install all library variants that were built. Your application can now use the GNATColl code through a project file, by\n adding a If you wish to install in a different location than was specified at\n-configure time, you can override the "prefix" variable from the command line,\n+configure time, you can override the \u201cprefix\u201d variable from the command line,\n for instance: This does not require any recompilation.declare\n Str : constant String := "ABDEABCFGABC";\n Key : Pattern;\n Index : Integer;\n begin\n Compile (Key, "ABC");\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -21,31 +21,31 @@\n The package GNATCOLL.Boyer_Moore provides one such optimize algorithm, although\n there exists several others which might be more efficient depending on the\n pattern.\n It deals with string searching, and does not handle regular expressions for\n instance.\n This algorithm needs to preprocess its key (the searched string), but does not\n need to perform any specific analysis of the string to be searched. Its\n-execution time can be sub-linear: it doesn't need to actually check every\n+execution time can be sub-linear: it doesn\u00e2\u0080\u0099t need to actually check every\n character of the string to be searched, and will skip over some of them. The\n worst case for this algorithm has been proved to need approximately 3 * N\n comparisons, hence the algorithm has a complexity of O(n).\n The longer the key, the faster the algorithm in general, since that provides\n more context as to how many characters can be skipped when a non-matching\n character is found..\n We will not go into the details of the algorithm, although a general\n description follows: when the pattern is being preprocessed, Boyer-Moore\n computes how many characters can be skipped if an incorrect match is found at\n that point, depending on which character was read. In addition, this algorithm\n tries to match the key starting from its end, which in general provides a\n greater number of characters to skip.\n-For instance, if you are looking for \"ABC\" in the string \"ABDEFG\" at the first\n-position, the algorithm will compare \"C\" and \"D\". Since \"D\" does not appear in\n-the key \"ABC\", it knows that it can immediately skip 3 characters and start the\n-search after \"D\".\n+For instance, if you are looking for \u00e2\u0080\u009cABC\u00e2\u0080\u009d in the string \u00e2\u0080\u009cABDEFG\u00e2\u0080\u009d at\n+the first position, the algorithm will compare \u00e2\u0080\u009cC\u00e2\u0080\u009d and \u00e2\u0080\u009cD\u00e2\u0080\u009d. Since\n+\u00e2\u0080\u009cD\u00e2\u0080\u009d does not appear in the key \u00e2\u0080\u009cABC\u00e2\u0080\u009d, it knows that it can immediately\n+skip 3 characters and start the search after \u00e2\u0080\u009cD\u00e2\u0080\u009d.\n Using this package is extremely easy, and it has only a limited API:\n declare\n Str : constant String := \"ABDEABCFGABC\";\n Key : Pattern;\n Index : Integer;\n begin\n Compile (Key, \"ABC\");\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/building.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/building.html", "unified_diff": "@@ -66,15 +66,15 @@\n \n
\n
with
clause to gnatcoll.gpr
.make prefix=/alternate/directory install\n
There are lots of possible formats for such configuration files: you could\n chose to use an XML file (but these are in general hard to edit manually),\n a binary file, or any other format. One format that is found very often is\n the one used by a lot of Windows applications (the .ini
file format).
GNATCOLL.Config is independent from the actual format you are using,\n and you can add your own parsers compatible with the GNATCOLL.Config\n-API. Out of the box, support is provided for .ini
files, so let's\n+API. Out of the box, support is provided for .ini
files, so let\u2019s\n detail this very simply format:
# A single-line comment\n [Section1]\n key1 = value\n key2=value2\n \n [Section2]\n key1 = value3\n
Comments are (by default) started with '#' signs, but you can\n+
Comments are (by default) started with \u2018#\u2019 signs, but you can\n configure that and use any prefix you want. The (key, value) pairs\n are then organized into optional sections (if you do not start a section\n-before the first key, that key will be considered as part of the ""\n+before the first key, that key will be considered as part of the \u201c\u201d\n section). A section then extends until the start of the next section.
\nThe values associated with the various keys can be strings, integers or\n booleans. Spaces on the left and right of the values and keys are trimmed,\n and therefore irrelevant.
\nSupport is providing for interpreting the values as file or directory\n names. In such a case, if a relative name is specified in the configuration\n file it will be assumed to be relative to the location of the configuration\n@@ -114,19 +114,19 @@\n Put_Line (Config.Get ("section.key")); -- Ada05 dotted notation\n \n \n
Again, the values are by default read as strings, but you can interpret\n them as integers, booleans or files.
\nA third layer is provided in GNATCOLL.Config. This solves the issue\n of possible typos in code: in the above example, we could have made a typo\n-when writting "section.key". That would only be detected at run\n+when writting \u201csection.key\u201d. That would only be detected at run\n time. Another issue is that we might decide to rename the key in the\n configuration file. We would then have to go through all the application\n-code to find all the places where this key is references (and that can't\n-be based on cross-references generated by the compiler, since that's inside\n+code to find all the places where this key is references (and that can\u2019t\n+be based on cross-references generated by the compiler, since that\u2019s inside\n a string).
\nTo solve this issue, it is possible to declare a set of constants that\n represent the keys, and then use these to access the values, solving the\n two problems above:
\nSection_Key1 : constant Config_Key := Create ("Key1", "Section");\n Section_Key2 : constant Config_Key := Create ("Key2", "Section");\n \n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -19,27 +19,27 @@\n interactively. However, it is possible to use them for both cases.\n There are lots of possible formats for such configuration files: you could\n chose to use an XML file (but these are in general hard to edit manually), a\n binary file, or any other format. One format that is found very often is the\n one used by a lot of Windows applications (the .ini file format).\n GNATCOLL.Configis independent from the actual format you are using, and you can\n add your own parsers compatible with theGNATCOLL.ConfigAPI. Out of the box,\n-support is provided for .ini files, so let's detail this very simply format:\n+support is provided for .ini files, so let\u00e2\u0080\u0099s detail this very simply format:\n # A single-line comment\n [Section1]\n key1 = value\n key2=value2\n \n [Section2]\n key1 = value3\n-Comments are (by default) started with'#'signs, but you can configure that and\n-use any prefix you want. The(key, value)pairs are then organized into optional\n-sections (if you do not start a section before the first key, that key will be\n-considered as part of the\"\"section). A section then extends until the start of\n-the next section.\n+Comments are (by default) started with\u00e2\u0080\u0098#\u00e2\u0080\u0099signs, but you can configure that\n+and use any prefix you want. The(key, value)pairs are then organized into\n+optional sections (if you do not start a section before the first key, that key\n+will be considered as part of the\u00e2\u0080\u009c\u00e2\u0080\u009dsection). A section then extends until\n+the start of the next section.\n The values associated with the various keys can be strings, integers or\n booleans. Spaces on the left and right of the values and keys are trimmed, and\n therefore irrelevant.\n Support is providing for interpreting the values as file or directory names. In\n such a case, if a relative name is specified in the configuration file it will\n be assumed to be relative to the location of the configuration file (by\n default, but you can also configure that).\n@@ -76,19 +76,19 @@\n end;\n \n Put_Line (Config.Get (\"section.key\")); -- Ada05 dotted notation\n Again, the values are by default read as strings, but you can interpret them as\n integers, booleans or files.\n A third layer is provided inGNATCOLL.Config. This solves the issue of possible\n typos in code: in the above example, we could have made a typo when\n-writting\"section.key\". That would only be detected at run time. Another issue\n-is that we might decide to rename the key in the configuration file. We would\n-then have to go through all the application code to find all the places where\n-this key is references (and that can't be based on cross-references generated\n-by the compiler, since that's inside a string).\n+writting\u00e2\u0080\u009csection.key\u00e2\u0080\u009d. That would only be detected at run time. Another\n+issue is that we might decide to rename the key in the configuration file. We\n+would then have to go through all the application code to find all the places\n+where this key is references (and that can\u00e2\u0080\u0099t be based on cross-references\n+generated by the compiler, since that\u00e2\u0080\u0099s inside a string).\n To solve this issue, it is possible to declare a set of constants that\n represent the keys, and then use these to access the values, solving the two\n problems above:\n Section_Key1 : constant Config_Key := Create (\"Key1\", \"Section\");\n Section_Key2 : constant Config_Key := Create (\"Key2\", \"Section\");\n \n Put_Line (Section_Key1.Get);\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/email.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/email.html", "unified_diff": "@@ -169,15 +169,15 @@\n
The subprograms in GNATCOLL.Email can also be used to create a message\n from scratch. Alternatively, if you have already parsed a message, you\n can alter it, or easily generate a reply to it (using the Reply_To\n subprogram. The latter will preset some headers, so that message threading\n-is preserved in the user's mailers.
\n+is preserved in the user\u2019s mailers.\nThe package GNATCOLL.Paragraph_Filling provides several algorithms for\n-filling paragraphs---formatting them to take up the minimal number of lines and\n+filling paragraphs\u2014formatting them to take up the minimal number of lines and\n to look better. Knuth_Fill is based on an algorithm invented by Donald\n Knuth, and used in TeX. Pretty_Fill uses a different algorithm, which\n was judged by some to produce more aesthetically pleasing output.
\nMore detailed documentation may be found in the comments in the package spec.
\nGNATColl provides the package GNATCOLL.Geometry. This\n package includes a number of primitive operations on geometric figures\n like points, segments, lines, circles, rectangles and polygons.\n-In particular, you can compute their intersections, the distances,...
\n+In particular, you can compute their intersections, the distances,\u2026\nThis package is generic, so that you can specify the type of coordinates\n you wish to handle:
\ndeclare\n package Float_Geometry is new GNATCOLL.Geometry (Float);\n use Float_Geometry;\n \n P1 : constant Point := (1.0, 1.0);\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -12,15 +12,15 @@\n * previous |\n * GNATColl_0.0_documentation \u00bb\n * 16. Geometry: primitive geometric operations\n ****** 16. Geometry: primitive geometric operations\u00c2\u00b6 ******\n GNATColl provides the packageGNATCOLL.Geometry. This package includes a number\n of primitive operations on geometric figures like points, segments, lines,\n circles, rectangles and polygons. In particular, you can compute their\n-intersections, the distances,...\n+intersections, the distances,\u00e2\u0080\u00a6\n This package is generic, so that you can specify the type of coordinates you\n wish to handle:\n declare\n package Float_Geometry is new GNATCOLL.Geometry (Float);\n use Float_Geometry;\n \n P1 : constant Point := (1.0, 1.0);\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/json.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/json.html", "unified_diff": "@@ -41,15 +41,15 @@\n \n \n \n 21. JSON: handling JSON data\u00b6
\n JSON is a format often used on the web\n to communicate between a server and a browser, or between servers. It plays a\n similar role to XML, but it has a much lighter syntax. On the other hand, it\n-doesn't provide advanced features like validation, which XML provides.
\n+doesn\u2019t provide advanced features like validation, which XML provides.\n The GNATCOLL.JSON
package provides an Ada API to decode JSON data from\n strings and to encode that data back to strings. It also allows one to create\n and modify JSON data.
\n \n 21.1. API overview\u00b6
\n The entry point for this API is the JSON_Value
data type. JSON values can\n be any of:
\n@@ -108,17 +108,17 @@\n \n -- Now serialize it. The call below will display:\n -- {"field1": 1, "name": "thename"}\n Put_Line (My_Obj.Write);\n end JSON_Test;\n \n \n-The above uses the Ada 2005 "dot notation" to call primitive operations\n-(.Set_Field
, .Write
), but naturally the more traditional "prefix\n-notation" is also available:
\n+The above uses the Ada 2005 \u201cdot notation\u201d to call primitive operations\n+(.Set_Field
, .Write
), but naturally the more traditional \u201cprefix\n+notation\u201d is also available:
\n Set_Field (My_Obj, "field1", Create (1));\n
\n \n It is also possible to create JSON arrays. These are not tagged types, so the\n prefix notation has to be used. Here is a further example that sets another\n field in the object we had before (My_Obj
):
\n declare\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -11,15 +11,15 @@\n * next |\n * previous |\n * GNATColl_0.0_documentation \u00bb\n * 21. JSON: handling JSON data\n ****** 21. JSON: handling JSON data\u00c2\u00b6 ******\n JSON is a format often used on the web to communicate between a server and a\n browser, or between servers. It plays a similar role to XML, but it has a much\n-lighter syntax. On the other hand, it doesn't provide advanced features like\n+lighter syntax. On the other hand, it doesn\u00e2\u0080\u0099t provide advanced features like\n validation, which XML provides.\n The GNATCOLL.JSON package provides an Ada API to decode JSON data from strings\n and to encode that data back to strings. It also allows one to create and\n modify JSON data.\n ***** 21.1. API overview\u00c2\u00b6 *****\n The entry point for this API is the JSON_Value data type. JSON values can be\n any of:\n@@ -65,17 +65,17 @@\n My_Obj.Set_Field (\"field1\", Create (1));\n My_Obj.Set_Field (\"name\", \"theName\");\n \n -- Now serialize it. The call below will display:\n -- {\"field1\": 1, \"name\": \"thename\"}\n Put_Line (My_Obj.Write);\n end JSON_Test;\n-The above uses the Ada 2005 \"dot notation\" to call primitive operations\n-(.Set_Field, .Write), but naturally the more traditional \"prefix notation\" is\n-also available:\n+The above uses the Ada 2005 \u00e2\u0080\u009cdot notation\u00e2\u0080\u009d to call primitive operations\n+(.Set_Field, .Write), but naturally the more traditional \u00e2\u0080\u009cprefix notation\u00e2\u0080\u009d\n+is also available:\n Set_Field (My_Obj, \"field1\", Create (1));\n It is also possible to create JSON arrays. These are not tagged types, so the\n prefix notation has to be used. Here is a further example that sets another\n field in the object we had before (My_Obj):\n declare\n -- Create a JSON array\n My_Arr : JSON_Array := Empty_Array;\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/mmap.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/mmap.html", "unified_diff": "@@ -65,29 +65,29 @@\n by the system. To modify the file, you just modify the contents of the\n memory, and do not worry about writing the file back to the disk.\n When your application does not need to read the whole contents of the file,\n the speed up can be several orders of magnitude faster than read().\n Even when you need to read the whole contents, using mmap() is\n still two or three times faster, which is especially interesting on big\n files.
\n-GNATColl's GNATCOLL.Mmap package provides a high-level abstraction\n+
GNATColl\u2019s GNATCOLL.Mmap package provides a high-level abstraction\n on top of the mmap system call. As for most other packages in\n GNATColl, it also nicely handles the case where your system does not\n actually support mmap, and will in that case fallback on using\n read and write transparently. In such a case, your application\n will perform a little slower, but you do not have to modify your code to\n adapt it to the new system.
\n Due to the low-level C API that is needed underneath, the various subprograms\n in this package do not directly manipulate Ada strings with valid bounds.\n Instead, a new type Str_Access was defined. It does not contain the\n bounds of the string, and therefore you cannot use the usual\n-'First and 'Last attributes on that string. But there are other\n+\u2018First and \u2018Last attributes on that string. But there are other\n subprograms that provide those values.
\n Here is how to read a whole file at once. This is what your code will use\n-in most cases, unless you expect to read files bigger than Integer'Last\n+in most cases, unless you expect to read files bigger than Integer\u2019Last\n bytes long. In such cases you need to read chunks of the file separately.\n The mmap system call is such that its performance does not depend on\n the size of the file your are mapping. Of course, this could be a problem if\n GNATCOLL.Mmap falls back on calling read, since in that case it\n needs to allocate as much memory as your file. Therefore in some cases you\n will also want to only read chunks of the file at once:
\n declare\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -34,33 +34,33 @@\n actual contents is temporarily mapped in memory by the system. To modify the\n file, you just modify the contents of the memory, and do not worry about\n writing the file back to the disk.\n When your application does not need to read the whole contents of the file, the\n speed up can be several orders of magnitude faster thanread(). Even when you\n need to read the whole contents, usingmmap()is still two or three times faster,\n which is especially interesting on big files.\n-GNATColl'sGNATCOLL.Mmappackage provides a high-level abstraction on top of\n+GNATColl\u00e2\u0080\u0099sGNATCOLL.Mmappackage provides a high-level abstraction on top of\n themmapsystem call. As for most other packages in GNATColl, it also nicely\n handles the case where your system does not actually supportmmap, and will in\n that case fallback on usingreadandwritetransparently. In such a case, your\n application will perform a little slower, but you do not have to modify your\n code to adapt it to the new system.\n Due to the low-level C API that is needed underneath, the various subprograms\n in this package do not directly manipulate Ada strings with valid bounds.\n Instead, a new typeStr_Accesswas defined. It does not contain the bounds of the\n-string, and therefore you cannot use the usual'Firstand'Lastattributes on that\n-string. But there are other subprograms that provide those values.\n+string, and therefore you cannot use the usual\u00e2\u0080\u0098Firstand\u00e2\u0080\u0098Lastattributes on\n+that string. But there are other subprograms that provide those values.\n Here is how to read a whole file at once. This is what your code will use in\n-most cases, unless you expect to read files bigger thanInteger'Lastbytes long.\n-In such cases you need to read chunks of the file separately. Themmapsystem\n-call is such that its performance does not depend on the size of the file your\n-are mapping. Of course, this could be a problem ifGNATCOLL.Mmapfalls back on\n-callingread, since in that case it needs to allocate as much memory as your\n-file. Therefore in some cases you will also want to only read chunks of the\n-file at once:\n+most cases, unless you expect to read files bigger thanInteger\u00e2\u0080\u0099Lastbytes\n+long. In such cases you need to read chunks of the file separately.\n+Themmapsystem call is such that its performance does not depend on the size of\n+the file your are mapping. Of course, this could be a problem\n+ifGNATCOLL.Mmapfalls back on callingread, since in that case it needs to\n+allocate as much memory as your file. Therefore in some cases you will also\n+want to only read chunks of the file at once:\n declare\n File : Mapped_File;\n Reg : Mapped_Region;\n Str : Long.Str_Access;\n begin\n File := Open_Read (\"/tmp/file_on_disk\");\n Reg := Read (File); *-- map the whole file*\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/refcount.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/refcount.html", "unified_diff": "@@ -117,15 +117,15 @@\n \n type My_Type is new Weak_Refcounted with...;\n \n package Pointers is new Weakref_Pointers (My_Type);\n
\n \n The above code can be used instead of the code in the first example, and\n-provides the same capability (smart pointers, reference counted types,...).\n+provides the same capability (smart pointers, reference counted types,\u2026).\n However, the type My_Type is slightly bigger, but can be used to\n create weak references:
\n WR : Weak_Ref;\n \n declare\n R : Ref;\n Tmp : My_Type := ...;\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -78,15 +78,15 @@\n with GNATCOLL.Refcount.Weakref;\n use GNATCOLL.Refcount.Weakref;\n \n type My_Type is new Weak_Refcounted with...;\n \n package Pointers is new Weakref_Pointers (My_Type);\n The above code can be used instead of the code in the first example, and\n-provides the same capability (smart pointers, reference counted types,...).\n+provides the same capability (smart pointers, reference counted types,\u00e2\u0080\u00a6).\n However, the typeMy_Typeis slightly bigger, but can be used to create weak\n references:\n WR : Weak_Ref;\n \n declare\n R : Ref;\n Tmp : My_Type := ...;\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/scripting.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/scripting.html", "unified_diff": "@@ -42,20 +42,20 @@\n \n \n 3. Scripts: Embedding script languages\u00b6
\n In a lot of contexts, you want to give the possibility to users to extend\n your application. This can be done in several ways: define an Ada API from\n which they can build dynamically loadable modules, provide the whole source\n code to your application and let users recompile it, interface with a simpler\n-scripting languages,...
\n+scripting languages,\u2026\n Dynamically loadable modules can be loaded on demand, as their name indicate.\n However, they generally require a relatively complex environment to build,\n and are somewhat less portable. But when your users are familiar with Ada,\n they provide a programming environment in which they are comfortable.\n-As usual, changing the module requires recompilation, re-installation,...
\n+As usual, changing the module requires recompilation, re-installation,\u2026\n Providing the source code to your application is generally even more\n complex for users. This requires an even more complex setup, your application\n is generally too big for users to dive into, and modifications done by one\n users are hard to provide to other users, or will be lost when you\n distribute a new version of your application.
\n The third solution is to embed one or more scripting languages in your\n application, and export some functions to it. This often requires your users\n@@ -64,103 +64,103 @@\n console. The resulting scripts can easily be redistributed to other users or\n even distributed with future versions of your application.
\n The module in GNATColl helps you implement the third solution. It was\n used extensively in the GPS programming environment for its python interface.
\n Each of the scripting language is optional
\n This module can be compiled with any of these languages as an optional\n dependency (except for the shell language, which is always built-in, but is\n-extremely minimal, and doesn't have to be loaded at run time anyway).\n+extremely minimal, and doesn\u2019t have to be loaded at run time anyway).\n If the necessary libraries are found on the system, GNATColl will\n be build with support for the corresponding language, but your application\n can chose at run time whether or not to activate the support for a specific\n language.
\n Use a scripting language to provide an automatic testing framework for\n your application.
\n The GPS environment uses python command for its automatic test suite,\n including graphical tests such as pressing on a button, selecting a\n-menu,...
\n+menu,\u2026\n \n 3.1. Supported languages\u00b6
\n The module provides built-in support for several scripting languages, and\n-other languages can "easily" be added. Your application does not change\n+other languages can \u201ceasily\u201d be added. Your application does not change\n when new languages are added, since the interface to export subprograms\n and classes to the scripting languages is language-neutral, and will\n automatically export to all known scripting languages.
\n The Core component provides support for the following language:
\n \n-- Shell
This is a very simple-minded scripting language, which doesn't provide\n+
- Shell
This is a very simple-minded scripting language, which doesn\u2019t provide\n flow-control instructions (The Shell language).
\n \n
\n Optional components add support for other languages, e.g. Python. Please\n-refer to the corresponding component's documentation.
\n+refer to the corresponding component\u2019s documentation.\n \n 3.1.1. The Shell language\u00b6
\n The shell language was initially developed in the context of the GPS\n programming environment, as a way to embed scripting commands in XML\n configuration files.
\n In this language, you can execute any of the commands exported by the\n application, passing any number of arguments they need. Arguments to function\n calls can, but need not, be quoted. Quoting is only mandatory when they\n-contain spaces, newline characters, or double-quotes ('"'). To quote an\n+contain spaces, newline characters, or double-quotes (\u2018\u201d\u2019). To quote an\n argument, surround it by double-quotes, and precede each double-quote it\n contains by a backslash character. Another way of quoting is similar to\n what python provides, which is to triple-quote the argument, i.e. surround it\n-by '"""' on each side. In such a case, any special character (in particular\n+by \u2018\u201d\u201d\u201d\u2019 on each side. In such a case, any special character (in particular\n other double-quotes or backslashes) lose their special meaning and are just\n taken as part of the argument. This is in particular useful when you do not\n know in advance the contents of the argument you are quoting:
\n Shell> function_name arg1 "arg 2" """arg 3"""\n
\n \n Commands are executed as if on a stack machine: the result of a command is\n pushed on the stack, and later commands can reference it using %\n following by a number. By default, the number of previous results that are\n kept is set to 9, and this can only be changed by modifying the source code\n for GNATColl. The return values are also modified by commands executed\n internally by your application, and that might have no visible output from\n-the user's point of view. As a result, you should never assume you know\n-what %1,... contain unless you just executed a command in the\n+the user\u2019s point of view. As a result, you should never assume you know\n+what %1,\u2026 contain unless you just executed a command in the\n same script:
\n Shell> function_name arg1\n Shell> function2_name %1\n
\n \n In particular, the %1 syntax is used when emulating object-oriented\n programming in the shell. A method of a class is just a particular function\n-that contains a '.' in its name, and whose first implicit argument is the\n+that contains a \u2018.\u2019 in its name, and whose first implicit argument is the\n instance on which it applies. This instance is generally the result of\n calling a constructor in an earlier call. Assuming, for instance, that we\n-have exported a class "Base" to the shell from our Ada core, we could use\n+have exported a class \u201cBase\u201d to the shell from our Ada core, we could use\n the following code:
\n Shell> Base arg1 arg2\n Shell> Base.method %1 arg1 arg2\n
\n \n to create an instance and call one of its methods.\n Of course, the shell is not the best language for object-oriented programming,\n and better languages should be used instead.
\n When an instance has associated properties (which you can export from Ada\n using Set_Property), you access the properties by prefixing its name\n-with "@":
\n+with \u201c@\u201d:\n Shell> Base arg1 arg2 # Build new instance\n Shell> @id %1 # Access its "id" field\n Shell> @id %1 5 # Set its "id" field\n
\n \n Some commands are automatically added to the shell when this scripting\n language is added to the application. These are
\n \n - Function load (file)
Loads the content of file from the disk, and execute each of its lines as\n a Shell command. This can for instance be used to load scripts when your\n application is loaded
\n \n
\n \n-- Function echo (arg...)
This function takes any number of argument, and prints them in the console\n+
- Function echo (arg\u2026)
This function takes any number of argument, and prints them in the console\n associated with the language. By default, when in an interactive console, the\n output of commands is automatically printed to the console. But when you\n execute a script through load above, you need to explicitly call\n echo to make some output visible.
\n \n
\n \n@@ -181,15 +181,15 @@\n above Ada procedure. It will be assumed to be Console in the rest\n of this document.\n This class provides an interface to consoles. A console is an input/output\n area in your application (whether it is a text area in a graphical\n application, or simply standard text I/O in text mode). In particular,\n the python standard output streams sys.stdin, sys.stdout\n and sys.stderr are redirected to an instance of that class. If you\n-want to see python's error messages or usual output in your application,\n+want to see python\u2019s error messages or usual output in your application,\n you must register that class, and define a default console for your\n scripting language through calls to\n GNATCOLL.Scripts.Set_Default_Console.
\n You can later add new methods to this class, which would be specific to your\n application. Or you can derive this class into a new class to achieve a\n similar goal.
\n \n@@ -242,23 +242,23 @@\n Shell, to python, or to another language integrated in GNATColl.\n The code remains exactly the same, and new scripting languages can be added\n in later releases of GNATColl without requiring a change in your\n application. This flexibility is central to the design of GNATColl.\n In exchange for that flexibility, however, there are language-specific\n features that cannot be performed through the GNATColl API. At\n present, this includes for instance exporting functions that return hash\n-tables. But GNATColl doesn't try to export the greatest set of\n+tables. But GNATColl doesn\u2019t try to export the greatest set of\n features common to all languages. On the contrary, it tries to fully\n support all the languages, and provide reasonable fallback for languages\n that do not support that feature. For instance, named parameters (which\n are a part of the python language) are fully supported, although the\n-shell language doesn't support them. But that's an implementation detail\n+shell language doesn\u2019t support them. But that\u2019s an implementation detail\n transparent to your own application.
\n Likewise, your application might decide to always load the python\n-scripting language. If GNATColl wasn't compiled with python support,\n+scripting language. If GNATColl wasn\u2019t compiled with python support,\n the corresponding Ada function still exists (and thus your code still\n compiles), although of course it does nothing. But since the rest of the\n code is independent of python, this is totally transparent for your\n application.
\n GNATColl comes with some examples, which you can use\n as a reference when building your own application.\n See the <prefix>/share/examples/gnatcoll
directory.
\n@@ -269,15 +269,15 @@\n to load\n
You can create an interactive console for the various\n languages, so that users can perform experiments interactively. This\n is optional, and you could decide to keep the scripting language has a\n hidden implementation detail (or just for automatic testing purposes\n for instance)
\n You can export some classes and methods.\n-This is optional, but it doesn't really make sense to just embed a\n+This is optional, but it doesn\u2019t really make sense to just embed a\n scripting language and export nothing to it. In such a case, you might\n as well spawn a separate executable.
\n You can load start up scripts or plug-ins that users have\n written to extend your application.
\n \n \n 3.2.1. Initializing the scripting module\u00b6
\n@@ -489,42 +489,42 @@\n to make it possible to register each exported function only once (it then\n takes care of exporting it to each scripting language).\n \n \n \n - Class Scripting_Language
Instances of this type represent a specific language. It provides various\n operations to export subprograms, execute commands, create the other types\n-described below,... There should exists a single instance of this class per\n+described below,\u2026 There should exists a single instance of this class per\n supported language.
\n This class interacts with the script interpreter (for instance python), and\n all code executed in python goes through this type, which then executes your\n Ada callbacks to perform the actual operation.
\n It is also associated with a default console, as described above, so that\n all input and output of the scripts can be made visible to the user.
\n \n
\n \n - Class Callback_Data
This type is an opaque tagged type that provides a language-independent\n interface to the scripting language. It gives for instance access to the\n various parameters passed to your subprogram (Nth_Arg functions),\n allows you to set the return value (Set_Return_Value procedure),\n-or raise exceptions (Set_Error_Msg procedure),...
\n+or raise exceptions (Set_Error_Msg procedure),\u2026\n \n
\n \n - Record Class_Type
This type is not tagged, and cannot be extended. It basically represents a\n class in any of the scripting languages, and is used to create new instances\n of that class from Ada.
\n \n
\n \n - Class Class_Instance
A class instance represents a specific instance of a class. In general,\n such an instance is strongly bound to an instance of an Ada type. For\n instance, if you have a Foo type in your application that you wish\n-to export, you would create a Class_Type called "Foo", and then the\n+to export, you would create a Class_Type called \u201cFoo\u201d, and then the\n user can create as many instances as he wants of that class, each of which\n is associated with different values of Foo in Ada.
\n Another more specific example is the predefined Console class. As\n we have seen before, this is a Virtual_Console in Ada. You could\n for instance have two graphical windows in your application, each of which\n is a Virtual_Console. In the scripting language, this is exported\n as a class named Console. The user can create two\n@@ -645,19 +645,19 @@\n the scripting language to display a proper error message to the user. You\n have nothing special to do here.
\n
\n \n 3.2.3.2.2. Support for named parameters\u00b6
\n Some languages (especially python) support named parameters, ie parameters\n can be specified in any order on the command line, as long as they are\n-properly identified (very similar to Ada's own capabilities). In the example\n+properly identified (very similar to Ada\u2019s own capabilities). In the example\n above, the call to Name_Parameters is really optional, but adds this\n support for your own functions as well. You just have to specify the name\n of the parameters, and GNATColl will then ensure that when you\n-call Nth_Arg the parameter number 1 is really "arg1".\n+call Nth_Arg the parameter number 1 is really \u201carg1\u201d.\n For scripting languages that do not support named parameters, this has no\n effect.
\n Your code can then perform as complex a code as needed, and finally\n return a value (or not) to the scripting language, through a call to\n Set_Return_Value.
\n After the above code has been executed, your users can go to the python\n console and type for instance:
\n@@ -693,25 +693,25 @@\n this class.\n You can then register the class methods in the same way that you registered\n functions. An additional parameter Class exists for\n Register_Command. A method is really just a standard function that\n has an implicit first parameter which is a Class_Instance. This\n extra parameter should not be taken into account in Min_Args and\n Max_Args. You can also declare the method as a static method, ie\n-one that doesn't take this extra implicit parameter, and basically just\n+one that doesn\u2019t take this extra implicit parameter, and basically just\n uses the class as a namespace.
\n Some special method names are available. In particular,\n Constructor_Method should be used for the constructor of a class.\n It is a method that receives, as its first argument, a class instance that\n has just been created. It should associate that instance with the Ada\n object it represents.
\n Here is a simple example that exports a class. Each instance of this class\n is associated with a string, passed in parameter to the constructor. The\n class has a single method print, which prints its string parameter\n-prefixed by the instance's string. To start with, here is a python example\n+prefixed by the instance\u2019s string. To start with, here is a python example\n on what we want to achieve:
\n c1 = MyClass ("prefix1")\n c1.print ("foo")\n => "prefix1 foo"\n c2 = MyClass () # Using a default prefix\n c2.print ("foo")\n => "default foo"\n@@ -737,37 +737,37 @@\n (Repo, Constructor_Method, 0, 1, Handler'Access, MyClass);\n Register_Command\n (Repo, "print", 1, 1, Handler'Access, MyClass);\n
\n \n This example also demonstrates a few concepts: the constructor is declared\n as a method that takes one optional argument. The default value is in\n-fact passed in the call to Nth_Arg and is set to "default".\n+fact passed in the call to Nth_Arg and is set to \u201cdefault\u201d.\n In the handler, we know there is always a first argument which is the\n instance on which the method applies. The implementation for the\n constructor stores the prefix in the instance itself, so that several\n-instances can have different prefixes (we can't use global variables,\n-of course, since we don't know in advance how many instances will exist).\n+instances can have different prefixes (we can\u2019t use global variables,\n+of course, since we don\u2019t know in advance how many instances will exist).\n The implementation for print inserts code in the default console\n for the script (we could of course use Put_Line or any other way\n to output data), and computes the string to output by concatenating the\n-instance's prefix and the parameter to print.
\n+instance\u2019s prefix and the parameter to print.\n Note that Set_Data and Get_Data take the class in parameter,\n in addition to the class instance. This is needed for proper handling of\n multiple inheritance: say we have a class C that extends two classes\n A and B. The Ada code that deals with A associates an\n integer with the class instance, whereas the code that deals with B\n associates a string. Now, if you have an instance of C but call a\n-method inherited from A, and if Get_Data didn't specify the\n+method inherited from A, and if Get_Data didn\u2019t specify the\n class, there would be a risk that a string would be returned instead of the\n expected integer. In fact, the proper solution here is that both A\n and B store their preferred data at the same time in the instances,\n but only fetch the one they actually need. Therefore instances of C\n are associated with two datas.
\n-Here is a more advanced example that shows how to export an Ada object. Let's\n+
Here is a more advanced example that shows how to export an Ada object. Let\u2019s\n assume we have the following Ada type that we want to make available to\n scripts:
\n type MyType is record\n Field : Integer;\n end record;\n
\n \n@@ -794,18 +794,18 @@\n (Get_Data (Inst, Get_Name (MyClass))));\n begin\n return Data.Val;\n end Get_Data;\n \n \n Several aspects worth noting in this example. Each data is associated with\n-a name, not a class as in the previous example. That's in fact the same\n+a name, not a class as in the previous example. That\u2019s in fact the same\n thing, and mostly for historical reasons. We have to create our own\n instance of Instance_Property_Record to store the data, but the\n-implementation presents no special difficulty. In fact, we don't absolutely\n+implementation presents no special difficulty. In fact, we don\u2019t absolutely\n need to create Set_Data and Get_Data and could do everything\n inline in the method implementation, but it is cleaner this way and easier\n to reuse.
\n GNATColl is fully responsible for managing the lifetime of the\n data associated with the class instances and you can override the procedure\n Destroy if you need special memory management.
\n \n@@ -830,15 +830,15 @@\n was done the same for other languages for compatibility reasons).\n There are two ways to work around that limitation:\n \n Static get methods
\n With each of your classes, you can export a static method generally called\n get that takes in parameter a way to identify an existing instance,\n and either return it or create a new one. It is also recommended to disable\n-the constructor, ie force it to raise an error. Let's examine the python\n+the constructor, ie force it to raise an error. Let\u2019s examine the python\n code as it would be used:
\n ed = Editor ("file.adb") # constructor\n => Error, cannot construct instances\n ed = Editor.get ("file.adb")\n => Create a new instance\n ed2 = Editor.get ("file.adb")\n => Return existing instance\n@@ -891,15 +891,15 @@\n
\n \n It is important to realize that in the call above, we are not calling\n the constructor of a class, but a function. At the Ada level, the function\n has basically the same implementation as the one we gave for get\n above. But the python code looks nicer because we do not have these\n additional .get() calls. The name of the class MyClassImpl\n-doesn't appear anywhere in the python code, so this is mostly transparent.
\n+doesn\u2019t appear anywhere in the python code, so this is mostly transparent.\n However, if you have more than one scripting language, in particular for\n the shell, the code looks less nice in this case:
\n MyClass "file.adb"\n => <MyClassImpl_Instance_0x12345>\n MyClassImpl.do_something %1\n
\n \n@@ -952,15 +952,15 @@\n GNATColl provides a convenient hook to debug your script. By default,\n a script (python for instance) will call your Ada callback, which might\n raise errors. Most of the time, the error should indeed be reported to the\n user, and you can thus raise a standard exception, or call\n Set_Error_Msg.
\n But if you wish to know which script was executing the command, it is\n generally not doable. You can however activate a trace\n-(Traces: Logging information) called "PYTHON.TB" (for "traceback"), which will\n+(Traces: Logging information) called \u201cPYTHON.TB\u201d (for \u201ctraceback\u201d), which will\n output the name of the command that is being executed, as well as the\n full traceback within the python scripts. This will help you locate which\n script is raising an exception.
\n
\n
\n \n \n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -13,20 +13,20 @@\n * GNATColl_0.0_documentation \u00bb\n * 3. Scripts: Embedding script languages\n ****** 3. Scripts: Embedding script languages\u00c2\u00b6 ******\n In a lot of contexts, you want to give the possibility to users to extend your\n application. This can be done in several ways: define an Ada API from which\n they can build dynamically loadable modules, provide the whole source code to\n your application and let users recompile it, interface with a simpler scripting\n-languages,...\n+languages,\u00e2\u0080\u00a6\n Dynamically loadable modules can be loaded on demand, as their name indicate.\n However, they generally require a relatively complex environment to build, and\n are somewhat less portable. But when your users are familiar with Ada, they\n provide a programming environment in which they are comfortable. As usual,\n-changing the module requires recompilation, re-installation,...\n+changing the module requires recompilation, re-installation,\u00e2\u0080\u00a6\n Providing the source code to your application is generally even more complex\n for users. This requires an even more complex setup, your application is\n generally too big for users to dive into, and modifications done by one users\n are hard to provide to other users, or will be lost when you distribute a new\n version of your application.\n The third solution is to embed one or more scripting languages in your\n application, and export some functions to it. This often requires your users to\n@@ -35,83 +35,84 @@\n The resulting scripts can easily be redistributed to other users or even\n distributed with future versions of your application.\n The module in GNATColl helps you implement the third solution. It was used\n extensively in the GPS programming environment for its python interface.\n [TIP:] Each of the scripting language is optional\n This module can be compiled with any of these languages as an optional\n dependency (except for the shell language, which is always built-in, but is\n-extremely minimal, and doesn't have to be loaded at run time anyway). If the\n+extremely minimal, and doesn\u00e2\u0080\u0099t have to be loaded at run time anyway). If the\n necessary libraries are found on the system, GNATColl will be build with\n support for the corresponding language, but your application can chose at run\n time whether or not to activate the support for a specific language.\n [TIP:] Use a scripting language to provide an automatic testing framework for\n your application.\n The GPS environment uses python command for its automatic test suite, including\n-graphical tests such as pressing on a button, selecting a menu,...\n+graphical tests such as pressing on a button, selecting a menu,\u00e2\u0080\u00a6\n ***** 3.1. Supported languages\u00c2\u00b6 *****\n The module provides built-in support for several scripting languages, and other\n-languages can \"easily\" be added. Your application does not change when new\n+languages can \u00e2\u0080\u009ceasily\u00e2\u0080\u009d be added. Your application does not change when new\n languages are added, since the interface to export subprograms and classes to\n the scripting languages is language-neutral, and will automatically export to\n all known scripting languages.\n The Core component provides support for the following language:\n Shell\n- This is a very simple-minded scripting language, which doesn't provide\n+ This is a very simple-minded scripting language, which doesn\u00e2\u0080\u0099t provide\n flow-control instructions (The_Shell_language).\n Optional components add support for other languages, e.g. Python. Please refer\n-to the corresponding component's documentation.\n+to the corresponding component\u00e2\u0080\u0099s documentation.\n **** 3.1.1. The Shell language\u00c2\u00b6 ****\n The shell language was initially developed in the context of the GPS\n programming environment, as a way to embed scripting commands in XML\n configuration files.\n In this language, you can execute any of the commands exported by the\n application, passing any number of arguments they need. Arguments to function\n calls can, but need not, be quoted. Quoting is only mandatory when they contain\n-spaces, newline characters, or double-quotes ('\"'). To quote an argument,\n+spaces, newline characters, or double-quotes (\u00e2\u0080\u0098\u00e2\u0080\u009d\u00e2\u0080\u0099). To quote an argument,\n surround it by double-quotes, and precede each double-quote it contains by a\n backslash character. Another way of quoting is similar to what python provides,\n-which is to triple-quote the argument, i.e. surround it by '\"\"\"' on each side.\n-In such a case, any special character (in particular other double-quotes or\n-backslashes) lose their special meaning and are just taken as part of the\n-argument. This is in particular useful when you do not know in advance the\n+which is to triple-quote the argument, i.e. surround it by \u00e2\u0080\u0098\u00e2\u0080\u009d\u00e2\u0080\u009d\u00e2\u0080\u009d\u00e2\u0080\u0099 on\n+each side. In such a case, any special character (in particular other double-\n+quotes or backslashes) lose their special meaning and are just taken as part of\n+the argument. This is in particular useful when you do not know in advance the\n contents of the argument you are quoting:\n Shell> function_name arg1 \"arg 2\" \"\"\"arg 3\"\"\"\n Commands are executed as if on a stack machine: the result of a command is\n pushed on the stack, and later commands can reference it using%following by a\n number. By default, the number of previous results that are kept is set to 9,\n and this can only be changed by modifying the source code for GNATColl. The\n return values are also modified by commands executed internally by your\n-application, and that might have no visible output from the user's point of\n-view. As a result, you should never assume you know what%1,... contain unless\n+application, and that might have no visible output from the user\u00e2\u0080\u0099s point of\n+view. As a result, you should never assume you know what%1,\u00e2\u0080\u00a6 contain unless\n you just executed a command in the same script:\n Shell> function_name arg1\n Shell> function2_name %1\n In particular, the%1syntax is used when emulating object-oriented programming\n in the shell. A method of a class is just a particular function that contains a\n-'.' in its name, and whose first implicit argument is the instance on which it\n-applies. This instance is generally the result of calling a constructor in an\n-earlier call. Assuming, for instance, that we have exported a class \"Base\" to\n-the shell from our Ada core, we could use the following code:\n+\u00e2\u0080\u0098.\u00e2\u0080\u0099 in its name, and whose first implicit argument is the instance on which\n+it applies. This instance is generally the result of calling a constructor in\n+an earlier call. Assuming, for instance, that we have exported a class\n+\u00e2\u0080\u009cBase\u00e2\u0080\u009d to the shell from our Ada core, we could use the following code:\n Shell> Base arg1 arg2\n Shell> Base.method %1 arg1 arg2\n to create an instance and call one of its methods. Of course, the shell is not\n the best language for object-oriented programming, and better languages should\n be used instead.\n When an instance has associated properties (which you can export from Ada\n-usingSet_Property), you access the properties by prefixing its name with \"@\":\n+usingSet_Property), you access the properties by prefixing its name with\n+\u00e2\u0080\u009c@\u00e2\u0080\u009d:\n Shell> Base arg1 arg2 # Build new instance\n Shell> @id %1 # Access its \"id\" field\n Shell> @id %1 5 # Set its \"id\" field\n Some commands are automatically added to the shell when this scripting language\n is added to the application. These are\n Function load (file)\n Loads the content offilefrom the disk, and execute each of its lines as a\n Shell command. This can for instance be used to load scripts when your\n application is loaded\n- Function echo (arg...)\n+ Function echo (arg\u00e2\u0080\u00a6)\n This function takes any number of argument, and prints them in the\n console associated with the language. By default, when in an interactive\n console, the output of commands is automatically printed to the console.\n But when you execute a script throughloadabove, you need to explicitly\n callechoto make some output visible.\n Function clear_cache\n This frees the memory used to store the output of previous commands.\n@@ -126,15 +127,15 @@\n Class Console\n Consoleis a name that you can chose yourself when you call the above Ada\n procedure. It will be assumed to beConsolein the rest of this document.\n This class provides an interface to consoles. A console is an input/\n output area in your application (whether it is a text area in a graphical\n application, or simply standard text I/O in text mode). In particular,\n the python standard output streamssys.stdin,sys.stdoutandsys.stderrare\n- redirected to an instance of that class. If you want to see python's\n+ redirected to an instance of that class. If you want to see python\u00e2\u0080\u0099s\n error messages or usual output in your application, you must register\n that class, and define a default console for your scripting language\n through calls toGNATCOLL.Scripts.Set_Default_Console.\n You can later add new methods to this class, which would be specific to\n your application. Or you can derive this class into a new class to\n achieve a similar goal.\n Console.write(text)\n@@ -168,38 +169,39 @@\n transparent for your application whether you are talking to the Shell, to\n python, or to another language integrated in GNATColl. The code remains exactly\n the same, and new scripting languages can be added in later releases of\n GNATColl without requiring a change in your application. This flexibility is\n central to the design of GNATColl.\n In exchange for that flexibility, however, there are language-specific features\n that cannot be performed through the GNATColl API. At present, this includes\n-for instance exporting functions that return hash tables. But GNATColl doesn't\n-try to export the greatest set of features common to all languages. On the\n-contrary, it tries to fully support all the languages, and provide reasonable\n-fallback for languages that do not support that feature. For instance, named\n-parameters (which are a part of the python language) are fully supported,\n-although the shell language doesn't support them. But that's an implementation\n-detail transparent to your own application.\n+for instance exporting functions that return hash tables. But GNATColl\n+doesn\u00e2\u0080\u0099t try to export the greatest set of features common to all languages.\n+On the contrary, it tries to fully support all the languages, and provide\n+reasonable fallback for languages that do not support that feature. For\n+instance, named parameters (which are a part of the python language) are fully\n+supported, although the shell language doesn\u00e2\u0080\u0099t support them. But that\u00e2\u0080\u0099s an\n+implementation detail transparent to your own application.\n Likewise, your application might decide to always load the python scripting\n-language. If GNATColl wasn't compiled with python support, the corresponding\n+language. If GNATColl wasn\u00e2\u0080\u0099t compiled with python support, the corresponding\n Ada function still exists (and thus your code still compiles), although of\n course it does nothing. But since the rest of the code is independent of\n python, this is totally transparent for your application.\n [TIP:] GNATColl comes with some examples, which you can use as a reference when\n building your own application. See the /share/examples/gnatcoll\n directory.\n Interfacing your application with the scripting module is a multistep process:\n * You must initialize GNATColl and decide which features to load\n * You can create an interactive console for the various languages, so that\n users can perform experiments interactively. This is optional, and you\n could decide to keep the scripting language has a hidden implementation\n detail (or just for automatic testing purposes for instance)\n- * You can export some classes and methods. This is optional, but it doesn't\n- really make sense to just embed a scripting language and export nothing\n- to it. In such a case, you might as well spawn a separate executable.\n+ * You can export some classes and methods. This is optional, but it\n+ doesn\u00e2\u0080\u0099t really make sense to just embed a scripting language and export\n+ nothing to it. In such a case, you might as well spawn a separate\n+ executable.\n * You can load start up scripts or plug-ins that users have written to\n extend your application.\n **** 3.2.1. Initializing the scripting module\u00c2\u00b6 ****\n GNATColl must be initialized properly in order to provide added value to your\n application. This cannot be done automatically simply by depending on the\n library, since this initialization requires multiple-step that must be done at\n specific moments in the initialization of your whole application.\n@@ -358,37 +360,37 @@\n instance in your whole application, and whose main role is to give access\n to each of the scripting languages (Lookup_Scripting_Languagefunction),\n and to make it possible to register each exported function only once (it\n then takes care of exporting it to each scripting language).\n Class Scripting_Language\n Instances of this type represent a specific language. It provides various\n operations to export subprograms, execute commands, create the other\n- types described below,... There should exists a single instance of this\n+ types described below,\u00e2\u0080\u00a6 There should exists a single instance of this\n class per supported language.\n This class interacts with the script interpreter (for instance python),\n and all code executed in python goes through this type, which then\n executes your Ada callbacks to perform the actual operation.\n It is also associated with a default console, as described above, so that\n all input and output of the scripts can be made visible to the user.\n Class Callback_Data\n This type is an opaque tagged type that provides a language-independent\n interface to the scripting language. It gives for instance access to the\n various parameters passed to your subprogram (Nth_Argfunctions), allows\n you to set the return value (Set_Return_Valueprocedure), or raise\n- exceptions (Set_Error_Msgprocedure),...\n+ exceptions (Set_Error_Msgprocedure),\u00e2\u0080\u00a6\n Record Class_Type\n This type is not tagged, and cannot be extended. It basically represents\n a class in any of the scripting languages, and is used to create new\n instances of that class from Ada.\n Class Class_Instance\n A class instance represents a specific instance of a class. In general,\n such an instance is strongly bound to an instance of an Ada type. For\n instance, if you have aFootype in your application that you wish to\n- export, you would create aClass_Typecalled \"Foo\", and then the user can\n- create as many instances as he wants of that class, each of which is\n+ export, you would create aClass_Typecalled \u00e2\u0080\u009cFoo\u00e2\u0080\u009d, and then the user\n+ can create as many instances as he wants of that class, each of which is\n associated with different values ofFooin Ada.\n Another more specific example is the predefinedConsoleclass. As we have\n seen before, this is aVirtual_Consolein Ada. You could for instance have\n two graphical windows in your application, each of which is\n aVirtual_Console. In the scripting language, this is exported as a class\n namedConsole. The user can create two instances of those, each of which\n is associated with one of your graphical windows. This way,\n@@ -485,20 +487,20 @@\n through one of the numerousNth_Argfunctions. In the example above, we assume\n they are integer. But if one of them was passed as a string, an exception would\n be raised and sent back to the scripting language to display a proper error\n message to the user. You have nothing special to do here.\n ** 3.2.3.2.2. Support for named parameters\u00c2\u00b6 **\n Some languages (especially python) support named parameters, ie parameters can\n be specified in any order on the command line, as long as they are properly\n-identified (very similar to Ada's own capabilities). In the example above, the\n-call toName_Parametersis really optional, but adds this support for your own\n-functions as well. You just have to specify the name of the parameters, and\n+identified (very similar to Ada\u00e2\u0080\u0099s own capabilities). In the example above,\n+the call toName_Parametersis really optional, but adds this support for your\n+own functions as well. You just have to specify the name of the parameters, and\n GNATColl will then ensure that when you callNth_Argthe parameter number 1 is\n-really \"arg1\". For scripting languages that do not support named parameters,\n-this has no effect.\n+really \u00e2\u0080\u009carg1\u00e2\u0080\u009d. For scripting languages that do not support named\n+parameters, this has no effect.\n Your code can then perform as complex a code as needed, and finally return a\n value (or not) to the scripting language, through a call toSet_Return_Value.\n After the above code has been executed, your users can go to the python console\n and type for instance:\n from MyModule import * # MyModule is the name we declared above\n print sum (1,2)\n => 3\n@@ -523,24 +525,24 @@\n required setup has been done internally so that you can now add methods to this\n class.\n You can then register the class methods in the same way that you registered\n functions. An additional parameterClassexists forRegister_Command. A method is\n really just a standard function that has an implicit first parameter which is\n aClass_Instance. This extra parameter should not be taken into account\n inMin_ArgsandMax_Args. You can also declare the method as a static method, ie\n-one that doesn't take this extra implicit parameter, and basically just uses\n+one that doesn\u00e2\u0080\u0099t take this extra implicit parameter, and basically just uses\n the class as a namespace.\n Some special method names are available. In particular,Constructor_Methodshould\n be used for the constructor of a class. It is a method that receives, as its\n first argument, a class instance that has just been created. It should\n associate that instance with the Ada object it represents.\n Here is a simple example that exports a class. Each instance of this class is\n associated with a string, passed in parameter to the constructor. The class has\n a single methodprint, which prints its string parameter prefixed by the\n-instance's string. To start with, here is a python example on what we want to\n+instance\u00e2\u0080\u0099s string. To start with, here is a python example on what we want to\n achieve:\n c1 = MyClass (\"prefix1\")\n c1.print (\"foo\")\n => \"prefix1 foo\"\n c2 = MyClass () # Using a default prefix\n c2.print (\"foo\")\n => \"default foo\"\n@@ -562,34 +564,34 @@\n \n Register_Command\n (Repo, Constructor_Method, 0, 1, Handler'Access, MyClass);\n Register_Command\n (Repo, \"print\", 1, 1, Handler'Access, MyClass);\n This example also demonstrates a few concepts: the constructor is declared as a\n method that takes one optional argument. The default value is in fact passed in\n-the call toNth_Argand is set to \"default\". In the handler, we know there is\n+the call toNth_Argand is set to \u00e2\u0080\u009cdefault\u00e2\u0080\u009d. In the handler, we know there is\n always a first argument which is the instance on which the method applies. The\n implementation for the constructor stores the prefix in the instance itself, so\n-that several instances can have different prefixes (we can't use global\n-variables, of course, since we don't know in advance how many instances will\n+that several instances can have different prefixes (we can\u00e2\u0080\u0099t use global\n+variables, of course, since we don\u00e2\u0080\u0099t know in advance how many instances will\n exist). The implementation forprintinserts code in the default console for the\n script (we could of course usePut_Lineor any other way to output data), and\n-computes the string to output by concatenating the instance's prefix and the\n+computes the string to output by concatenating the instance\u00e2\u0080\u0099s prefix and the\n parameter toprint.\n Note thatSet_DataandGet_Datatake the class in parameter, in addition to the\n class instance. This is needed for proper handling of multiple inheritance: say\n we have a classCthat extends two classesAandB. The Ada code that deals\n withAassociates an integer with the class instance, whereas the code that deals\n withBassociates a string. Now, if you have an instance ofCbut call a method\n-inherited fromA, and ifGet_Datadidn't specify the class, there would be a risk\n-that a string would be returned instead of the expected integer. In fact, the\n-proper solution here is that bothAandBstore their preferred data at the same\n-time in the instances, but only fetch the one they actually need. Therefore\n-instances ofCare associated with two datas.\n-Here is a more advanced example that shows how to export an Ada object. Let's\n+inherited fromA, and ifGet_Datadidn\u00e2\u0080\u0099t specify the class, there would be a\n+risk that a string would be returned instead of the expected integer. In fact,\n+the proper solution here is that bothAandBstore their preferred data at the\n+same time in the instances, but only fetch the one they actually need.\n+Therefore instances ofCare associated with two datas.\n+Here is a more advanced example that shows how to export an Ada object. Let\u00e2\u0080\u0099s\n assume we have the following Ada type that we want to make available to\n scripts:\n type MyType is record\n Field : Integer;\n end record;\n As you can see, this is not a tagged type, but could certainly be. There is of\n course no procedureSet_Datain GNATCOLL.Scripts that enables us to storeMyTypein\n@@ -611,18 +613,18 @@\n function Get_Data (Inst : Class_Instance) return MyType is\n Data : MyProps := MyProps (Instance_Property'\n (Get_Data (Inst, Get_Name (MyClass))));\n begin\n return Data.Val;\n end Get_Data;\n Several aspects worth noting in this example. Each data is associated with a\n-name, not a class as in the previous example. That's in fact the same thing,\n+name, not a class as in the previous example. That\u00e2\u0080\u0099s in fact the same thing,\n and mostly for historical reasons. We have to create our own instance\n ofInstance_Property_Recordto store the data, but the implementation presents no\n-special difficulty. In fact, we don't absolutely need to\n+special difficulty. In fact, we don\u00e2\u0080\u0099t absolutely need to\n createSet_DataandGet_Dataand could do everything inline in the method\n implementation, but it is cleaner this way and easier to reuse.\n GNATColl is fully responsible for managing the lifetime of the data associated\n with the class instances and you can override the procedureDestroyif you need\n special memory management.\n *** 3.2.3.4. Reusing class instances\u00c2\u00b6 ***\n We mentioned above that it is more convenient for users of your exported\n@@ -641,16 +643,16 @@\n already received the created instance (this is forced by python, and was done\n the same for other languages for compatibility reasons). There are two ways to\n work around that limitation:\n * Staticgetmethods\n With each of your classes, you can export a static method generally\n calledgetthat takes in parameter a way to identify an existing instance,\n and either return it or create a new one. It is also recommended to\n- disable the constructor, ie force it to raise an error. Let's examine the\n- python code as it would be used:\n+ disable the constructor, ie force it to raise an error. Let\u00e2\u0080\u0099s examine\n+ the python code as it would be used:\n ed = Editor (\"file.adb\") # constructor\n => Error, cannot construct instances\n ed = Editor.get (\"file.adb\")\n => Create a new instance\n ed2 = Editor.get (\"file.adb\")\n => Return existing instance\n ed == ed2\n@@ -693,15 +695,15 @@\n => ed is of type MyClassImpl\n ed = MyClass (\"file.adb\") # return same instance\n ed.do_something()\n It is important to realize that in the call above, we are not calling the\n constructor of a class, but a function. At the Ada level, the function\n has basically the same implementation as the one we gave forgetabove. But\n the python code looks nicer because we do not have these additional.get\n- ()calls. The name of the classMyClassImpldoesn't appear anywhere in the\n+ ()calls. The name of the classMyClassImpldoesn\u00e2\u0080\u0099t appear anywhere in the\n python code, so this is mostly transparent.\n However, if you have more than one scripting language, in particular for\n the shell, the code looks less nice in this case:\n MyClass \"file.adb\"\n => \n MyClassImpl.do_something %1\n and the new name of the class is visible in the method call.\n@@ -739,16 +741,16 @@\n **** 3.2.6. Debugging scripts\u00c2\u00b6 ****\n GNATColl provides a convenient hook to debug your script. By default, a script\n (python for instance) will call your Ada callback, which might raise errors.\n Most of the time, the error should indeed be reported to the user, and you can\n thus raise a standard exception, or callSet_Error_Msg.\n But if you wish to know which script was executing the command, it is generally\n not doable. You can however activate a trace (Traces:_Logging_information)\n-called\"PYTHON.TB\"(for \"traceback\"), which will output the name of the command\n-that is being executed, as well as the full traceback within the python\n+called\u00e2\u0080\u009cPYTHON.TB\u00e2\u0080\u009d(for \u00e2\u0080\u009ctraceback\u00e2\u0080\u009d), which will output the name of the\n+command that is being executed, as well as the full traceback within the python\n scripts. This will help you locate which script is raising an exception.\n [Logo]\n **** Table_of_Contents ****\n * 3._Scripts:_Embedding_script_languages\n o 3.1._Supported_languages\n # 3.1.1._The_Shell_language\n # 3.1.2._Classes_exported_to_all_languages\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/storage_pools.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/storage_pools.html", "unified_diff": "@@ -51,16 +51,16 @@\n This can of course be done in most languages. However, that generally\n means you have to remember not to use the standard memory allocations\n like malloc or new, and instead call one of your\n subprograms. If you ever decide to change the allocation strategy, or\n want to experiment with several strategies, that means updating your\n code in several places.
\n In Ada, when you declare the type of your data, you also specify through\n-a 'Storage_Pool attribute how the memory for instances of that\n-type should be allocated. And that's it. You then use the usual\n+a \u2018Storage_Pool attribute how the memory for instances of that\n+type should be allocated. And that\u2019s it. You then use the usual\n new keyword to allocate memory.
\n GNATColl provides a number of examples for such storage pools,\n with various goals. There is also one advanced such pool in the GNAT\n run-time itself, called GNAT.Debug_Pools, which allows you to\n control memory leaks and whether all accesses do reference valid memory\n location (and not memory that has already been deallocated).
\n In GNATColl, you will find the following storage pools:
\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -20,16 +20,17 @@\n results in a single system call, which speeds up your application.\n This can of course be done in most languages. However, that generally means you\n have to remember not to use the standard memory allocations likemallocornew,\n and instead call one of your subprograms. If you ever decide to change the\n allocation strategy, or want to experiment with several strategies, that means\n updating your code in several places.\n In Ada, when you declare the type of your data, you also specify through\n-a'Storage_Poolattribute how the memory for instances of that type should be\n-allocated. And that's it. You then use the usualnewkeyword to allocate memory.\n+a\u00e2\u0080\u0098Storage_Poolattribute how the memory for instances of that type should be\n+allocated. And that\u00e2\u0080\u0099s it. You then use the usualnewkeyword to allocate\n+memory.\n GNATColl provides a number of examples for such storage pools, with various\n goals. There is also one advanced such pool in the GNAT run-time itself,\n calledGNAT.Debug_Pools, which allows you to control memory leaks and whether\n all accesses do reference valid memory location (and not memory that has\n already been deallocated).\n In GNATColl, you will find the following storage pools:\n `GNATCOLL.Storage_Pools.Alignment`\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/strings.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/strings.html", "unified_diff": "@@ -41,19 +41,19 @@\n \n \n \n 5. Strings: high-performance strings\u00b6
\n The generic package GNATCOLL.Strings_Impl
(and its default\n instantiation in GNATCOLL.Strings
) provides a high-performance\n strings implementation.
\n-It comes in addition to Ada's own String and Unbounded_String types,\n+
It comes in addition to Ada\u2019s own String and Unbounded_String types,\n although it attempts to find a middle ground in between (flexibility\n vs performance).
\n GNATCOLL.Strings therefore provides strings (named XString, as in\n-extended-strings) that can grow as needed (up to Natural'Last, like standard\n+extended-strings) that can grow as needed (up to Natural\u2019Last, like standard\n strings), yet are faster than unbounded strings. They also come with an\n extended API, which includes all primitive operations from unbounded strings,\n in addition to some subprograms inspired from GNATCOLL.Utils and the python and\n C++ programming languages.
\n \n 5.1. Small string optimization\u00b6
\n GNATCOLL.Strings uses a number of tricks to improve on the efficiency. The\n@@ -87,17 +87,17 @@\n
\n So in the same amount of memory (24 bytes), we can either store a small string\n of 23 characters or less with no memory allocations, or a big string that\n requires allocation. In a typical application, most strings are smaller than 23\n bytes, so we are saving very significant time here.
\n This representation has to work on both 32 bits systems and 64 bits systems, so\n we have careful representation clauses to take this into account. It also\n-needs to work on both big-endian and little-endian systems. Thanks to Ada's\n+needs to work on both big-endian and little-endian systems. Thanks to Ada\u2019s\n representation clauses, this one in fact relatively easy to achieve (well,\n-okay, after trying a few different approaches to emulate what's done in C++,\n+okay, after trying a few different approaches to emulate what\u2019s done in C++,\n and that did not work elegantly). In fact, emulating via bit-shift operations\n ended up with code that was less efficient than letting the compiler do it\n automatically because of our representation clauses.
\n \n \n 5.2. Character types\u00b6
\n Applications should be able to handle the whole set of Unicode characters. In\n@@ -145,40 +145,40 @@\n
This is often a reasonable number, and given that applications mostly use small\n strings, we are already saving a lot of allocations. However, in some cases we\n know that the typical length of strings in a particular context is different.\n For instance, GNATCOLL.Traces builds messages to output in the log file. Such\n messages will typically be at most 100 characters, although they can of course\n be much larger sometimes.
\n We have added one more formal parameter to GNATCOLL.Strings_Impl to control the\n-maximum size of small strings. If for instance we decide that a "small" string\n+maximum size of small strings. If for instance we decide that a \u201csmall\u201d string\n is anywhere from 1 to 100 characters long (i.e. we do not want to allocate\n memory for those strings), it can be done via this parameter.
\n Of course, in such cases the size of the string itself becomes much larger.\n In this example it would be 101 bytes long, rather than the 24 bytes. Although\n we are saving on memory allocations, we are also spending more time copying\n-data when the string is passed around, so you'll need to measure the\n+data when the string is passed around, so you\u2019ll need to measure the\n performance here.
\n The maximum size for the small string is 127 bytes however, because this size\n and the 1-bit flag need to fit in 1 bytes in the representation clauses we\n showed above. We tried to make this more configurable, but this makes things\n significantly more complex between little-endian and big-endian systems, and\n-having large "small" strings would not make much sense in terms of performance\n+having large \u201csmall\u201d strings would not make much sense in terms of performance\n anyway.
\n Typical C++ implementations do not make this small size configurable.
\n \n \n 5.4. Task safety\u00b6
\n Just like unbounded strings, the strings in this package are not thread safe.\n This means that you cannot access the same string (read or write) from two\n different threads without somehow protecting the access via a protected type,\n-locks,...
\n+locks,\u2026\n In practice, sharing strings would rarely be done, so if the package itself\n was doing its own locking we would end up with very bad performance in all\n cases, for a few cases where it might prove useful.
\n-As we'll discuss below, it is possible to use two different strings that\n+
As we\u2019ll discuss below, it is possible to use two different strings that\n actually share the same internal buffer, from two different threads. Since this\n is an implementation detail, this package takes care of guaranteeing the\n integrity of the shared data in such a case.
\n \n \n 5.5. Copy on write\u00b6
\n There is one more formal parameter, to configure whether this package should\n@@ -217,38 +217,38 @@\n
This package has a slightly different strategy. Remember that we only start\n allocating memory past the size of small strings, so we will for instance first\n allocate 24 bytes. When more memory is needed, we multiply this size by 1.5,\n which some researchers have found to be a good comprise between waste of memory\n and number of allocations. For very large strings, we always allocate multiples\n of the memory page size (4096 bytes), since this is what the system will make\n available anyway. So we will basically allocate the following: 24, 36, 54, 82,\n-122,...
\n+122,\u2026\n An additional constraint is that we only ever allocate even number of bytes.\n This is called the capacity of the string. In the layout of the big string,\n as shown above, we store half that capacity, which saves one bit that we\n use for the flag.
\n \n \n 5.7. Substrings\u00b6
\n One other optimization performed by this package (which is not done for\n unbounded strings or various C++ implementations) is to optimize substrings\n when also using copy-on-write.
\n We simply store the index of the first character of the string within the\n shared buffer, instead of always starting at the first.
\n-From the user's point of view, this is an implementation detail. Strings\n+
From the user\u2019s point of view, this is an implementation detail. Strings\n are always indexed from 1, and internally we convert to an actual position\n in the buffer. This means that if we need to reallocate the buffer, for\n instance when the string is modified, we transparently change the index\n of the first character, but the indexes the user was using are still valid.
\n This results in very significant savings, as shown below in the timings\n for Trim for instance. Also, we can do an operation like splitting a\n string very efficiently.
\n-For instance, the following code doesn't allocate any memory, beside\n+
For instance, the following code doesn\u2019t allocate any memory, beside\n setting the initial value of the string. It parses a file containing\n-some "key=value" lines, with optional spaces, and possibly empty lines:
\n+some \u201ckey=value\u201d lines, with optional spaces, and possibly empty lines:\n declare\n S, Key, Value : XString;\n L : XString_Array (1 .. 2);\n Last : Natural;\n begin\n S.Set (".......");\n \n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -11,18 +11,18 @@\n * next |\n * previous |\n * GNATColl_0.0_documentation \u00bb\n * 5. Strings: high-performance strings\n ****** 5. Strings: high-performance strings\u00c2\u00b6 ******\n The generic package GNATCOLL.Strings_Impl (and its default instantiation in\n GNATCOLL.Strings) provides a high-performance strings implementation.\n-It comes in addition to Ada's ownStringandUnbounded_Stringtypes, although it\n+It comes in addition to Ada\u00e2\u0080\u0099s ownStringandUnbounded_Stringtypes, although it\n attempts to find a middle ground in between (flexibility vs performance).\n GNATCOLL.Strings therefore provides strings (namedXString, as in extended-\n-strings) that can grow as needed (up toNatural'Last, like standard strings),\n+strings) that can grow as needed (up toNatural\u00e2\u0080\u0099Last, like standard strings),\n yet are faster than unbounded strings. They also come with an extended API,\n which includes all primitive operations from unbounded strings, in addition to\n some subprograms inspired from GNATCOLL.Utils and the python and C++\n programming languages.\n ***** 5.1. Small string optimization\u00c2\u00b6 *****\n GNATCOLL.Strings uses a number of tricks to improve on the efficiency. The most\n important one is to limit the number of memory allocations. For this, we use a\n@@ -53,17 +53,17 @@\n This is because of alignment issues.\n So in the same amount of memory (24 bytes), we can either store a small string\n of 23 characters or less with no memory allocations, or a big string that\n requires allocation. In a typical application, most strings are smaller than 23\n bytes, so we are saving very significant time here.\n This representation has to work on both 32 bits systems and 64 bits systems, so\n we have careful representation clauses to take this into account. It also needs\n-to work on both big-endian and little-endian systems. Thanks to Ada's\n+to work on both big-endian and little-endian systems. Thanks to Ada\u00e2\u0080\u0099s\n representation clauses, this one in fact relatively easy to achieve (well,\n-okay, after trying a few different approaches to emulate what's done in C++,\n+okay, after trying a few different approaches to emulate what\u00e2\u0080\u0099s done in C++,\n and that did not work elegantly). In fact, emulating via bit-shift operations\n ended up with code that was less efficient than letting the compiler do it\n automatically because of our representation clauses.\n ***** 5.2. Character types\u00c2\u00b6 *****\n Applications should be able to handle the whole set of Unicode characters. In\n Ada, these are represented as the Wide_Character type, rather than Character,\n and stored on 2 bytes rather than 1. Of course, for a lot of applications it\n@@ -102,38 +102,38 @@\n This is often a reasonable number, and given that applications mostly use small\n strings, we are already saving a lot of allocations. However, in some cases we\n know that the typical length of strings in a particular context is different.\n For instance, GNATCOLL.Traces builds messages to output in the log file. Such\n messages will typically be at most 100 characters, although they can of course\n be much larger sometimes.\n We have added one more formal parameter to GNATCOLL.Strings_Impl to control the\n-maximum size of small strings. If for instance we decide that a \"small\" string\n-is anywhere from 1 to 100 characters long (i.e. we do not want to allocate\n-memory for those strings), it can be done via this parameter.\n+maximum size of small strings. If for instance we decide that a \u00e2\u0080\u009csmall\u00e2\u0080\u009d\n+string is anywhere from 1 to 100 characters long (i.e. we do not want to\n+allocate memory for those strings), it can be done via this parameter.\n Of course, in such cases the size of the string itself becomes much larger. In\n this example it would be 101 bytes long, rather than the 24 bytes. Although we\n are saving on memory allocations, we are also spending more time copying data\n-when the string is passed around, so you'll need to measure the performance\n+when the string is passed around, so you\u00e2\u0080\u0099ll need to measure the performance\n here.\n The maximum size for the small string is 127 bytes however, because this size\n and the 1-bit flag need to fit in 1 bytes in the representation clauses we\n showed above. We tried to make this more configurable, but this makes things\n significantly more complex between little-endian and big-endian systems, and\n-having large \"small\" strings would not make much sense in terms of performance\n-anyway.\n+having large \u00e2\u0080\u009csmall\u00e2\u0080\u009d strings would not make much sense in terms of\n+performance anyway.\n Typical C++ implementations do not make this small size configurable.\n ***** 5.4. Task safety\u00c2\u00b6 *****\n Just like unbounded strings, the strings in this package are not thread safe.\n This means that you cannot access the same string (read or write) from two\n different threads without somehow protecting the access via a protected type,\n-locks,...\n+locks,\u00e2\u0080\u00a6\n In practice, sharing strings would rarely be done, so if the package itself was\n doing its own locking we would end up with very bad performance in all cases,\n for a few cases where it might prove useful.\n-As we'll discuss below, it is possible to use two different strings that\n+As we\u00e2\u0080\u0099ll discuss below, it is possible to use two different strings that\n actually share the same internal buffer, from two different threads. Since this\n is an implementation detail, this package takes care of guaranteeing the\n integrity of the shared data in such a case.\n ***** 5.5. Copy on write\u00c2\u00b6 *****\n There is one more formal parameter, to configure whether this package should\n use copy-on-write or not. When copy on write is enabled, you can have multiple\n strings that internally share the same buffer of characters. This means that\n@@ -167,36 +167,36 @@\n This package has a slightly different strategy. Remember that we only start\n allocating memory past the size of small strings, so we will for instance first\n allocate 24 bytes. When more memory is needed, we multiply this size by 1.5,\n which some researchers have found to be a good comprise between waste of memory\n and number of allocations. For very large strings, we always allocate multiples\n of the memory page size (4096 bytes), since this is what the system will make\n available anyway. So we will basically allocate the following: 24, 36, 54, 82,\n-122,...\n+122,\u00e2\u0080\u00a6\n An additional constraint is that we only ever allocate even number of bytes.\n This is called the capacity of the string. In the layout of the big string, as\n shown above, we store half that capacity, which saves one bit that we use for\n the flag.\n ***** 5.7. Substrings\u00c2\u00b6 *****\n One other optimization performed by this package (which is not done for\n unbounded strings or various C++ implementations) is to optimize substrings\n when also using copy-on-write.\n We simply store the index of the first character of the string within the\n shared buffer, instead of always starting at the first.\n-From the user's point of view, this is an implementation detail. Strings are\n+From the user\u00e2\u0080\u0099s point of view, this is an implementation detail. Strings are\n always indexed from 1, and internally we convert to an actual position in the\n buffer. This means that if we need to reallocate the buffer, for instance when\n the string is modified, we transparently change the index of the first\n character, but the indexes the user was using are still valid.\n This results in very significant savings, as shown below in the timings for\n Trim for instance. Also, we can do an operation like splitting a string very\n efficiently.\n-For instance, the following code doesn't allocate any memory, beside setting\n-the initial value of the string. It parses a file containing some \"key=value\"\n-lines, with optional spaces, and possibly empty lines:\n+For instance, the following code doesn\u00e2\u0080\u0099t allocate any memory, beside setting\n+the initial value of the string. It parses a file containing some\n+\u00e2\u0080\u009ckey=value\u00e2\u0080\u009d lines, with optional spaces, and possibly empty lines:\n declare\n S, Key, Value : XString;\n L : XString_Array (1 .. 2);\n Last : Natural;\n begin\n S.Set (\".......\");\n \n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/templates.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/templates.html", "unified_diff": "@@ -40,45 +40,45 @@\n \n \n \n \n 10. Templates: generating text\u00b6
\n This module provides convenient subprograms for replacing specific\n substrings with other values. It is typically used to replace substrings\n-like "%{version}" in a longer string with the actual version, at run time.
\n+like \u201c%{version}\u201d in a longer string with the actual version, at run time.\n This module is not the same as the templates parser provided in the context\n of AWS, the Ada web server, where external files are parsed and processed\n to generate other files. The latter provides advanced features like filters,\n-loops,...
\n+loops,\u2026\n The substrings to be replaced always start with a specific delimiter, which\n is set to % by default, but can be overridden in your code. The name\n of the substring to be replaced is then the identifier following that\n delimiter, with the following rules:
\n \n If the character following the delimiter is the delimiter itself,\n then the final string will contain a single instance of that delimiter, and\n no further substitution is done for that delimiter. An example of this is\n-"%%".
\n+\u201c%%\u201d.\n If the character immediately after the delimiter is a curly brace\n ({), then the name of the identifier is the text until the next\n closing curly brace. It can then contain any character expect a closing\n-curly brace. An example of this is "%{long name}"
\n+curly brace. An example of this is \u201c%{long name}\u201d\n If the first character after the delimiter is a digit, then the\n name of the identifier is the number after the delimiter. An example of\n-this is "%12". As a special case, if the first non-digit\n+this is \u201c%12\u201d. As a special case, if the first non-digit\n character is the symbol -, it is added as part of the name of the\n-identifier, as in "%1-". One use for this feature is to indicate\n+identifier, as in \u201c%1-\u201c. One use for this feature is to indicate\n you want to replace it with all the positional parameters %1%2%3%4. For\n instance, if you are writing the command line to spawn an external tool,\n to which the user can pass any number of parameter, you could specify that\n-command line as "tool -o %1 %2-" to indicate that all parameters\n+command line as \u201ctool -o %1 %2-\u201c to indicate that all parameters\n should be concatenated on the command line.
\n If the first character after the delimiter is a letter, the identifier\n follows the same rules as for Ada identifiers, and can contain any letter,\n-digit, or underscore character. An example of this is "%ab_12". For\n+digit, or underscore character. An example of this is \u201c%ab_12\u201d. For\n readability, it is recommended to use the curly brace notation when the\n name is complex, but that is not mandatory.
\n Otherwise the name of the identifier is the single character\n following the delimiter
\n
\n For each substring matching the rules above, the Substitute subprogram\n will look for possible replacement text in the following order:
\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -10,47 +10,47 @@\n * index\n * next |\n * previous |\n * GNATColl_0.0_documentation \u00bb\n * 10. Templates: generating text\n ****** 10. Templates: generating text\u00c2\u00b6 ******\n This module provides convenient subprograms for replacing specific substrings\n-with other values. It is typically used to replace substrings like \"%{version}\"\n-in a longer string with the actual version, at run time.\n+with other values. It is typically used to replace substrings like \u00e2\u0080\u009c%\n+{version}\u00e2\u0080\u009d in a longer string with the actual version, at run time.\n This module is not the same as the templates parser provided in the context of\n AWS, the Ada web server, where external files are parsed and processed to\n generate other files. The latter provides advanced features like filters,\n-loops,...\n+loops,\u00e2\u0080\u00a6\n The substrings to be replaced always start with a specific delimiter, which is\n set to%by default, but can be overridden in your code. The name of the\n substring to be replaced is then the identifier following that delimiter, with\n the following rules:\n * If the character following the delimiter is the delimiter itself, then\n the final string will contain a single instance of that delimiter, and no\n further substitution is done for that delimiter. An example of this\n- is\"%%\".\n+ is\u00e2\u0080\u009c%%\u00e2\u0080\u009d.\n * If the character immediately after the delimiter is a curly brace ({),\n then the name of the identifier is the text until the next closing curly\n brace. It can then contain any character expect a closing curly brace. An\n- example of this is\"%{long name}\"\n+ example of this is\u00e2\u0080\u009c%{long name}\u00e2\u0080\u009d\n * If the first character after the delimiter is a digit, then the name of\n the identifier is the number after the delimiter. An example of this\n- is\"%12\". As a special case, if the first non-digit character is the\n- symbol-, it is added as part of the name of the identifier, as in\"%1-\".\n- One use for this feature is to indicate you want to replace it with all\n- the positional parameters %1%2%3%4. For instance, if you are writing the\n- command line to spawn an external tool, to which the user can pass any\n- number of parameter, you could specify that command line as\"tool -o %1\n- %2-\"to indicate that all parameters should be concatenated on the command\n- line.\n+ is\u00e2\u0080\u009c%12\u00e2\u0080\u009d. As a special case, if the first non-digit character is the\n+ symbol-, it is added as part of the name of the identifier, as in\u00e2\u0080\u009c%1-\n+ \u00e2\u0080\u009c. One use for this feature is to indicate you want to replace it with\n+ all the positional parameters %1%2%3%4. For instance, if you are writing\n+ the command line to spawn an external tool, to which the user can pass\n+ any number of parameter, you could specify that command line as\u00e2\u0080\u009ctool -\n+ o %1 %2-\u00e2\u0080\u009cto indicate that all parameters should be concatenated on the\n+ command line.\n * If the first character after the delimiter is a letter, the identifier\n follows the same rules as for Ada identifiers, and can contain any\n- letter, digit, or underscore character. An example of this is\"%ab_12\".\n- For readability, it is recommended to use the curly brace notation when\n- the name is complex, but that is not mandatory.\n+ letter, digit, or underscore character. An example of this\n+ is\u00e2\u0080\u009c%ab_12\u00e2\u0080\u009d. For readability, it is recommended to use the curly brace\n+ notation when the name is complex, but that is not mandatory.\n * Otherwise the name of the identifier is the single character following\n the delimiter\n For each substring matching the rules above, theSubstitutesubprogram will look\n for possible replacement text in the following order:\n * If theSubstringsparameter contains an entry for that name, the\n corresponding value is used.\n * Otherwise, if acallbackwas specified, it is called with the name of the\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/traces.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/traces.html", "unified_diff": "@@ -41,40 +41,40 @@\n \n \n \n 4. Traces: Logging information\u00b6
\n Most applications need to log various kinds of information: error messages,\n information messages or debug messages among others. These logs can be\n displayed and stored in a number of places: standard output, a file, the\n-system logger, an application-specific database table,...
\n+system logger, an application-specific database table,\u2026\n The package GNATCOLL.Traces
addresses the various needs, except for the\n application-specific database, which of course is specific to your business\n and needs various custom fields in any case, which cannot be easily provided\n through a general interface.
\n This module is organized around two tagged types (used through access types,\n in fact, so the latter are mentioned below as a shortcut):
\n \n - Trace_Handle
This type defines a handle (similar to a file descriptor in other contexts)\n which is latter used to output messages. An application will generally\n define several handles, which can be enabled or disabled separately, therefore\n limiting the amount of logging.
\n \n - Trace_Stream
Streams are the ultimate types responsible for the output of the messages.\n One or more handles are associated with each stream. The latter can be a file,\n-the standard output, a graphical window, a socket,... New types of streams\n+the standard output, a graphical window, a socket,\u2026 New types of streams\n can easily be defined in your application.
\n \n
\n \n 4.1. Configuring traces\u00b6
\n As mentioned above, an application will generally create several\n Trace_Handle (typically one per module in the application). When\n new features are added to the application, the developers will generally\n need to add lots of traces to help investigate problems once the application\n-is installed at a customer's site. The problem here is that each module\n+is installed at a customer\u2019s site. The problem here is that each module\n might output a lot of information, thus confusing the logs; this also does\n not help debugging.
\n The GNATCOLL.Traces package allows the user to configure which handles\n should actually generate logs, and which should just be silent and not\n generate anything. Depending on the part of the application that needs to\n be investigated, one can therefore enable a set of handles or another, to\n be able to concentrate on that part of the application.
\n@@ -93,70 +93,70 @@\n Parse_Config_File.\n \n If no file name was specified in that call, the environment variable\n ADA_DEBUG_FILE might point to a configuration file.
\n \n If the above two attempts did not find a suitable configuration file,\n the current directory is searched for a file called .gnatdebug.\n-Finally, the user's home directory will also be searched for that file.
\n+Finally, the user\u2019s home directory will also be searched for that file.\n \n In all cases, the format of the configuration file is the same. Its goal is\n to associate the name of a trace_handle with the name of a\n trace_stream on which it should be displayed.
\n Streams are identified by a name. You can provide additional streams by\n creating a new tagged object (Defining custom stream types). Here are\n the various possibilities to reference a stream:
\n \n-- "name"
where name is a string made of letters, digits and slash ('/') characters.\n+
- \u201cname\u201d
where name is a string made of letters, digits and slash (\u2018/\u2019) characters.\n This is the name of a file to which the traces should be redirected. The\n previous contents of the file is discarded. If the name of the file is a\n relative path, it is relative to the location of the configuration file, not\n necessarily to the current directory when the file is parsed.\n In the file name, $$ is automatically replaced by the process number.\n $D is automatically replaced by the current date. $T is automatically\n replaced by the current date and time. Other patterns of the form $name,\n ${name}, or $(name) are substituted with the value of the named environment\n-variable, if it exists. If ">>" is used instead of ">" to redirect to that\n+variable, if it exists. If \u201c>>\u201d is used instead of \u201c>\u201d to redirect to that\n stream, the file is appended to, instead of truncated.
\n \n-- "&1"
This syntax is similar to the one used on Unix shells, and indicates that\n+
- \u201c&1\u201d
This syntax is similar to the one used on Unix shells, and indicates that\n the output should be displayed on the standard output for the application.\n If the application is graphical, and in particular on Windows platforms, it\n is possible that there is no standard output!
\n \n-- "&2"
Similar to the previous one, but the output is sent to standard error.
\n+- \u201c&2\u201d
Similar to the previous one, but the output is sent to standard error.
\n \n-- "&syslog"
- \n+
- \u201c&syslog\u201d
- \n
\n
\n Comments in a configuration file must be on a line of their own, and start\n-with --. Empty lines are ignored. The rest of the lines represent\n+with \u2013. Empty lines are ignored. The rest of the lines represent\n configurations, as in:
\n \n-If a line contains the single character "+", it activates all\n+
If a line contains the single character \u201c+\u201d, it activates all\n trace_handle by default. This means the rest of the configuration\n file should disable those handles that are not needed. The default is that\n all handles are disabled by default, and the configuration file should\n activate the ones it needs. The Ada source code can change the default\n status of each handles, as well
\n-If the line starts with the character ">", followed by a\n+
If the line starts with the character \u201c>\u201d, followed by a\n stream name (as defined above), this becomes the default stream. All handles\n will be displayed on that stream, unless otherwise specified. If the stream\n does not exist, it defaults to standard output.
\n Otherwise, the first token on the line is the name of a handle.\n If that is the only element on the line, the handle is activated, and will\n be displayed on the default stream.
\n-Otherwise, the next element on the line should be a "=" sign,\n-followed by either "yes" or "no", depending on whether the\n+
Otherwise, the next element on the line should be a \u201c=\u201d sign,\n+followed by either \u201cyes\u201d or \u201cno\u201d, depending on whether the\n handle should resp. be enabled or disabled.
\n-Finally, the rest of the line can optionally contain the ">"\n+
Finally, the rest of the line can optionally contain the \u201c>\u201d\n character followed by the name of the stream to which the handle should\n be directed.
\n There is are two special cases for the names on this line: they can\n-start with either "*." or ".*" to indicate the settings apply to a\n+start with either \u201c*.\u201d or \u201c.*\u201d to indicate the settings apply to a\n whole set of handles. See the example below.
\n \n
\n Here is a short example of a configuration file. It activates all handles\n by default, and defines four handles: two of them are directed to the\n default stream (standard error), the third one to a file on the disk,\n and the last one to the system logger syslog (if your system supports it,\n@@ -297,15 +297,15 @@\n
\n \n 4.3. Log decorators\u00b6
\n Speaking of color, a number of decorators are defined by\n GNATCOLL.Traces. Their goal is not to be used for outputting information,\n but to configure what extra information should be output with all log\n messages. They are activated through the same configuration file as the\n-traces, with the same syntax (i.e either "=yes" or "=no").
\n+traces, with the same syntax (i.e either \u201c=yes\u201d or \u201c=no\u201d).\n Here is an exhaustive list:
\n \n - DEBUG.ABSOLUTE_TIME
If this decorator is activated in the configuration file, the absolute time\n when Trace is called is automatically added to the output, when the\n streams supports it (in particular, this has no effect for syslog, which\n already does this on its own).
\n \n@@ -318,21 +318,21 @@\n - DEBUG.STACK_TRACE
If this decorator is activated, then the stack trace is also displayed. It can\n be converted to a symbolic stack trace through the use of the external\n application addr2line, but that would be too costly to do this\n automatically for each message.
\n \n - DEBUG.LOCATION
If this decorator is activated, the location of the call to Trace is\n automatically displayed. This is a file:line:column information. This\n-works even when the executable wasn't compiled with debug information
\n+works even when the executable wasn\u2019t compiled with debug information\n \n - DEBUG.ENCLOSING_ENTITY
Activate this decorator to automatically display the name of the subprogram\n that contains the call to Trace.
\n \n - DEBUG.COLORS
If this decorator is activated, the messages will use colors for the various\n-fields, if the stream supports it (syslog doesn't).
\n+fields, if the stream supports it (syslog doesn\u2019t).\n \n - DEBUG.COUNT
This decorator displays two additional numbers on each line: the first is\n the number of times this handle was used so far in the application, the second\n is the total number of traces emitted so far. These numbers can for instance\n be used to set conditional breakpoints on a specific trace (break on\n gnat.traces.log or gnat.traces.trace and check the value of\n Handle.Count. It can also be used to refer to a specific line in some\n@@ -358,15 +358,15 @@\n (elapsed: 2ms)(loc: gnatcoll-traces.adb:224)\n (entity:GNATCOLL.Traces.Log)\n (callstack: 40FD9902 082FCFDD 082FE8DF )\n
\n \n Depending on your application, there are lots of other possible decorators\n that could be useful (for instance the current thread, or the name of the\n-executable when you have several of them,...). Since GNATCOLL.Traces\n+executable when you have several of them,\u2026). Since GNATCOLL.Traces\n cannot provide all possible decorators, it provides support, through tagged\n types, so that you can create your own decorators.
\n This needs you to override the Trace_Handle_Record tagged type. Since\n this type is created through calls to GNATCOLL.Traces.Create. This is done\n by providing an additional Factory parameter to Create; this is\n a function that allocates and returns the new handle.
\n Then you can override either (or both) of the primitive operations\n@@ -408,22 +408,22 @@\n application which is charge of monitoring your application.
\n You do not need the code below if you simply want to have a new stream in\n your application (for instance using one for logging Info messages, one for\n Error messages, and so on). In this case, the function Create is all\n you need.
\n GNATCOLL.Traces provides the type Trace_Stream_Record, which can\n be overridden to redirect the traces to your own streams.
\n-Let's assume for now that you have defined a new type of stream (called\n-"mystream"). To keep the example simple, we will assume this stream\n+
Let\u2019s assume for now that you have defined a new type of stream (called\n+\u201cmystream\u201d). To keep the example simple, we will assume this stream\n also redirects to a file. For flexibility, however, you want to let the user\n configure the file name from the traces configuration file. Here is an\n example of a configuration file that sets the default stream to a file\n called foo
, and redirects a specific handle to another file called\n bar
. Note how the same syntax that was used for standard output and\n-standard error is also reused (ie the stream name starts with the "&"\n+standard error is also reused (ie the stream name starts with the \u201c&\u201d\n symbol, to avoid confusion with standard file names):
\n >&mystream:foo\n MODULE=yes >&mystream:bar\n
\n \n You need of course to do a bit of coding in Ada to create the stream. This\n is done by creating a new child of Trace_Stream_Record, and override\n@@ -441,23 +441,23 @@\n begin\n Str.Get_String (S, L);\n Put (Stream.File.all, String (S (1 .. L)));\n end Put;\n
\n \n The above code did not open the file itself, as you might have noticed,\n-nor did it register the name "mystream" so that it can be used in\n+nor did it register the name \u201cmystream\u201d so that it can be used in\n the configuration file. All this is done by creating a factory, ie a\n function in charge of creating the new stream.
\n A factory is also a tagged object (so that you can store custom information\n in it), with a single primitive operation, New_Stream, in charge of\n creating and initializing a new stream.\n This operation receives\n in parameter the argument specified by the user in the configuration file\n-(after the ":" character, if any), and must return a newly\n+(after the \u201c:\u201d character, if any), and must return a newly\n allocated stream. This function is also never called twice with the\n same argument, since GNATCOLL.Traces automatically reuses an existing\n stream when one with the same name and arguments already exists:
\n type My_Stream_Factory is new Stream_Factory with null record;\n \n overriding function New_Stream\n (Self : My_Stream_Factory; Args : String) return Trace_Stream\n@@ -475,31 +475,31 @@\n
\n \n \n 4.5. Logging to syslog\u00b6
\n Among the predefined streams, GNATColl gives access to the system\n logger syslog. This is a standard utility on all Unix systems, but is\n not available on other systems. When you compile GNATColl, you should\n-specify the switch --enable-syslog to configure to activate the\n-support. If either this switch wasn't specified, or configure could not find\n+specify the switch \u2013enable-syslog to configure to activate the\n+support. If either this switch wasn\u2019t specified, or configure could not find\n the relevant header files anyway, then support for syslog will not\n be available. In this case, the package GNATCOLL.Traces.Syslog is still\n available, but contains a single function that does nothing. If your\n-configuration files redirect some trace handles to "syslog", they will\n+configuration files redirect some trace handles to \u201csyslog\u201d, they will\n instead be redirect to the default stream or to standard output.
\n Activating support for syslog requires the following call in your application:
\n GNATCOLL.Traces.Syslog.Register_Syslog_Stream;\n
\n \n This procedure is always available, whether your system supports or not\n-syslog, and will simply do nothing if it doesn't support syslog. This means\n+syslog, and will simply do nothing if it doesn\u2019t support syslog. This means\n that you do not need to have conditional code in your application to handle\n that, and you can let GNATColl take care of this.
\n After the above call, trace handles can be redirected to a stream named\n-"syslog".
\n+\u201csyslog\u201d.\n The package GNATCOLL.Traces.Syslog also contains a low-level interface\n to syslog, which, although fully functional, you should probably not use,\n since that would make your code system-dependent.
\n Syslog itself dispatches its output based on two criteria: the\n facility, which indicates what application emitted the message,\n and where it should be filed, and the level which indicates the\n urgency level of the message. Both of these criteria can be specified in\n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -12,36 +12,36 @@\n * previous |\n * GNATColl_0.0_documentation \u00bb\n * 4. Traces: Logging information\n ****** 4. Traces: Logging information\u00c2\u00b6 ******\n Most applications need to log various kinds of information: error messages,\n information messages or debug messages among others. These logs can be\n displayed and stored in a number of places: standard output, a file, the system\n-logger, an application-specific database table,...\n+logger, an application-specific database table,\u00e2\u0080\u00a6\n The package GNATCOLL.Traces addresses the various needs, except for the\n application-specific database, which of course is specific to your business and\n needs various custom fields in any case, which cannot be easily provided\n through a general interface.\n This module is organized around two tagged types (used through access types, in\n fact, so the latter are mentioned below as a shortcut):\n Trace_Handle\n This type defines a handle (similar to a file descriptor in other\n contexts) which is latter used to output messages. An application will\n generally define several handles, which can be enabled or disabled\n separately, therefore limiting the amount of logging.\n Trace_Stream\n Streams are the ultimate types responsible for the output of the\n messages. One or more handles are associated with each stream. The latter\n- can be a file, the standard output, a graphical window, a socket,... New\n+ can be a file, the standard output, a graphical window, a socket,\u00e2\u0080\u00a6 New\n types of streams can easily be defined in your application.\n ***** 4.1. Configuring traces\u00c2\u00b6 *****\n As mentioned above, an application will generally create severalTrace_Handle\n (typically one per module in the application). When new features are added to\n the application, the developers will generally need to add lots of traces to\n-help investigate problems once the application is installed at a customer's\n+help investigate problems once the application is installed at a customer\u00e2\u0080\u0099s\n site. The problem here is that each module might output a lot of information,\n thus confusing the logs; this also does not help debugging.\n TheGNATCOLL.Tracespackage allows the user to configure which handles should\n actually generate logs, and which should just be silent and not generate\n anything. Depending on the part of the application that needs to be\n investigated, one can therefore enable a set of handles or another, to be able\n to concentrate on that part of the application.\n@@ -54,68 +54,68 @@\n The configuration file is found in one of three places, in the following order:\n * The file name is specified in the source code in the call\n toParse_Config_File.\n * If no file name was specified in that call, the environment\n variableADA_DEBUG_FILEmight point to a configuration file.\n * If the above two attempts did not find a suitable configuration file, the\n current directory is searched for a file called.gnatdebug. Finally, the\n- user's home directory will also be searched for that file.\n+ user\u00e2\u0080\u0099s home directory will also be searched for that file.\n In all cases, the format of the configuration file is the same. Its goal is to\n associate the name of atrace_handlewith the name of atrace_streamon which it\n should be displayed.\n Streams are identified by a name. You can provide additional streams by\n creating a new tagged object (Defining_custom_stream_types). Here are the\n various possibilities to reference a stream:\n- \"name\"\n- where name is a string made of letters, digits and slash ('/')\n+ \u00e2\u0080\u009cname\u00e2\u0080\u009d\n+ where name is a string made of letters, digits and slash (\u00e2\u0080\u0098/\u00e2\u0080\u0099)\n characters. This is the name of a file to which the traces should be\n redirected. The previous contents of the file is discarded. If the name\n of the file is a relative path, it is relative to the location of the\n configuration file, not necessarily to the current directory when the\n file is parsed. In the file name,$$is automatically replaced by the\n process number.$Dis automatically replaced by the current date.$Tis\n automatically replaced by the current date and time. Other patterns of\n the form$name,${name}, or$(name)are substituted with the value of the\n- named environment variable, if it exists. If \">>\" is used instead of \">\"\n- to redirect to that stream, the file is appended to, instead of\n+ named environment variable, if it exists. If \u00e2\u0080\u009c>>\u00e2\u0080\u009d is used instead of\n+ \u00e2\u0080\u009c>\u00e2\u0080\u009d to redirect to that stream, the file is appended to, instead of\n truncated.\n- \"&1\"\n+ \u00e2\u0080\u009c&1\u00e2\u0080\u009d\n This syntax is similar to the one used on Unix shells, and indicates that\n the output should be displayed on the standard output for the\n application. If the application is graphical, and in particular on\n Windows platforms, it is possible that there is no standard output!\n- \"&2\"\n+ \u00e2\u0080\u009c&2\u00e2\u0080\u009d\n Similar to the previous one, but the output is sent to standard error.\n- \"&syslog\"\n+ \u00e2\u0080\u009c&syslog\u00e2\u0080\u009d\n Logging_to_syslog.\n Comments in a configuration file must be on a line of their own, and start\n-with--. Empty lines are ignored. The rest of the lines represent\n+with\u00e2\u0080\u0093. Empty lines are ignored. The rest of the lines represent\n configurations, as in:\n- * If a line contains the single character\"+\", it activates\n+ * If a line contains the single character\u00e2\u0080\u009c+\u00e2\u0080\u009d, it activates\n alltrace_handleby default. This means the rest of the configuration file\n should disable those handles that are not needed. The default is that all\n handles are disabled by default, and the configuration file should\n activate the ones it needs. The Ada source code can change the default\n status of each handles, as well\n- * If the line starts with the character\">\", followed by a stream name (as\n- defined above), this becomes the default stream. All handles will be\n+ * If the line starts with the character\u00e2\u0080\u009c>\u00e2\u0080\u009d, followed by a stream name\n+ (as defined above), this becomes the default stream. All handles will be\n displayed on that stream, unless otherwise specified. If the stream does\n not exist, it defaults to standard output.\n * Otherwise, the first token on the line is the name of a handle. If that\n is the only element on the line, the handle is activated, and will be\n displayed on the default stream.\n- Otherwise, the next element on the line should be a\"=\"sign, followed by\n- either\"yes\"or\"no\", depending on whether the handle should resp. be\n- enabled or disabled.\n- Finally, the rest of the line can optionally contain the\">\"character\n+ Otherwise, the next element on the line should be a\u00e2\u0080\u009c=\u00e2\u0080\u009dsign, followed\n+ by either\u00e2\u0080\u009cyes\u00e2\u0080\u009dor\u00e2\u0080\u009cno\u00e2\u0080\u009d, depending on whether the handle should\n+ resp. be enabled or disabled.\n+ Finally, the rest of the line can optionally contain the\u00e2\u0080\u009c>\u00e2\u0080\u009dcharacter\n followed by the name of the stream to which the handle should be\n directed.\n There is are two special cases for the names on this line: they can start\n- with either\"*.\"or\".*\"to indicate the settings apply to a whole set of\n- handles. See the example below.\n+ with either\u00e2\u0080\u009c*.\u00e2\u0080\u009dor\u00e2\u0080\u009c.*\u00e2\u0080\u009dto indicate the settings apply to a whole\n+ set of handles. See the example below.\n Here is a short example of a configuration file. It activates all handles by\n default, and defines four handles: two of them are directed to the default\n stream (standard error), the third one to a file on the disk, and the last one\n to the system logger syslog (if your system supports it, otherwise to the\n default stream, ie standard error):\n +\n >&2\n@@ -226,15 +226,15 @@\n Trace (Me, A & B & C & D & E);\n end if;\n ***** 4.3. Log decorators\u00c2\u00b6 *****\n Speaking of color, a number of decorators are defined byGNATCOLL.Traces. Their\n goal is not to be used for outputting information, but to configure what extra\n information should be output with all log messages. They are activated through\n the same configuration file as the traces, with the same syntax (i.e\n-either\"=yes\"or\"=no\").\n+either\u00e2\u0080\u009c=yes\u00e2\u0080\u009dor\u00e2\u0080\u009c=no\u00e2\u0080\u009d).\n Here is an exhaustive list:\n DEBUG.ABSOLUTE_TIME\n If this decorator is activated in the configuration file, the absolute\n time when Trace is called is automatically added to the output, when the\n streams supports it (in particular, this has no effect for syslog, which\n already does this on its own).\n DEBUG.MICRO_TIME\n@@ -247,21 +247,21 @@\n If this decorator is activated, then the stack trace is also displayed.\n It can be converted to a symbolic stack trace through the use of the\n external applicationaddr2line, but that would be too costly to do this\n automatically for each message.\n DEBUG.LOCATION\n If this decorator is activated, the location of the call to Trace is\n automatically displayed. This is a file:line:column information. This\n- works even when the executable wasn't compiled with debug information\n+ works even when the executable wasn\u00e2\u0080\u0099t compiled with debug information\n DEBUG.ENCLOSING_ENTITY\n Activate this decorator to automatically display the name of the\n subprogram that contains the call toTrace.\n DEBUG.COLORS\n If this decorator is activated, the messages will use colors for the\n- various fields, if the stream supports it (syslog doesn't).\n+ various fields, if the stream supports it (syslog doesn\u00e2\u0080\u0099t).\n DEBUG.COUNT\n This decorator displays two additional numbers on each line: the first is\n the number of times this handle was used so far in the application, the\n second is the total number of traces emitted so far. These numbers can\n for instance be used to set conditional breakpoints on a specific trace\n (break ongnat.traces.logorgnat.traces.traceand check the value\n ofHandle.Count. It can also be used to refer to a specific line in some\n@@ -283,15 +283,15 @@\n output on a single line:\n [MODULE] 6/247 User Message (2007-07-03 13:12:53.46)\n (elapsed: 2ms)(loc: gnatcoll-traces.adb:224)\n (entity:GNATCOLL.Traces.Log)\n (callstack: 40FD9902 082FCFDD 082FE8DF )\n Depending on your application, there are lots of other possible decorators that\n could be useful (for instance the current thread, or the name of the executable\n-when you have several of them,...). SinceGNATCOLL.Tracescannot provide all\n+when you have several of them,\u00e2\u0080\u00a6). SinceGNATCOLL.Tracescannot provide all\n possible decorators, it provides support, through tagged types, so that you can\n create your own decorators.\n This needs you to override theTrace_Handle_Recordtagged type. Since this type\n is created through calls toGNATCOLL.Traces.Create. This is done by providing an\n additionalFactoryparameter toCreate; this is a function that allocates and\n returns the new handle.\n Then you can override either (or both) of the primitive\n@@ -326,23 +326,23 @@\n even a CORBA ORB) to communicate with another application which is charge of\n monitoring your application.\n You do not need the code below if you simply want to have a new stream in your\n application (for instance using one for logging Info messages, one for Error\n messages, and so on). In this case, the functionCreateis all you need.\n GNATCOLL.Tracesprovides the typeTrace_Stream_Record, which can be overridden to\n redirect the traces to your own streams.\n-Let's assume for now that you have defined a new type of stream\n-(called\"mystream\"). To keep the example simple, we will assume this stream also\n-redirects to a file. For flexibility, however, you want to let the user\n+Let\u00e2\u0080\u0099s assume for now that you have defined a new type of stream\n+(called\u00e2\u0080\u009cmystream\u00e2\u0080\u009d). To keep the example simple, we will assume this stream\n+also redirects to a file. For flexibility, however, you want to let the user\n configure the file name from the traces configuration file. Here is an example\n of a configuration file that sets the default stream to a file called foo, and\n redirects a specific handle to another file called bar. Note how the same\n syntax that was used for standard output and standard error is also reused (ie\n-the stream name starts with the\"&\"symbol, to avoid confusion with standard file\n-names):\n+the stream name starts with the\u00e2\u0080\u009c&\u00e2\u0080\u009dsymbol, to avoid confusion with standard\n+file names):\n >&mystream:foo\n MODULE=yes >&mystream:bar\n You need of course to do a bit of coding in Ada to create the stream. This is\n done by creating a new child ofTrace_Stream_Record, and override the primitive\n operationPut.\n The whole output message is given as a single parameter toPut:\n type My_Stream is new Trace_Stream_Record with record\n@@ -355,21 +355,21 @@\n S : Msg_Strings.Unconstrained_String_Access;\n L : Natural;\n begin\n Str.Get_String (S, L);\n Put (Stream.File.all, String (S (1 .. L)));\n end Put;\n The above code did not open the file itself, as you might have noticed, nor did\n-it register the name\"mystream\"so that it can be used in the configuration file.\n-All this is done by creating a factory, ie a function in charge of creating the\n-new stream.\n+it register the name\u00e2\u0080\u009cmystream\u00e2\u0080\u009dso that it can be used in the configuration\n+file. All this is done by creating a factory, ie a function in charge of\n+creating the new stream.\n A factory is also a tagged object (so that you can store custom information in\n it), with a single primitive operation,New_Stream, in charge of creating and\n initializing a new stream. This operation receives in parameter the argument\n-specified by the user in the configuration file (after the\":\"character, if\n+specified by the user in the configuration file (after the\u00e2\u0080\u009c:\u00e2\u0080\u009dcharacter, if\n any), and must return a newly allocated stream. This function is also never\n called twice with the same argument, sinceGNATCOLL.Tracesautomatically reuses\n an existing stream when one with the same name and arguments already exists:\n type My_Stream_Factory is new Stream_Factory with null record;\n \n overriding function New_Stream\n (Self : My_Stream_Factory; Args : String) return Trace_Stream\n@@ -382,30 +382,30 @@\n end Factory;\n \n Fact : access My_Stream_Factory := new My_Stream_Factory;\n Register_Stream_Factory (\"mystream\", Fact);\n ***** 4.5. Logging to syslog\u00c2\u00b6 *****\n Among the predefined streams, GNATColl gives access to the system loggersyslog.\n This is a standard utility on all Unix systems, but is not available on other\n-systems. When you compile GNATColl, you should specify the switch--enable-\n-syslogto configure to activate the support. If either this switch wasn't\n+systems. When you compile GNATColl, you should specify the switch\u00e2\u0080\u0093enable-\n+syslogto configure to activate the support. If either this switch wasn\u00e2\u0080\u0099t\n specified, or configure could not find the relevant header files anyway, then\n support forsyslogwill not be available. In this case, the\n packageGNATCOLL.Traces.Syslogis still available, but contains a single function\n that does nothing. If your configuration files redirect some trace handles\n-to\"syslog\", they will instead be redirect to the default stream or to standard\n-output.\n+to\u00e2\u0080\u009csyslog\u00e2\u0080\u009d, they will instead be redirect to the default stream or to\n+standard output.\n Activating support for syslog requires the following call in your application:\n GNATCOLL.Traces.Syslog.Register_Syslog_Stream;\n This procedure is always available, whether your system supports or not syslog,\n-and will simply do nothing if it doesn't support syslog. This means that you do\n-not need to have conditional code in your application to handle that, and you\n-can let GNATColl take care of this.\n+and will simply do nothing if it doesn\u00e2\u0080\u0099t support syslog. This means that you\n+do not need to have conditional code in your application to handle that, and\n+you can let GNATColl take care of this.\n After the above call, trace handles can be redirected to a stream\n-named\"syslog\".\n+named\u00e2\u0080\u009csyslog\u00e2\u0080\u009d.\n The packageGNATCOLL.Traces.Syslogalso contains a low-level interface to syslog,\n which, although fully functional, you should probably not use, since that would\n make your code system-dependent.\n Syslog itself dispatches its output based on two criteria: thefacility, which\n indicates what application emitted the message, and where it should be filed,\n and thelevelwhich indicates the urgency level of the message. Both of these\n criteria can be specified in theGNATCOLL.Tracesconfiguration file, as follows:\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/tribooleans.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/tribooleans.html", "unified_diff": "@@ -43,21 +43,21 @@\n
\n 15. Tribooleans: Three state logic\u00b6
\n Through the package GNATCOLL.Tribooleans, GNATColl provides\n a type that extends the classical Boolean type with an\n Indeterminate value.
\n There are various cases where such a type is useful. One example we have\n is when a user is doing a search (on a database or any set of data), and\n-can specify some optional boolean criteria ("must the contact be french?").\n-He can choose to only see french people ("True"), to see no french people\n-at all ("False"), or to get all contacts ("Indeterminate"). With a classical\n+can specify some optional boolean criteria (\u201cmust the contact be french?\u201d).\n+He can choose to only see french people (\u201cTrue\u201d), to see no french people\n+at all (\u201cFalse\u201d), or to get all contacts (\u201cIndeterminate\u201d). With a classical\n boolean, there is no way to cover all these cases.
\n Of course, there are more advanced use cases for such a type. To support\n these cases, the Tribooleans package overrides the usual logical\n-operations "and", "or", "xor", "not" and\n+operations \u201cand\u201d, \u201cor\u201d, \u201cxor\u201d, \u201cnot\u201d and\n provides an Equal function.
\n See the specs of the package to see the truth tables associated with those\n operators.
\n \n \n \n \n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -13,21 +13,21 @@\n * GNATColl_0.0_documentation \u00bb\n * 15. Tribooleans: Three state logic\n ****** 15. Tribooleans: Three state logic\u00c2\u00b6 ******\n Through the packageGNATCOLL.Tribooleans, GNATColl provides a type that extends\n the classicalBooleantype with anIndeterminatevalue.\n There are various cases where such a type is useful. One example we have is\n when a user is doing a search (on a database or any set of data), and can\n-specify some optional boolean criteria (\"must the contact be french?\"). He can\n-choose to only see french people (\"True\"), to see no french people at all\n-(\"False\"), or to get all contacts (\"Indeterminate\"). With a classical boolean,\n-there is no way to cover all these cases.\n+specify some optional boolean criteria (\u00e2\u0080\u009cmust the contact be french?\u00e2\u0080\u009d). He\n+can choose to only see french people (\u00e2\u0080\u009cTrue\u00e2\u0080\u009d), to see no french people at\n+all (\u00e2\u0080\u009cFalse\u00e2\u0080\u009d), or to get all contacts (\u00e2\u0080\u009cIndeterminate\u00e2\u0080\u009d). With a\n+classical boolean, there is no way to cover all these cases.\n Of course, there are more advanced use cases for such a type. To support these\n cases, theTribooleanspackage overrides the usual logical\n-operations\"and\",\"or\",\"xor\",\"not\"and provides anEqualfunction.\n+operations\u00e2\u0080\u009cand\u00e2\u0080\u009d,\u00e2\u0080\u009cor\u00e2\u0080\u009d,\u00e2\u0080\u009cxor\u00e2\u0080\u009d,\u00e2\u0080\u009cnot\u00e2\u0080\u009dand provides anEqualfunction.\n See the specs of the package to see the truth tables associated with those\n operators.\n [Logo]\n *** Previous topic ***\n 14._VFS:_Manipulating_Files\n *** Next topic ***\n 16._Geometry:_primitive_geometric_operations\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/html/vfs.html", "source2": "./usr/share/doc/libgnatcoll-doc/html/vfs.html", "unified_diff": "@@ -67,35 +67,35 @@\n course, might be an expansive computation). To make this easier,\n GNATColl provides a type that encapsulates the notion of a file,\n and removes the need for the application to indicate whether it needs a\n full name, a base name, or any other part of the file name.\n \n 14.1. Filesystems abstraction\u00b6
\n There exists lots of different filesystems on all machines. These include\n-such things as FAT, VFAT, NTFS, ext2, VMS,.... However, all these can\n+such things as FAT, VFAT, NTFS, ext2, VMS,\u2026. However, all these can\n be grouped into three families of filesystems:
\n \n windows-based filesystems
\n On such filesystems, the full name of a file is split into three parts: the\n-name of the drive (c:, d:,...), the directories which are separated by\n+name of the drive (c:, d:,\u2026), the directories which are separated by\n a backslash, and the base name. Such filesystems are sometimes inaccurately\n said to be case insensitive: by that, one means that the same file can be\n accessed through various casing. However, a user is generally expecting a\n specific casing when a file name is displayed, and the application should\n strive to preserve that casing (as opposed to, for instance, systematically\n convert the file name to lower cases).
\n A special case of a windows-based filesystems is that emulated by the\n cygwin development environment. In this case, the filesystem is seen as if\n it was unix-based (see below), with one special quirk to indicate the drive\n-letter (the file name starts with "/cygwin/c/").
\n+letter (the file name starts with \u201c/cygwin/c/\u201d).\n \n unix-based filesystems
\n On such filesystems, directories are separated by forward slashed. File\n-names are case sensitive, that is a directory can contain both "foo" and\n-"Foo", which is not possible on windows-based filesystems.
\n+names are case sensitive, that is a directory can contain both \u201cfoo\u201d and\n+\u201cFoo\u201d, which is not possible on windows-based filesystems.\n \n vms filesystem
\n This filesystem represents path differently than the other two, using\n brackets to indicate parent directories
\n \n
\n A given machine can actually have several file systems in parallel, when\n@@ -109,15 +109,15 @@\n a set of tagged types in the GNATCOLL.Filesystem package and its\n children. Such a type has primitive operations to manipulate the names of\n files (retrieving the base name from a full name for instance), to check\n various attributes of the file (is this a directory, a symbolic link, is the\n file readable or writable), or to\n manipulate the file itself (copying, deleting, reading and writing).\n It provides similar operations for directories (creating or deleting paths,\n-reading the list of files in a directory,...).
\n+reading the list of files in a directory,\u2026).\n It also provides information on the system itself (the list of available drives\n on a windows machine for instance).
\n The root type Filesystem_Record is abstract, and is specialized in\n various child types. A convenient factory is provided to return the filesystem\n appropriate for the local machine (Get_Local_Filesystem), but you\n might chose to create your own factory in your application if you have\n specialized needs (Remote filesystems).
\n@@ -148,24 +148,24 @@\n \n 14.2. Remote filesystems\u00b6
\n Once the abstract for filesystems exists, it is tempting to use it to\n access files on remote machines. There are of course lots of differences\n with filesystems on the local machine: their names are manipulated\n similarly (although you need to somehow indicate on which host they are\n to be found), but any operation of the file itself needs to be done on the\n-remote host itself, as it can't be done through calls to the system's\n+remote host itself, as it can\u2019t be done through calls to the system\u2019s\n standard C library.
\n Note that when we speak of disks on a remote machine, we indicate disks\n that are not accessible locally, for instance through NFS mounts or samba.\n In such cases, the files are accessed transparently as if they were local,\n and all this is taken care of by the system itself, no special layer is\n needed at the application level.
\n GNATColl provides an extensive framework for manipulating such\n remote files. It knows what commands need to be run on the remote host to\n-perform the operations ("cp" or "copy", "stat" or "dir /a-d",...) and\n+perform the operations (\u201ccp\u201d or \u201ccopy\u201d, \u201cstat\u201d or \u201cdir /a-d\u201d,\u2026) and\n will happily perform these operations when you try to manipulate such\n files.
\n There are however two operations that your own application needs to take\n care of to take full advantage of remote files.
\n \n 14.2.1. Filesystem factory\u00b6
\n GNATColl cannot know in advance what filesystem is running on the\n@@ -219,15 +219,15 @@\n different machines.
\n GNATColl does not try to second guess your intention here. It\n performs all its remote operations through a tagged type defined in\n GNATCOLL.Filesystem.Transport. This type is abstract, and must be\n overridden in your application. For instance, GPS has a full support for\n choosing which protocol to use on which host, what kind of filesystem is\n running on that host, to recognize password queries from the transport\n-protocol,.... All these can be encapsulated in the transport\n+protocol,\u2026. All these can be encapsulated in the transport\n protocol.
\n Once you have created one or more children of\n Filesystem_Transport_Record, you associate them with your\n instance of the filesystem through a call to the Setup primitive\n operation of the filesystem. See the factory example above.
\n \n \n", "details": [{"source1": "html2text {}", "source2": "html2text {}", "unified_diff": "@@ -36,33 +36,33 @@\n the API, and certainly fills the code with lots of conversion from full name to\n base name, and sometimes reverse (which, of course, might be an expansive\n computation). To make this easier, GNATColl provides a type that encapsulates\n the notion of a file, and removes the need for the application to indicate\n whether it needs a full name, a base name, or any other part of the file name.\n ***** 14.1. Filesystems abstraction\u00c2\u00b6 *****\n There exists lots of different filesystems on all machines. These include such\n-things as FAT, VFAT, NTFS, ext2, VMS,.... However, all these can be grouped\n+things as FAT, VFAT, NTFS, ext2, VMS,\u00e2\u0080\u00a6. However, all these can be grouped\n into three families of filesystems:\n * windows-based filesystems\n On such filesystems, the full name of a file is split into three parts:\n- the name of the drive (c:, d:,...), the directories which are separated\n+ the name of the drive (c:, d:,\u00e2\u0080\u00a6), the directories which are separated\n by a backslash, and the base name. Such filesystems are sometimes\n inaccurately said to be case insensitive: by that, one means that the\n same file can be accessed through various casing. However, a user is\n generally expecting a specific casing when a file name is displayed, and\n the application should strive to preserve that casing (as opposed to, for\n instance, systematically convert the file name to lower cases).\n A special case of a windows-based filesystems is that emulated by the\n cygwin development environment. In this case, the filesystem is seen as\n if it was unix-based (see below), with one special quirk to indicate the\n- drive letter (the file name starts with \"/cygwin/c/\").\n+ drive letter (the file name starts with \u00e2\u0080\u009c/cygwin/c/\u00e2\u0080\u009d).\n * unix-based filesystems\n On such filesystems, directories are separated by forward slashed. File\n- names are case sensitive, that is a directory can contain both \"foo\" and\n- \"Foo\", which is not possible on windows-based filesystems.\n+ names are case sensitive, that is a directory can contain both \u00e2\u0080\u009cfoo\u00e2\u0080\u009d\n+ and \u00e2\u0080\u009cFoo\u00e2\u0080\u009d, which is not possible on windows-based filesystems.\n * vms filesystem\n This filesystem represents path differently than the other two, using\n brackets to indicate parent directories\n A given machine can actually have several file systems in parallel, when a\n remote disk is mounted through NFS or samba for instance. There is generally no\n easy way to guess that information automatically, and it generally does not\n matter since the system will convert from the native file system to that of the\n@@ -72,15 +72,15 @@\n GNATColl abstracts the differences between these filesystems through a set of\n tagged types in theGNATCOLL.Filesystempackage and its children. Such a type has\n primitive operations to manipulate the names of files (retrieving the base name\n from a full name for instance), to check various attributes of the file (is\n this a directory, a symbolic link, is the file readable or writable), or to\n manipulate the file itself (copying, deleting, reading and writing). It\n provides similar operations for directories (creating or deleting paths,\n-reading the list of files in a directory,...).\n+reading the list of files in a directory,\u00e2\u0080\u00a6).\n It also provides information on the system itself (the list of available drives\n on a windows machine for instance).\n The root typeFilesystem_Recordis abstract, and is specialized in various child\n types. A convenient factory is provided to return the filesystem appropriate\n for the local machine (Get_Local_Filesystem), but you might chose to create\n your own factory in your application if you have specialized needs (Remote\n filesystems).\n@@ -106,24 +106,24 @@\n subprogramsLocale_To_DisplayandSet_Locale_To_Display_Encoder\n ***** 14.2. Remote filesystems\u00c2\u00b6 *****\n Once the abstract for filesystems exists, it is tempting to use it to access\n files on remote machines. There are of course lots of differences with\n filesystems on the local machine: their names are manipulated similarly\n (although you need to somehow indicate on which host they are to be found), but\n any operation of the file itself needs to be done on the remote host itself, as\n-it can't be done through calls to the system's standard C library.\n+it can\u00e2\u0080\u0099t be done through calls to the system\u00e2\u0080\u0099s standard C library.\n Note that when we speak of disks on a remote machine, we indicate disks that\n are not accessible locally, for instance through NFS mounts or samba. In such\n cases, the files are accessed transparently as if they were local, and all this\n is taken care of by the system itself, no special layer is needed at the\n application level.\n GNATColl provides an extensive framework for manipulating such remote files. It\n knows what commands need to be run on the remote host to perform the operations\n-(\"cp\" or \"copy\", \"stat\" or \"dir /a-d\",...) and will happily perform these\n-operations when you try to manipulate such files.\n+(\u00e2\u0080\u009ccp\u00e2\u0080\u009d or \u00e2\u0080\u009ccopy\u00e2\u0080\u009d, \u00e2\u0080\u009cstat\u00e2\u0080\u009d or \u00e2\u0080\u009cdir /a-d\u00e2\u0080\u009d,\u00e2\u0080\u00a6) and will happily\n+perform these operations when you try to manipulate such files.\n There are however two operations that your own application needs to take care\n of to take full advantage of remote files.\n **** 14.2.1. Filesystem factory\u00c2\u00b6 ****\n GNATColl cannot know in advance what filesystem is running on the remote host,\n so it does not try to guess it. As a result, your application should have a\n factory that creates the proper instance of aFilesystem_Recorddepending on the\n host. Something like:\n@@ -168,15 +168,15 @@\n (and will likely be asked to the user). Furthermore, you might not want to use\n the same protocol to connect to different machines.\n GNATColl does not try to second guess your intention here. It performs all its\n remote operations through a tagged type defined\n inGNATCOLL.Filesystem.Transport. This type is abstract, and must be overridden\n in your application. For instance, GPS has a full support for choosing which\n protocol to use on which host, what kind of filesystem is running on that host,\n-to recognize password queries from the transport protocol,.... All these can be\n+to recognize password queries from the transport protocol,\u00e2\u0080\u00a6. All these can be\n encapsulated in the transport protocol.\n Once you have created one or more children ofFilesystem_Transport_Record, you\n associate them with your instance of the filesystem through a call to\n theSetupprimitive operation of the filesystem. See the factory example above.\n ***** 14.3. Virtual files\u00c2\u00b6 *****\n As we have seen, the filesystem type abstracts all the operations for\n manipulating files and their names. There is however another aspect when\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/boyer_moore.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/boyer_moore.txt", "unified_diff": "@@ -12,15 +12,15 @@\n efficient depending on the pattern.\n \n It deals with string searching, and does not handle regular\n expressions for instance.\n \n This algorithm needs to preprocess its key (the searched string), but\n does not need to perform any specific analysis of the string to be\n-searched. Its execution time can be sub-linear: it doesn't need to\n+searched. Its execution time can be sub-linear: it doesn\u2019t need to\n actually check every character of the string to be searched, and will\n skip over some of them. The worst case for this algorithm has been\n proved to need approximately 3 * N comparisons, hence the algorithm\n has a complexity of O(n).\n \n The longer the key, the faster the algorithm in general, since that\n provides more context as to how many characters can be skipped when a\n@@ -29,18 +29,18 @@\n We will not go into the details of the algorithm, although a general\n description follows: when the pattern is being preprocessed, Boyer-\n Moore computes how many characters can be skipped if an incorrect\n match is found at that point, depending on which character was read.\n In addition, this algorithm tries to match the key starting from its\n end, which in general provides a greater number of characters to skip.\n \n-For instance, if you are looking for \"ABC\" in the string \"ABDEFG\" at\n-the first position, the algorithm will compare \"C\" and \"D\". Since \"D\"\n-does not appear in the key \"ABC\", it knows that it can immediately\n-skip 3 characters and start the search after \"D\".\n+For instance, if you are looking for \u201cABC\u201d in the string \u201cABDEFG\u201d at\n+the first position, the algorithm will compare \u201cC\u201d and \u201cD\u201d. Since \u201cD\u201d\n+does not appear in the key \u201cABC\u201d, it knows that it can immediately\n+skip 3 characters and start the search after \u201cD\u201d.\n \n Using this package is extremely easy, and it has only a limited API:\n \n declare\n Str : constant String := \"ABDEABCFGABC\";\n Key : Pattern;\n Index : Integer;\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/building.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/building.txt", "unified_diff": "@@ -45,15 +45,15 @@\n \n *SOURCE_DIR*\n For out-of-tree build\n \n *ENABLE_SHARED*\n Controls whether shared and static-pic library variants should be\n built: yes (default) or no. If you only intend to use static\n- libraries, specify 'no'.\n+ libraries, specify \u2018no\u2019.\n \n Module-specific:\n \n *GNATCOLL_MMAP*\n Whether MMAP is supported: yes (default) or no; this has no effect\n on Windows where embedded MMAP implementation is always provided.\n \n@@ -87,13 +87,13 @@\n build it first. This command will install all library variants that\n were built.\n \n Your application can now use the GNATColl code through a project file,\n by adding a \"with\" clause to \"gnatcoll.gpr\".\n \n If you wish to install in a different location than was specified at\n-configure time, you can override the \"prefix\" variable from the\n+configure time, you can override the \u201cprefix\u201d variable from the\n command line, for instance:\n \n make prefix=/alternate/directory install\n \n This does not require any recompilation.\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/config.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/config.txt.gz", "unified_diff": null, "details": [{"source1": "config.txt", "source2": "config.txt", "unified_diff": "@@ -11,30 +11,30 @@\n could chose to use an XML file (but these are in general hard to edit\n manually), a binary file, or any other format. One format that is\n found very often is the one used by a lot of Windows applications (the\n \".ini\" file format).\n \n *GNATCOLL.Config* is independent from the actual format you are using,\n and you can add your own parsers compatible with the *GNATCOLL.Config*\n-API. Out of the box, support is provided for \".ini\" files, so let's\n+API. Out of the box, support is provided for \".ini\" files, so let\u2019s\n detail this very simply format:\n \n # A single-line comment\n [Section1]\n key1 = value\n key2=value2\n \n [Section2]\n key1 = value3\n \n-Comments are (by default) started with *'#'* signs, but you can\n+Comments are (by default) started with *\u2018#\u2019* signs, but you can\n configure that and use any prefix you want. The *(key, value)* pairs\n are then organized into optional sections (if you do not start a\n section before the first key, that key will be considered as part of\n-the *\"\"* section). A section then extends until the start of the next\n+the *\u201c\u201d* section). A section then extends until the start of the next\n section.\n \n The values associated with the various keys can be strings, integers\n or booleans. Spaces on the left and right of the values and keys are\n trimmed, and therefore irrelevant.\n \n Support is providing for interpreting the values as file or directory\n@@ -84,20 +84,20 @@\n Put_Line (Config.Get (\"section.key\")); -- Ada05 dotted notation\n \n Again, the values are by default read as strings, but you can\n interpret them as integers, booleans or files.\n \n A third layer is provided in *GNATCOLL.Config*. This solves the issue\n of possible typos in code: in the above example, we could have made a\n-typo when writting *\"section.key\"*. That would only be detected at run\n+typo when writting *\u201csection.key\u201d*. That would only be detected at run\n time. Another issue is that we might decide to rename the key in the\n configuration file. We would then have to go through all the\n application code to find all the places where this key is references\n-(and that can't be based on cross-references generated by the\n-compiler, since that's inside a string).\n+(and that can\u2019t be based on cross-references generated by the\n+compiler, since that\u2019s inside a string).\n \n To solve this issue, it is possible to declare a set of constants that\n represent the keys, and then use these to access the values, solving\n the two problems above:\n \n Section_Key1 : constant Config_Key := Create (\"Key1\", \"Section\");\n Section_Key2 : constant Config_Key := Create (\"Key2\", \"Section\");\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/email.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/email.txt.gz", "unified_diff": null, "details": [{"source1": "email.txt", "source2": "email.txt", "unified_diff": "@@ -151,8 +151,8 @@\n 11.4. Creating messages\n =======================\n \n The subprograms in *GNATCOLL.Email* can also be used to create a\n message from scratch. Alternatively, if you have already parsed a\n message, you can alter it, or easily generate a reply to it (using the\n *Reply_To* subprogram. The latter will preset some headers, so that\n-message threading is preserved in the user's mailers.\n+message threading is preserved in the user\u2019s mailers.\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/filling.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/filling.txt", "unified_diff": "@@ -1,12 +1,12 @@\n 9. **Paragraph filling**: formatting text\n *****************************************\n \n The package *GNATCOLL.Paragraph_Filling* provides several algorithms\n-for filling paragraphs---formatting them to take up the minimal number\n+for filling paragraphs\u2014formatting them to take up the minimal number\n of lines and to look better. *Knuth_Fill* is based on an algorithm\n invented by Donald Knuth, and used in TeX. *Pretty_Fill* uses a\n different algorithm, which was judged by some to produce more\n aesthetically pleasing output.\n \n More detailed documentation may be found in the comments in the\n package spec.\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/geometry.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/geometry.txt", "unified_diff": "@@ -1,14 +1,14 @@\n 16. **Geometry**: primitive geometric operations\n ************************************************\n \n GNATColl provides the package *GNATCOLL.Geometry*. This package\n includes a number of primitive operations on geometric figures like\n points, segments, lines, circles, rectangles and polygons. In\n-particular, you can compute their intersections, the distances,...\n+particular, you can compute their intersections, the distances,\u2026\n \n This package is generic, so that you can specify the type of\n coordinates you wish to handle:\n \n declare\n package Float_Geometry is new GNATCOLL.Geometry (Float);\n use Float_Geometry;\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/json.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/json.txt", "unified_diff": "@@ -1,13 +1,13 @@\n 21. **JSON**: handling JSON data\n ********************************\n \n JSON is a format often used on the web to communicate between a server\n and a browser, or between servers. It plays a similar role to XML, but\n-it has a much lighter syntax. On the other hand, it doesn't provide\n+it has a much lighter syntax. On the other hand, it doesn\u2019t provide\n advanced features like validation, which XML provides.\n \n The \"GNATCOLL.JSON\" package provides an Ada API to decode JSON data\n from strings and to encode that data back to strings. It also allows\n one to create and modify JSON data.\n \n \n@@ -79,17 +79,17 @@\n My_Obj.Set_Field (\"name\", \"theName\");\n \n -- Now serialize it. The call below will display:\n -- {\"field1\": 1, \"name\": \"thename\"}\n Put_Line (My_Obj.Write);\n end JSON_Test;\n \n-The above uses the Ada 2005 \"dot notation\" to call primitive\n+The above uses the Ada 2005 \u201cdot notation\u201d to call primitive\n operations (\".Set_Field\", \".Write\"), but naturally the more\n-traditional \"prefix notation\" is also available:\n+traditional \u201cprefix notation\u201d is also available:\n \n Set_Field (My_Obj, \"field1\", Create (1));\n \n It is also possible to create JSON arrays. These are not tagged types,\n so the prefix notation has to be used. Here is a further example that\n sets another field in the object we had before (\"My_Obj\"):\n \n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/mmap.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/mmap.txt.gz", "unified_diff": null, "details": [{"source1": "mmap.txt", "source2": "mmap.txt", "unified_diff": "@@ -31,32 +31,32 @@\n \n When your application does not need to read the whole contents of the\n file, the speed up can be several orders of magnitude faster than\n *read()*. Even when you need to read the whole contents, using\n *mmap()* is still two or three times faster, which is especially\n interesting on big files.\n \n-GNATColl's *GNATCOLL.Mmap* package provides a high-level abstraction\n+GNATColl\u2019s *GNATCOLL.Mmap* package provides a high-level abstraction\n on top of the *mmap* system call. As for most other packages in\n GNATColl, it also nicely handles the case where your system does not\n actually support *mmap*, and will in that case fallback on using\n *read* and *write* transparently. In such a case, your application\n will perform a little slower, but you do not have to modify your code\n to adapt it to the new system.\n \n Due to the low-level C API that is needed underneath, the various\n subprograms in this package do not directly manipulate Ada strings\n with valid bounds. Instead, a new type *Str_Access* was defined. It\n does not contain the bounds of the string, and therefore you cannot\n-use the usual *'First* and *'Last* attributes on that string. But\n+use the usual *\u2018First* and *\u2018Last* attributes on that string. But\n there are other subprograms that provide those values.\n \n Here is how to read a whole file at once. This is what your code will\n use in most cases, unless you expect to read files bigger than\n-*Integer'Last* bytes long. In such cases you need to read chunks of\n+*Integer\u2019Last* bytes long. In such cases you need to read chunks of\n the file separately. The *mmap* system call is such that its\n performance does not depend on the size of the file your are mapping.\n Of course, this could be a problem if *GNATCOLL.Mmap* falls back on\n calling *read*, since in that case it needs to allocate as much memory\n as your file. Therefore in some cases you will also want to only read\n chunks of the file at once:\n \n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/refcount.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/refcount.txt.gz", "unified_diff": null, "details": [{"source1": "refcount.txt", "source2": "refcount.txt", "unified_diff": "@@ -88,15 +88,15 @@\n \n type My_Type is new Weak_Refcounted with...;\n \n package Pointers is new Weakref_Pointers (My_Type);\n \n The above code can be used instead of the code in the first example,\n and provides the same capability (smart pointers, reference counted\n-types,...). However, the type *My_Type* is slightly bigger, but can be\n+types,\u2026). However, the type *My_Type* is slightly bigger, but can be\n used to create weak references:\n \n WR : Weak_Ref;\n \n declare\n R : Ref;\n Tmp : My_Type := ...;\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/scripting.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/scripting.txt.gz", "unified_diff": null, "details": [{"source1": "scripting.txt", "source2": "scripting.txt", "unified_diff": "@@ -1,22 +1,22 @@\n 3. **Scripts**: Embedding script languages\n ******************************************\n \n In a lot of contexts, you want to give the possibility to users to\n extend your application. This can be done in several ways: define an\n Ada API from which they can build dynamically loadable modules,\n provide the whole source code to your application and let users\n-recompile it, interface with a simpler scripting languages,...\n+recompile it, interface with a simpler scripting languages,\u2026\n \n Dynamically loadable modules can be loaded on demand, as their name\n indicate. However, they generally require a relatively complex\n environment to build, and are somewhat less portable. But when your\n users are familiar with Ada, they provide a programming environment in\n which they are comfortable. As usual, changing the module requires\n-recompilation, re-installation,...\n+recompilation, re-installation,\u2026\n \n Providing the source code to your application is generally even more\n complex for users. This requires an even more complex setup, your\n application is generally too big for users to dive into, and\n modifications done by one users are hard to provide to other users, or\n will be lost when you distribute a new version of your application.\n \n@@ -32,115 +32,115 @@\n used extensively in the GPS programming environment for its python\n interface.\n \n [image: TIP:][image] Each of the scripting language is optional\n \n This module can be compiled with any of these languages as an optional\n dependency (except for the shell language, which is always built-in,\n-but is extremely minimal, and doesn't have to be loaded at run time\n+but is extremely minimal, and doesn\u2019t have to be loaded at run time\n anyway). If the necessary libraries are found on the system, GNATColl\n will be build with support for the corresponding language, but your\n application can chose at run time whether or not to activate the\n support for a specific language.\n \n [image: TIP:][image] Use a scripting language to provide an automatic\n testing framework for your application.\n \n The GPS environment uses python command for its *automatic test\n suite*, including graphical tests such as pressing on a button,\n-selecting a menu,...\n+selecting a menu,\u2026\n \n \n 3.1. Supported languages\n ========================\n \n The module provides built-in support for several scripting languages,\n-and other languages can \"easily\" be added. Your application does not\n+and other languages can \u201ceasily\u201d be added. Your application does not\n change when new languages are added, since the interface to export\n subprograms and classes to the scripting languages is language-\n neutral, and will automatically export to all known scripting\n languages.\n \n The Core component provides support for the following language:\n \n *Shell*\n- This is a very simple-minded scripting language, which doesn't\n+ This is a very simple-minded scripting language, which doesn\u2019t\n provide flow-control instructions (The Shell language).\n \n Optional components add support for other languages, e.g. Python.\n-Please refer to the corresponding component's documentation.\n+Please refer to the corresponding component\u2019s documentation.\n \n \n 3.1.1. The Shell language\n -------------------------\n \n The shell language was initially developed in the context of the GPS\n programming environment, as a way to embed scripting commands in XML\n configuration files.\n \n In this language, you can execute any of the commands exported by the\n application, passing any number of arguments they need. Arguments to\n function calls can, but need not, be quoted. Quoting is only mandatory\n-when they contain spaces, newline characters, or double-quotes ('\"').\n+when they contain spaces, newline characters, or double-quotes (\u2018\u201d\u2019).\n To quote an argument, surround it by double-quotes, and precede each\n double-quote it contains by a backslash character. Another way of\n quoting is similar to what python provides, which is to triple-quote\n-the argument, i.e. surround it by '\"\"\"' on each side. In such a case,\n+the argument, i.e. surround it by \u2018\u201d\u201d\u201d\u2019 on each side. In such a case,\n any special character (in particular other double-quotes or\n backslashes) lose their special meaning and are just taken as part of\n the argument. This is in particular useful when you do not know in\n advance the contents of the argument you are quoting:\n \n Shell> function_name arg1 \"arg 2\" \"\"\"arg 3\"\"\"\n \n Commands are executed as if on a stack machine: the result of a\n command is pushed on the stack, and later commands can reference it\n using *%* following by a number. By default, the number of previous\n results that are kept is set to 9, and this can only be changed by\n modifying the source code for GNATColl. The return values are also\n modified by commands executed internally by your application, and that\n-might have no visible output from the user's point of view. As a\n-result, you should never assume you know what *%1*,... contain unless\n+might have no visible output from the user\u2019s point of view. As a\n+result, you should never assume you know what *%1*,\u2026 contain unless\n you just executed a command in the same script:\n \n Shell> function_name arg1\n Shell> function2_name %1\n \n In particular, the *%1* syntax is used when emulating object-oriented\n programming in the shell. A method of a class is just a particular\n-function that contains a '.' in its name, and whose first implicit\n+function that contains a \u2018.\u2019 in its name, and whose first implicit\n argument is the instance on which it applies. This instance is\n generally the result of calling a constructor in an earlier call.\n-Assuming, for instance, that we have exported a class \"Base\" to the\n+Assuming, for instance, that we have exported a class \u201cBase\u201d to the\n shell from our Ada core, we could use the following code:\n \n Shell> Base arg1 arg2\n Shell> Base.method %1 arg1 arg2\n \n to create an instance and call one of its methods. Of course, the\n shell is not the best language for object-oriented programming, and\n better languages should be used instead.\n \n When an instance has associated properties (which you can export from\n Ada using *Set_Property*), you access the properties by prefixing its\n-name with \"@\":\n+name with \u201c@\u201d:\n \n Shell> Base arg1 arg2 # Build new instance\n Shell> @id %1 # Access its \"id\" field\n Shell> @id %1 5 # Set its \"id\" field\n \n Some commands are automatically added to the shell when this scripting\n language is added to the application. These are\n \n *Function load (file)*\n Loads the content of *file* from the disk, and execute each of its\n lines as a Shell command. This can for instance be used to load\n scripts when your application is loaded\n \n-*Function echo (arg...)*\n+*Function echo (arg\u2026)*\n This function takes any number of argument, and prints them in the\n console associated with the language. By default, when in an\n interactive console, the output of commands is automatically\n printed to the console. But when you execute a script through\n *load* above, you need to explicitly call *echo* to make some\n output visible.\n \n@@ -165,15 +165,15 @@\n of this document.\n \n This class provides an interface to consoles. A console is an\n input/output area in your application (whether it is a text area in\n a graphical application, or simply standard text I/O in text mode).\n In particular, the python standard output streams *sys.stdin*,\n *sys.stdout* and *sys.stderr* are redirected to an instance of that\n- class. If you want to see python's error messages or usual output\n+ class. If you want to see python\u2019s error messages or usual output\n in your application, you must register that class, and define a\n default console for your scripting language through calls to\n *GNATCOLL.Scripts.Set_Default_Console*.\n \n You can later add new methods to this class, which would be\n specific to your application. Or you can derive this class into a\n new class to achieve a similar goal.\n@@ -224,24 +224,24 @@\n code remains exactly the same, and new scripting languages can be\n added in later releases of GNATColl without requiring a change in your\n application. This flexibility is central to the design of GNATColl.\n \n In exchange for that flexibility, however, there are language-specific\n features that cannot be performed through the GNATColl API. At\n present, this includes for instance exporting functions that return\n-hash tables. But GNATColl doesn't try to export the greatest set of\n+hash tables. But GNATColl doesn\u2019t try to export the greatest set of\n features common to all languages. On the contrary, it tries to fully\n support all the languages, and provide reasonable fallback for\n languages that do not support that feature. For instance, named\n parameters (which are a part of the python language) are fully\n-supported, although the shell language doesn't support them. But\n-that's an implementation detail transparent to your own application.\n+supported, although the shell language doesn\u2019t support them. But\n+that\u2019s an implementation detail transparent to your own application.\n \n Likewise, your application might decide to always load the python\n-scripting language. If GNATColl wasn't compiled with python support,\n+scripting language. If GNATColl wasn\u2019t compiled with python support,\n the corresponding Ada function still exists (and thus your code still\n compiles), although of course it does nothing. But since the rest of\n the code is independent of python, this is totally transparent for\n your application.\n \n [image: TIP:][image] GNATColl comes with some examples, which you can\n use as a reference when building your own application. See the\n@@ -255,15 +255,15 @@\n * You *can* create an **interactive console** for the various\n languages, so that users can perform experiments interactively. This\n is optional, and you could decide to keep the scripting language has\n a hidden implementation detail (or just for automatic testing\n purposes for instance)\n \n * You *can* **export** some classes and methods. This is optional, but\n- it doesn't really make sense to just embed a scripting language and\n+ it doesn\u2019t really make sense to just embed a scripting language and\n export nothing to it. In such a case, you might as well spawn a\n separate executable.\n \n * You *can* load **start up scripts** or plug-ins that users have\n written to extend your application.\n \n \n@@ -502,15 +502,15 @@\n (*Lookup_Scripting_Language* function), and to make it possible to\n register each exported function only once (it then takes care of\n exporting it to each scripting language).\n \n *Class Scripting_Language*\n Instances of this type represent a specific language. It provides\n various operations to export subprograms, execute commands, create\n- the other types described below,... There should exists a single\n+ the other types described below,\u2026 There should exists a single\n instance of this class per supported language.\n \n This class interacts with the script interpreter (for instance\n python), and all code executed in python goes through this type,\n which then executes your Ada callbacks to perform the actual\n operation.\n \n@@ -520,27 +520,27 @@\n \n *Class Callback_Data*\n This type is an opaque tagged type that provides a language-\n independent interface to the scripting language. It gives for\n instance access to the various parameters passed to your subprogram\n (*Nth_Arg* functions), allows you to set the return value\n (*Set_Return_Value* procedure), or raise exceptions\n- (*Set_Error_Msg* procedure),...\n+ (*Set_Error_Msg* procedure),\u2026\n \n *Record Class_Type*\n This type is not tagged, and cannot be extended. It basically\n represents a class in any of the scripting languages, and is used\n to create new instances of that class from Ada.\n \n *Class Class_Instance*\n A class instance represents a specific instance of a class. In\n general, such an instance is strongly bound to an instance of an\n Ada type. For instance, if you have a *Foo* type in your\n application that you wish to export, you would create a\n- *Class_Type* called \"Foo\", and then the user can create as many\n+ *Class_Type* called \u201cFoo\u201d, and then the user can create as many\n instances as he wants of that class, each of which is associated\n with different values of *Foo* in Ada.\n \n Another more specific example is the predefined *Console* class. As\n we have seen before, this is a *Virtual_Console* in Ada. You could\n for instance have two graphical windows in your application, each\n of which is a *Virtual_Console*. In the scripting language, this is\n@@ -673,20 +673,20 @@\n \n \n 3.2.3.2.2. Support for named parameters\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n \n Some languages (especially python) support named parameters, ie\n parameters can be specified in any order on the command line, as long\n-as they are properly identified (very similar to Ada's own\n+as they are properly identified (very similar to Ada\u2019s own\n capabilities). In the example above, the call to *Name_Parameters* is\n really optional, but adds this support for your own functions as well.\n You just have to specify the name of the parameters, and GNATColl will\n then ensure that when you call *Nth_Arg* the parameter number 1 is\n-really \"arg1\". For scripting languages that do not support named\n+really \u201carg1\u201d. For scripting languages that do not support named\n parameters, this has no effect.\n \n Your code can then perform as complex a code as needed, and finally\n return a value (or not) to the scripting language, through a call to\n *Set_Return_Value*.\n \n After the above code has been executed, your users can go to the\n@@ -725,27 +725,27 @@\n \n You can then register the class methods in the same way that you\n registered functions. An additional parameter *Class* exists for\n *Register_Command*. A method is really just a standard function that\n has an implicit first parameter which is a *Class_Instance*. This\n extra parameter should not be taken into account in *Min_Args* and\n *Max_Args*. You can also declare the method as a static method, ie one\n-that doesn't take this extra implicit parameter, and basically just\n+that doesn\u2019t take this extra implicit parameter, and basically just\n uses the class as a namespace.\n \n Some special method names are available. In particular,\n *Constructor_Method* should be used for the constructor of a class. It\n is a method that receives, as its first argument, a class instance\n that has just been created. It should associate that instance with the\n Ada object it represents.\n \n Here is a simple example that exports a class. Each instance of this\n class is associated with a string, passed in parameter to the\n constructor. The class has a single method *print*, which prints its\n-string parameter prefixed by the instance's string. To start with,\n+string parameter prefixed by the instance\u2019s string. To start with,\n here is a python example on what we want to achieve:\n \n c1 = MyClass (\"prefix1\")\n c1.print (\"foo\")\n => \"prefix1 foo\"\n c2 = MyClass () # Using a default prefix\n c2.print (\"foo\")\n@@ -772,39 +772,39 @@\n (Repo, Constructor_Method, 0, 1, Handler'Access, MyClass);\n Register_Command\n (Repo, \"print\", 1, 1, Handler'Access, MyClass);\n \n This example also demonstrates a few concepts: the constructor is\n declared as a method that takes one optional argument. The default\n value is in fact passed in the call to *Nth_Arg* and is set to\n-\"default\". In the handler, we know there is always a first argument\n+\u201cdefault\u201d. In the handler, we know there is always a first argument\n which is the instance on which the method applies. The implementation\n for the constructor stores the prefix in the instance itself, so that\n-several instances can have different prefixes (we can't use global\n-variables, of course, since we don't know in advance how many\n+several instances can have different prefixes (we can\u2019t use global\n+variables, of course, since we don\u2019t know in advance how many\n instances will exist). The implementation for *print* inserts code in\n the default console for the script (we could of course use *Put_Line*\n or any other way to output data), and computes the string to output by\n-concatenating the instance's prefix and the parameter to *print*.\n+concatenating the instance\u2019s prefix and the parameter to *print*.\n \n Note that *Set_Data* and *Get_Data* take the class in parameter, in\n addition to the class instance. This is needed for proper handling of\n multiple inheritance: say we have a class *C* that extends two classes\n *A* and *B*. The Ada code that deals with *A* associates an integer\n with the class instance, whereas the code that deals with *B*\n associates a string. Now, if you have an instance of *C* but call a\n-method inherited from *A*, and if *Get_Data* didn't specify the class,\n+method inherited from *A*, and if *Get_Data* didn\u2019t specify the class,\n there would be a risk that a string would be returned instead of the\n expected integer. In fact, the proper solution here is that both *A*\n and *B* store their preferred data at the same time in the instances,\n but only fetch the one they actually need. Therefore instances of *C*\n are associated with two datas.\n \n Here is a more advanced example that shows how to export an Ada\n-object. Let's assume we have the following Ada type that we want to\n+object. Let\u2019s assume we have the following Ada type that we want to\n make available to scripts:\n \n type MyType is record\n Field : Integer;\n end record;\n \n As you can see, this is not a tagged type, but could certainly be.\n@@ -830,18 +830,18 @@\n Data : MyProps := MyProps (Instance_Property'\n (Get_Data (Inst, Get_Name (MyClass))));\n begin\n return Data.Val;\n end Get_Data;\n \n Several aspects worth noting in this example. Each data is associated\n-with a name, not a class as in the previous example. That's in fact\n+with a name, not a class as in the previous example. That\u2019s in fact\n the same thing, and mostly for historical reasons. We have to create\n our own instance of *Instance_Property_Record* to store the data, but\n-the implementation presents no special difficulty. In fact, we don't\n+the implementation presents no special difficulty. In fact, we don\u2019t\n absolutely need to create *Set_Data* and *Get_Data* and could do\n everything inline in the method implementation, but it is cleaner this\n way and easier to reuse.\n \n GNATColl is fully responsible for managing the lifetime of the data\n associated with the class instances and you can override the procedure\n *Destroy* if you need special memory management.\n@@ -874,15 +874,15 @@\n \n * Static *get* methods\n \n With each of your classes, you can export a static method generally\n called *get* that takes in parameter a way to identify an existing\n instance, and either return it or create a new one. It is also\n recommended to disable the constructor, ie force it to raise an\n- error. Let's examine the python code as it would be used:\n+ error. Let\u2019s examine the python code as it would be used:\n \n ed = Editor (\"file.adb\") # constructor\n => Error, cannot construct instances\n ed = Editor.get (\"file.adb\")\n => Create a new instance\n ed2 = Editor.get (\"file.adb\")\n => Return existing instance\n@@ -935,15 +935,15 @@\n ed.do_something()\n \n It is important to realize that in the call above, we are not\n calling the constructor of a class, but a function. At the Ada\n level, the function has basically the same implementation as the one\n we gave for *get* above. But the python code looks nicer because we\n do not have these additional *.get()* calls. The name of the class\n- *MyClassImpl* doesn't appear anywhere in the python code, so this is\n+ *MyClassImpl* doesn\u2019t appear anywhere in the python code, so this is\n mostly transparent.\n \n However, if you have more than one scripting language, in particular\n for the shell, the code looks less nice in this case:\n \n MyClass \"file.adb\"\n => \n@@ -1008,11 +1008,11 @@\n a script (python for instance) will call your Ada callback, which\n might raise errors. Most of the time, the error should indeed be\n reported to the user, and you can thus raise a standard exception, or\n call *Set_Error_Msg*.\n \n But if you wish to know which script was executing the command, it is\n generally not doable. You can however activate a trace (Traces:\n-Logging information) called *\"PYTHON.TB\"* (for \"traceback\"), which\n+Logging information) called *\u201cPYTHON.TB\u201d* (for \u201ctraceback\u201d), which\n will output the name of the command that is being executed, as well as\n the full traceback within the python scripts. This will help you\n locate which script is raising an exception.\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/storage_pools.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/storage_pools.txt", "unified_diff": "@@ -12,16 +12,16 @@\n means you have to remember not to use the standard memory allocations\n like *malloc* or *new*, and instead call one of your subprograms. If\n you ever decide to change the allocation strategy, or want to\n experiment with several strategies, that means updating your code in\n several places.\n \n In Ada, when you declare the type of your data, you also specify\n-through a *'Storage_Pool* attribute how the memory for instances of\n-that type should be allocated. And that's it. You then use the usual\n+through a *\u2018Storage_Pool* attribute how the memory for instances of\n+that type should be allocated. And that\u2019s it. You then use the usual\n *new* keyword to allocate memory.\n \n GNATColl provides a number of examples for such storage pools, with\n various goals. There is also one advanced such pool in the GNAT run-\n time itself, called *GNAT.Debug_Pools*, which allows you to control\n memory leaks and whether all accesses do reference valid memory\n location (and not memory that has already been deallocated).\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/strings.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/strings.txt.gz", "unified_diff": null, "details": [{"source1": "strings.txt", "source2": "strings.txt", "unified_diff": "@@ -1,20 +1,20 @@\n 5. **Strings**: high-performance strings\n ****************************************\n \n The generic package \"GNATCOLL.Strings_Impl\" (and its default\n instantiation in \"GNATCOLL.Strings\") provides a high-performance\n strings implementation.\n \n-It comes in addition to Ada's own *String* and *Unbounded_String*\n+It comes in addition to Ada\u2019s own *String* and *Unbounded_String*\n types, although it attempts to find a middle ground in between\n (flexibility vs performance).\n \n GNATCOLL.Strings therefore provides strings (named *XString*, as in\n-extended-strings) that can grow as needed (up to *Natural'Last*, like\n+extended-strings) that can grow as needed (up to *Natural\u2019Last*, like\n standard strings), yet are faster than unbounded strings. They also\n come with an extended API, which includes all primitive operations\n from unbounded strings, in addition to some subprograms inspired from\n GNATCOLL.Utils and the python and C++ programming languages.\n \n \n 5.1. Small string optimization\n@@ -56,17 +56,17 @@\n big string that requires allocation. In a typical application, most\n strings are smaller than 23 bytes, so we are saving very significant\n time here.\n \n This representation has to work on both 32 bits systems and 64 bits\n systems, so we have careful representation clauses to take this into\n account. It also needs to work on both big-endian and little-endian\n-systems. Thanks to Ada's representation clauses, this one in fact\n+systems. Thanks to Ada\u2019s representation clauses, this one in fact\n relatively easy to achieve (well, okay, after trying a few different\n-approaches to emulate what's done in C++, and that did not work\n+approaches to emulate what\u2019s done in C++, and that did not work\n elegantly). In fact, emulating via bit-shift operations ended up with\n code that was less efficient than letting the compiler do it\n automatically because of our representation clauses.\n \n \n 5.2. Character types\n ====================\n@@ -125,47 +125,47 @@\n particular context is different. For instance, GNATCOLL.Traces builds\n messages to output in the log file. Such messages will typically be at\n most 100 characters, although they can of course be much larger\n sometimes.\n \n We have added one more formal parameter to GNATCOLL.Strings_Impl to\n control the maximum size of small strings. If for instance we decide\n-that a \"small\" string is anywhere from 1 to 100 characters long (i.e.\n+that a \u201csmall\u201d string is anywhere from 1 to 100 characters long (i.e.\n we do not want to allocate memory for those strings), it can be done\n via this parameter.\n \n Of course, in such cases the size of the string itself becomes much\n larger. In this example it would be 101 bytes long, rather than the 24\n bytes. Although we are saving on memory allocations, we are also\n spending more time copying data when the string is passed around, so\n-you'll need to measure the performance here.\n+you\u2019ll need to measure the performance here.\n \n The maximum size for the small string is 127 bytes however, because\n this size and the 1-bit flag need to fit in 1 bytes in the\n representation clauses we showed above. We tried to make this more\n configurable, but this makes things significantly more complex between\n-little-endian and big-endian systems, and having large \"small\" strings\n+little-endian and big-endian systems, and having large \u201csmall\u201d strings\n would not make much sense in terms of performance anyway.\n \n Typical C++ implementations do not make this small size configurable.\n \n \n 5.4. Task safety\n ================\n \n Just like unbounded strings, the strings in this package are not\n thread safe. This means that you cannot access the same string (read\n or write) from two different threads without somehow protecting the\n-access via a protected type, locks,...\n+access via a protected type, locks,\u2026\n \n In practice, sharing strings would rarely be done, so if the package\n itself was doing its own locking we would end up with very bad\n performance in all cases, for a few cases where it might prove useful.\n \n-As we'll discuss below, it is possible to use two different strings\n+As we\u2019ll discuss below, it is possible to use two different strings\n that actually share the same internal buffer, from two different\n threads. Since this is an implementation detail, this package takes\n care of guaranteeing the integrity of the shared data in such a case.\n \n \n 5.5. Copy on write\n ==================\n@@ -219,15 +219,15 @@\n start allocating memory past the size of small strings, so we will for\n instance first allocate 24 bytes. When more memory is needed, we\n multiply this size by 1.5, which some researchers have found to be a\n good comprise between waste of memory and number of allocations. For\n very large strings, we always allocate multiples of the memory page\n size (4096 bytes), since this is what the system will make available\n anyway. So we will basically allocate the following: 24, 36, 54, 82,\n-122,...\n+122,\u2026\n \n An additional constraint is that we only ever allocate even number of\n bytes. This is called the capacity of the string. In the layout of the\n big string, as shown above, we store half that capacity, which saves\n one bit that we use for the flag.\n \n \n@@ -237,28 +237,28 @@\n One other optimization performed by this package (which is not done\n for unbounded strings or various C++ implementations) is to optimize\n substrings when also using copy-on-write.\n \n We simply store the index of the first character of the string within\n the shared buffer, instead of always starting at the first.\n \n-From the user's point of view, this is an implementation detail.\n+From the user\u2019s point of view, this is an implementation detail.\n Strings are always indexed from 1, and internally we convert to an\n actual position in the buffer. This means that if we need to\n reallocate the buffer, for instance when the string is modified, we\n transparently change the index of the first character, but the indexes\n the user was using are still valid.\n \n This results in very significant savings, as shown below in the\n timings for Trim for instance. Also, we can do an operation like\n splitting a string very efficiently.\n \n-For instance, the following code doesn't allocate any memory, beside\n+For instance, the following code doesn\u2019t allocate any memory, beside\n setting the initial value of the string. It parses a file containing\n-some \"key=value\" lines, with optional spaces, and possibly empty\n+some \u201ckey=value\u201d lines, with optional spaces, and possibly empty\n lines:\n \n declare\n S, Key, Value : XString;\n L : XString_Array (1 .. 2);\n Last : Natural;\n begin\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/templates.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/templates.txt", "unified_diff": "@@ -1,51 +1,51 @@\n 10. **Templates**: generating text\n **********************************\n \n This module provides convenient subprograms for replacing specific\n substrings with other values. It is typically used to replace\n-substrings like \"%{version}\" in a longer string with the actual\n+substrings like \u201c%{version}\u201d in a longer string with the actual\n version, at run time.\n \n This module is not the same as the templates parser provided in the\n context of AWS, the Ada web server, where external files are parsed\n and processed to generate other files. The latter provides advanced\n-features like filters, loops,...\n+features like filters, loops,\u2026\n \n The substrings to be replaced always start with a specific delimiter,\n which is set to *%* by default, but can be overridden in your code.\n The name of the substring to be replaced is then the identifier\n following that delimiter, with the following rules:\n \n * If the character following the delimiter is the delimiter itself,\n then the final string will contain a single instance of that\n delimiter, and no further substitution is done for that delimiter.\n- An example of this is *\"%%\"*.\n+ An example of this is *\u201c%%\u201d*.\n \n * If the character immediately after the delimiter is a curly brace\n (*{*), then the name of the identifier is the text until the next\n closing curly brace. It can then contain any character expect a\n- closing curly brace. An example of this is *\"%{long name}\"*\n+ closing curly brace. An example of this is *\u201c%{long name}\u201d*\n \n * If the first character after the delimiter is a digit, then the name\n of the identifier is the number after the delimiter. An example of\n- this is *\"%12\"*. As a special case, if the first non-digit character\n+ this is *\u201c%12\u201d*. As a special case, if the first non-digit character\n is the symbol *-*, it is added as part of the name of the\n- identifier, as in *\"%1-\"*. One use for this feature is to indicate\n+ identifier, as in *\u201c%1-\u201c*. One use for this feature is to indicate\n you want to replace it with all the positional parameters %1%2%3%4.\n For instance, if you are writing the command line to spawn an\n external tool, to which the user can pass any number of parameter,\n- you could specify that command line as *\"tool -o %1 %2-\"* to\n+ you could specify that command line as *\u201ctool -o %1 %2-\u201c* to\n indicate that all parameters should be concatenated on the command\n line.\n \n * If the first character after the delimiter is a letter, the\n identifier follows the same rules as for Ada identifiers, and can\n contain any letter, digit, or underscore character. An example of\n- this is *\"%ab_12\"*. For readability, it is recommended to use the\n+ this is *\u201c%ab_12\u201d*. For readability, it is recommended to use the\n curly brace notation when the name is complex, but that is not\n mandatory.\n \n * Otherwise the name of the identifier is the single character\n following the delimiter\n \n For each substring matching the rules above, the *Substitute*\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/traces.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/traces.txt.gz", "unified_diff": null, "details": [{"source1": "traces.txt", "source2": "traces.txt", "unified_diff": "@@ -1,15 +1,15 @@\n 4. **Traces**: Logging information\n **********************************\n \n Most applications need to log various kinds of information: error\n messages, information messages or debug messages among others. These\n logs can be displayed and stored in a number of places: standard\n output, a file, the system logger, an application-specific database\n-table,...\n+table,\u2026\n \n The package \"GNATCOLL.Traces\" addresses the various needs, except for\n the application-specific database, which of course is specific to your\n business and needs various custom fields in any case, which cannot be\n easily provided through a general interface.\n \n This module is organized around two tagged types (used through access\n@@ -21,26 +21,26 @@\n will generally define several handles, which can be enabled or\n disabled separately, therefore limiting the amount of logging.\n \n *Trace_Stream*\n Streams are the ultimate types responsible for the output of the\n messages. One or more handles are associated with each stream. The\n latter can be a file, the standard output, a graphical window, a\n- socket,... New types of streams can easily be defined in your\n+ socket,\u2026 New types of streams can easily be defined in your\n application.\n \n \n 4.1. Configuring traces\n =======================\n \n As mentioned above, an application will generally create several\n *Trace_Handle* (typically one per module in the application). When new\n features are added to the application, the developers will generally\n need to add lots of traces to help investigate problems once the\n-application is installed at a customer's site. The problem here is\n+application is installed at a customer\u2019s site. The problem here is\n that each module might output a lot of information, thus confusing the\n logs; this also does not help debugging.\n \n The *GNATCOLL.Traces* package allows the user to configure which\n handles should actually generate logs, and which should just be silent\n and not generate anything. Depending on the part of the application\n that needs to be investigated, one can therefore enable a set of\n@@ -63,85 +63,85 @@\n *Parse_Config_File*.\n \n * If no file name was specified in that call, the environment variable\n *ADA_DEBUG_FILE* might point to a configuration file.\n \n * If the above two attempts did not find a suitable configuration\n file, the current directory is searched for a file called\n- *.gnatdebug*. Finally, the user's home directory will also be\n+ *.gnatdebug*. Finally, the user\u2019s home directory will also be\n searched for that file.\n \n In all cases, the format of the configuration file is the same. Its\n goal is to associate the name of a *trace_handle* with the name of a\n *trace_stream* on which it should be displayed.\n \n Streams are identified by a name. You can provide additional streams\n by creating a new tagged object (Defining custom stream types). Here\n are the various possibilities to reference a stream:\n \n-*\"name\"*\n- where name is a string made of letters, digits and slash ('/')\n+*\u201cname\u201d*\n+ where name is a string made of letters, digits and slash (\u2018/\u2019)\n characters. This is the name of a file to which the traces should\n be redirected. The previous contents of the file is discarded. If\n the name of the file is a relative path, it is relative to the\n location of the configuration file, not necessarily to the current\n directory when the file is parsed. In the file name, *$$* is\n automatically replaced by the process number. *$D* is automatically\n replaced by the current date. *$T* is automatically replaced by the\n current date and time. Other patterns of the form *$name*,\n *${name}*, or *$(name)* are substituted with the value of the named\n- environment variable, if it exists. If \">>\" is used instead of \">\"\n+ environment variable, if it exists. If \u201c>>\u201d is used instead of \u201c>\u201d\n to redirect to that stream, the file is appended to, instead of\n truncated.\n \n-*\"&1\"*\n+*\u201c&1\u201d*\n This syntax is similar to the one used on Unix shells, and\n indicates that the output should be displayed on the standard\n output for the application. If the application is graphical, and in\n particular on Windows platforms, it is possible that there is no\n standard output!\n \n-*\"&2\"*\n+*\u201c&2\u201d*\n Similar to the previous one, but the output is sent to standard\n error.\n \n-*\"&syslog\"*\n+*\u201c&syslog\u201d*\n Logging to syslog.\n \n Comments in a configuration file must be on a line of their own, and\n-start with *--*. Empty lines are ignored. The rest of the lines\n+start with *\u2013*. Empty lines are ignored. The rest of the lines\n represent configurations, as in:\n \n-* If a line contains the single character *\"+\"*, it activates all\n+* If a line contains the single character *\u201c+\u201d*, it activates all\n *trace_handle* by default. This means the rest of the configuration\n file should disable those handles that are not needed. The default\n is that all handles are disabled by default, and the configuration\n file should activate the ones it needs. The Ada source code can\n change the default status of each handles, as well\n \n-* If the line starts with the character *\">\"*, followed by a stream\n+* If the line starts with the character *\u201c>\u201d*, followed by a stream\n name (as defined above), this becomes the default stream. All\n handles will be displayed on that stream, unless otherwise\n specified. If the stream does not exist, it defaults to standard\n output.\n \n * Otherwise, the first token on the line is the name of a handle. If\n that is the only element on the line, the handle is activated, and\n will be displayed on the default stream.\n \n- Otherwise, the next element on the line should be a *\"=\"* sign,\n- followed by either *\"yes\"* or *\"no\"*, depending on whether the\n+ Otherwise, the next element on the line should be a *\u201c=\u201d* sign,\n+ followed by either *\u201cyes\u201d* or *\u201cno\u201d*, depending on whether the\n handle should resp. be enabled or disabled.\n \n- Finally, the rest of the line can optionally contain the *\">\"*\n+ Finally, the rest of the line can optionally contain the *\u201c>\u201d*\n character followed by the name of the stream to which the handle\n should be directed.\n \n There is are two special cases for the names on this line: they can\n- start with either *\"*.\"* or *\".*\"* to indicate the settings apply to\n+ start with either *\u201c*.\u201d* or *\u201c.*\u201d* to indicate the settings apply to\n a whole set of handles. See the example below.\n \n Here is a short example of a configuration file. It activates all\n handles by default, and defines four handles: two of them are directed\n to the default stream (standard error), the third one to a file on the\n disk, and the last one to the system logger syslog (if your system\n supports it, otherwise to the default stream, ie standard error):\n@@ -297,15 +297,15 @@\n ===================\n \n Speaking of color, a number of decorators are defined by\n *GNATCOLL.Traces*. Their goal is not to be used for outputting\n information, but to configure what extra information should be output\n with all log messages. They are activated through the same\n configuration file as the traces, with the same syntax (i.e either\n-*\"=yes\"* or *\"=no\"*).\n+*\u201c=yes\u201d* or *\u201c=no\u201d*).\n \n Here is an exhaustive list:\n \n *DEBUG.ABSOLUTE_TIME*\n If this decorator is activated in the configuration file, the\n absolute time when Trace is called is automatically added to the\n output, when the streams supports it (in particular, this has no\n@@ -324,24 +324,24 @@\n displayed. It can be converted to a symbolic stack trace through\n the use of the external application *addr2line*, but that would be\n too costly to do this automatically for each message.\n \n *DEBUG.LOCATION*\n If this decorator is activated, the location of the call to Trace\n is automatically displayed. This is a file:line:column information.\n- This works even when the executable wasn't compiled with debug\n+ This works even when the executable wasn\u2019t compiled with debug\n information\n \n *DEBUG.ENCLOSING_ENTITY*\n Activate this decorator to automatically display the name of the\n subprogram that contains the call to *Trace*.\n \n *DEBUG.COLORS*\n If this decorator is activated, the messages will use colors for\n- the various fields, if the stream supports it (syslog doesn't).\n+ the various fields, if the stream supports it (syslog doesn\u2019t).\n \n *DEBUG.COUNT*\n This decorator displays two additional numbers on each line: the\n first is the number of times this handle was used so far in the\n application, the second is the total number of traces emitted so\n far. These numbers can for instance be used to set conditional\n breakpoints on a specific trace (break on *gnat.traces.log* or\n@@ -371,15 +371,15 @@\n [MODULE] 6/247 User Message (2007-07-03 13:12:53.46)\n (elapsed: 2ms)(loc: gnatcoll-traces.adb:224)\n (entity:GNATCOLL.Traces.Log)\n (callstack: 40FD9902 082FCFDD 082FE8DF )\n \n Depending on your application, there are lots of other possible\n decorators that could be useful (for instance the current thread, or\n-the name of the executable when you have several of them,...). Since\n+the name of the executable when you have several of them,\u2026). Since\n *GNATCOLL.Traces* cannot provide all possible decorators, it provides\n support, through tagged types, so that you can create your own\n decorators.\n \n This needs you to override the *Trace_Handle_Record* tagged type.\n Since this type is created through calls to *GNATCOLL.Traces.Create*.\n This is done by providing an additional *Factory* parameter to\n@@ -430,23 +430,23 @@\n in your application (for instance using one for logging Info messages,\n one for Error messages, and so on). In this case, the function\n *Create* is all you need.\n \n *GNATCOLL.Traces* provides the type *Trace_Stream_Record*, which can\n be overridden to redirect the traces to your own streams.\n \n-Let's assume for now that you have defined a new type of stream\n-(called *\"mystream\"*). To keep the example simple, we will assume this\n+Let\u2019s assume for now that you have defined a new type of stream\n+(called *\u201cmystream\u201d*). To keep the example simple, we will assume this\n stream also redirects to a file. For flexibility, however, you want to\n let the user configure the file name from the traces configuration\n file. Here is an example of a configuration file that sets the default\n stream to a file called \"foo\", and redirects a specific handle to\n another file called \"bar\". Note how the same syntax that was used for\n standard output and standard error is also reused (ie the stream name\n-starts with the *\"&\"* symbol, to avoid confusion with standard file\n+starts with the *\u201c&\u201d* symbol, to avoid confusion with standard file\n names):\n \n >&mystream:foo\n MODULE=yes >&mystream:bar\n \n You need of course to do a bit of coding in Ada to create the stream.\n This is done by creating a new child of *Trace_Stream_Record*, and\n@@ -465,23 +465,23 @@\n L : Natural;\n begin\n Str.Get_String (S, L);\n Put (Stream.File.all, String (S (1 .. L)));\n end Put;\n \n The above code did not open the file itself, as you might have\n-noticed, nor did it register the name *\"mystream\"* so that it can be\n+noticed, nor did it register the name *\u201cmystream\u201d* so that it can be\n used in the configuration file. All this is done by creating a\n factory, ie a function in charge of creating the new stream.\n \n A factory is also a tagged object (so that you can store custom\n information in it), with a single primitive operation, *New_Stream*,\n in charge of creating and initializing a new stream. This operation\n receives in parameter the argument specified by the user in the\n-configuration file (after the *\":\"* character, if any), and must\n+configuration file (after the *\u201c:\u201d* character, if any), and must\n return a newly allocated stream. This function is also never called\n twice with the same argument, since *GNATCOLL.Traces* automatically\n reuses an existing stream when one with the same name and arguments\n already exists:\n \n type My_Stream_Factory is new Stream_Factory with null record;\n \n@@ -501,36 +501,36 @@\n \n 4.5. Logging to syslog\n ======================\n \n Among the predefined streams, GNATColl gives access to the system\n logger *syslog*. This is a standard utility on all Unix systems, but\n is not available on other systems. When you compile GNATColl, you\n-should specify the switch *--enable-syslog* to configure to activate\n-the support. If either this switch wasn't specified, or configure\n+should specify the switch *\u2013enable-syslog* to configure to activate\n+the support. If either this switch wasn\u2019t specified, or configure\n could not find the relevant header files anyway, then support for\n *syslog* will not be available. In this case, the package\n *GNATCOLL.Traces.Syslog* is still available, but contains a single\n function that does nothing. If your configuration files redirect some\n-trace handles to *\"syslog\"*, they will instead be redirect to the\n+trace handles to *\u201csyslog\u201d*, they will instead be redirect to the\n default stream or to standard output.\n \n Activating support for syslog requires the following call in your\n application:\n \n GNATCOLL.Traces.Syslog.Register_Syslog_Stream;\n \n This procedure is always available, whether your system supports or\n-not syslog, and will simply do nothing if it doesn't support syslog.\n+not syslog, and will simply do nothing if it doesn\u2019t support syslog.\n This means that you do not need to have conditional code in your\n application to handle that, and you can let GNATColl take care of\n this.\n \n After the above call, trace handles can be redirected to a stream\n-named *\"syslog\"*.\n+named *\u201csyslog\u201d*.\n \n The package *GNATCOLL.Traces.Syslog* also contains a low-level\n interface to syslog, which, although fully functional, you should\n probably not use, since that would make your code system-dependent.\n \n Syslog itself dispatches its output based on two criteria: the\n *facility*, which indicates what application emitted the message, and\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/tribooleans.txt", "source2": "./usr/share/doc/libgnatcoll-doc/text/tribooleans.txt", "unified_diff": "@@ -3,20 +3,20 @@\n \n Through the package *GNATCOLL.Tribooleans*, GNATColl provides a type\n that extends the classical *Boolean* type with an *Indeterminate*\n value.\n \n There are various cases where such a type is useful. One example we\n have is when a user is doing a search (on a database or any set of\n-data), and can specify some optional boolean criteria (\"must the\n-contact be french?\"). He can choose to only see french people\n-(\"True\"), to see no french people at all (\"False\"), or to get all\n-contacts (\"Indeterminate\"). With a classical boolean, there is no way\n+data), and can specify some optional boolean criteria (\u201cmust the\n+contact be french?\u201d). He can choose to only see french people\n+(\u201cTrue\u201d), to see no french people at all (\u201cFalse\u201d), or to get all\n+contacts (\u201cIndeterminate\u201d). With a classical boolean, there is no way\n to cover all these cases.\n \n Of course, there are more advanced use cases for such a type. To\n support these cases, the *Tribooleans* package overrides the usual\n-logical operations *\"and\"*, *\"or\"*, *\"xor\"*, *\"not\"* and provides an\n+logical operations *\u201cand\u201d*, *\u201cor\u201d*, *\u201cxor\u201d*, *\u201cnot\u201d* and provides an\n *Equal* function.\n \n See the specs of the package to see the truth tables associated with\n those operators.\n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}, {"source1": "./usr/share/doc/libgnatcoll-doc/text/vfs.txt.gz", "source2": "./usr/share/doc/libgnatcoll-doc/text/vfs.txt.gz", "unified_diff": null, "details": [{"source1": "vfs.txt", "source2": "vfs.txt", "unified_diff": "@@ -34,39 +34,39 @@\n any other part of the file name.\n \n \n 14.1. Filesystems abstraction\n =============================\n \n There exists lots of different filesystems on all machines. These\n-include such things as FAT, VFAT, NTFS, ext2, VMS,.... However, all\n+include such things as FAT, VFAT, NTFS, ext2, VMS,\u2026. However, all\n these can be grouped into three families of filesystems:\n \n * windows-based filesystems\n \n On such filesystems, the full name of a file is split into three\n- parts: the name of the drive (c:, d:,...), the directories which are\n+ parts: the name of the drive (c:, d:,\u2026), the directories which are\n separated by a backslash, and the base name. Such filesystems are\n sometimes inaccurately said to be case insensitive: by that, one\n means that the same file can be accessed through various casing.\n However, a user is generally expecting a specific casing when a file\n name is displayed, and the application should strive to preserve\n that casing (as opposed to, for instance, systematically convert the\n file name to lower cases).\n \n A special case of a windows-based filesystems is that emulated by\n the cygwin development environment. In this case, the filesystem is\n seen as if it was unix-based (see below), with one special quirk to\n- indicate the drive letter (the file name starts with \"/cygwin/c/\").\n+ indicate the drive letter (the file name starts with \u201c/cygwin/c/\u201d).\n \n * unix-based filesystems\n \n On such filesystems, directories are separated by forward slashed.\n File names are case sensitive, that is a directory can contain both\n- \"foo\" and \"Foo\", which is not possible on windows-based filesystems.\n+ \u201cfoo\u201d and \u201cFoo\u201d, which is not possible on windows-based filesystems.\n \n * vms filesystem\n \n This filesystem represents path differently than the other two,\n using brackets to indicate parent directories\n \n A given machine can actually have several file systems in parallel,\n@@ -81,15 +81,15 @@\n set of tagged types in the *GNATCOLL.Filesystem* package and its\n children. Such a type has primitive operations to manipulate the names\n of files (retrieving the base name from a full name for instance), to\n check various attributes of the file (is this a directory, a symbolic\n link, is the file readable or writable), or to manipulate the file\n itself (copying, deleting, reading and writing). It provides similar\n operations for directories (creating or deleting paths, reading the\n-list of files in a directory,...).\n+list of files in a directory,\u2026).\n \n It also provides information on the system itself (the list of\n available drives on a windows machine for instance).\n \n The root type *Filesystem_Record* is abstract, and is specialized in\n various child types. A convenient factory is provided to return the\n filesystem appropriate for the local machine (*Get_Local_Filesystem*),\n@@ -131,26 +131,26 @@\n ========================\n \n Once the abstract for filesystems exists, it is tempting to use it to\n access files on remote machines. There are of course lots of\n differences with filesystems on the local machine: their names are\n manipulated similarly (although you need to somehow indicate on which\n host they are to be found), but any operation of the file itself needs\n-to be done on the remote host itself, as it can't be done through\n-calls to the system's standard C library.\n+to be done on the remote host itself, as it can\u2019t be done through\n+calls to the system\u2019s standard C library.\n \n Note that when we speak of disks on a remote machine, we indicate\n disks that are not accessible locally, for instance through NFS mounts\n or samba. In such cases, the files are accessed transparently as if\n they were local, and all this is taken care of by the system itself,\n no special layer is needed at the application level.\n \n GNATColl provides an extensive framework for manipulating such remote\n files. It knows what commands need to be run on the remote host to\n-perform the operations (\"cp\" or \"copy\", \"stat\" or \"dir /a-d\",...) and\n+perform the operations (\u201ccp\u201d or \u201ccopy\u201d, \u201cstat\u201d or \u201cdir /a-d\u201d,\u2026) and\n will happily perform these operations when you try to manipulate such\n files.\n \n There are however two operations that your own application needs to\n take care of to take full advantage of remote files.\n \n \n@@ -210,15 +210,15 @@\n \n GNATColl does not try to second guess your intention here. It performs\n all its remote operations through a tagged type defined in\n *GNATCOLL.Filesystem.Transport*. This type is abstract, and must be\n overridden in your application. For instance, GPS has a full support\n for choosing which protocol to use on which host, what kind of\n filesystem is running on that host, to recognize password queries from\n-the transport protocol,.... All these can be encapsulated in the\n+the transport protocol,\u2026. All these can be encapsulated in the\n transport protocol.\n \n Once you have created one or more children of\n *Filesystem_Transport_Record*, you associate them with your instance\n of the filesystem through a call to the *Setup* primitive operation of\n the filesystem. See the factory example above.\n \n", "details": [{"source1": "encoding", "source2": "encoding", "unified_diff": "@@ -1 +1 @@\n-us-ascii\n+utf-8\n"}]}]}]}]}]}, {"source1": "libgnatcoll19_21.0.0-4_arm64.deb", "source2": "libgnatcoll19_21.0.0-4_arm64.deb", "unified_diff": null, "details": [{"source1": "control.tar.xz", "source2": "control.tar.xz", "unified_diff": null, "details": [{"source1": "control.tar", "source2": "control.tar", "unified_diff": null, "details": [{"source1": "./md5sums", "source2": "./md5sums", "unified_diff": null, "details": [{"source1": "./md5sums", "source2": "./md5sums", "comments": ["Files differ"], "unified_diff": null}]}]}]}, {"source1": "data.tar.xz", "source2": "data.tar.xz", "unified_diff": null, "details": [{"source1": "data.tar", "source2": "data.tar", "unified_diff": null, "details": [{"source1": "./usr/lib/aarch64-linux-gnu/libgnatcoll.so.19", "source2": "./usr/lib/aarch64-linux-gnu/libgnatcoll.so.19", "comments": ["File has been modified after NT_GNU_BUILD_ID has been applied."], "unified_diff": null, "details": [{"source1": "readelf --wide --notes {}", "source2": "readelf --wide --notes {}", "unified_diff": "@@ -1,4 +1,4 @@\n \n Displaying notes found in: .note.gnu.build-id\n Owner Data size \tDescription\n- GNU 0x00000014\tNT_GNU_BUILD_ID (unique build ID bitstring)\t Build ID: 741ce70cae34ead8cba4b6704c2dfe9056571d39\n+ GNU 0x00000014\tNT_GNU_BUILD_ID (unique build ID bitstring)\t Build ID: 317aec252cb5a2c24a2d3a59b7970742b7060f18\n"}, {"source1": "readelf --wide --decompress --hex-dump=.gnu_debuglink {}", "source2": "readelf --wide --decompress --hex-dump=.gnu_debuglink {}", "comments": ["error from `readelf --wide --decompress --hex-dump=.gnu_debuglink {}`:", "readelf: Error: no .dynamic section in the dynamic segment"], "unified_diff": "@@ -1,7 +1,7 @@\n \n Hex dump of section '.gnu_debuglink':\n- 0x00000000 31636537 30636165 33346561 64386362 1ce70cae34ead8cb\n- 0x00000010 61346236 37303463 32646665 39303536 a4b6704c2dfe9056\n- 0x00000020 35373164 33392e64 65627567 00000000 571d39.debug....\n- 0x00000030 725ffe8c r_..\n+ 0x00000000 37616563 32353263 62356132 63323461 7aec252cb5a2c24a\n+ 0x00000010 32643361 35396237 39373037 34326237 2d3a59b7970742b7\n+ 0x00000020 30363066 31382e64 65627567 00000000 060f18.debug....\n+ 0x00000030 101f5972 ..Yr\n \n"}]}]}]}]}, {"source1": "libgnatcoll19-dbgsym_21.0.0-4_arm64.deb", "source2": "libgnatcoll19-dbgsym_21.0.0-4_arm64.deb", "unified_diff": null, "details": [{"source1": "file list", "source2": "file list", "unified_diff": "@@ -1,3 +1,3 @@\n -rw-r--r-- 0 0 0 4 2020-12-22 09:58:09.000000 debian-binary\n -rw-r--r-- 0 0 0 536 2020-12-22 09:58:09.000000 control.tar.xz\n--rw-r--r-- 0 0 0 3182336 2020-12-22 09:58:09.000000 data.tar.xz\n+-rw-r--r-- 0 0 0 3182360 2020-12-22 09:58:09.000000 data.tar.xz\n"}, {"source1": "control.tar.xz", "source2": "control.tar.xz", "unified_diff": null, "details": [{"source1": "control.tar", "source2": "control.tar", "unified_diff": null, "details": [{"source1": "./control", "source2": "./control", "unified_diff": "@@ -6,8 +6,8 @@\n Maintainer: Nicolas Boulenguez \n Installed-Size: 4208\n Depends: libgnatcoll19 (= 21.0.0-4)\n Section: debug\n Priority: optional\n Multi-Arch: same\n Description: debug symbols for libgnatcoll19\n-Build-Ids: 741ce70cae34ead8cba4b6704c2dfe9056571d39\n+Build-Ids: 317aec252cb5a2c24a2d3a59b7970742b7060f18\n"}, {"source1": "./md5sums", "source2": "./md5sums", "unified_diff": null, "details": [{"source1": "./md5sums", "source2": "./md5sums", "comments": ["Files differ"], "unified_diff": null}, {"source1": "line order", "source2": "line order", "unified_diff": "@@ -1 +1 @@\n-usr/lib/debug/.build-id/74/1ce70cae34ead8cba4b6704c2dfe9056571d39.debug\n+usr/lib/debug/.build-id/31/7aec252cb5a2c24a2d3a59b7970742b7060f18.debug\n"}]}]}]}, {"source1": "data.tar.xz", "source2": "data.tar.xz", "unified_diff": null, "details": [{"source1": "data.tar", "source2": "data.tar", "unified_diff": null, "details": [{"source1": "file list", "source2": "file list", "unified_diff": "@@ -1,10 +1,10 @@\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/lib/\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/lib/debug/\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/lib/debug/.build-id/\n-drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/lib/debug/.build-id/74/\n--rw-r--r-- 0 root (0) root (0) 4297784 2020-12-22 09:58:09.000000 ./usr/lib/debug/.build-id/74/1ce70cae34ead8cba4b6704c2dfe9056571d39.debug\n+drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/lib/debug/.build-id/31/\n+-rw-r--r-- 0 root (0) root (0) 4298144 2020-12-22 09:58:09.000000 ./usr/lib/debug/.build-id/31/7aec252cb5a2c24a2d3a59b7970742b7060f18.debug\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/share/\n drwxr-xr-x 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/share/doc/\n lrwxrwxrwx 0 root (0) root (0) 0 2020-12-22 09:58:09.000000 ./usr/share/doc/libgnatcoll19-dbgsym -> libgnatcoll19\n"}, {"source1": "./usr/lib/debug/.build-id/74/1ce70cae34ead8cba4b6704c2dfe9056571d39.debug", "source2": "./usr/lib/debug/.build-id/31/7aec252cb5a2c24a2d3a59b7970742b7060f18.debug", "comments": ["File has been modified after NT_GNU_BUILD_ID has been applied.", "Files 2% similar despite different names"], "unified_diff": null, "details": [{"source1": "readelf --wide --file-header {}", "source2": "readelf --wide --file-header {}", "unified_diff": "@@ -6,15 +6,15 @@\n OS/ABI: UNIX - System V\n ABI Version: 0\n Type: DYN (Shared object file)\n Machine: AArch64\n Version: 0x1\n Entry point address: 0x19b720\n Start of program headers: 64 (bytes into file)\n- Start of section headers: 4295544 (bytes into file)\n+ Start of section headers: 4295904 (bytes into file)\n Flags: 0x0\n Size of this header: 64 (bytes)\n Size of program headers: 56 (bytes)\n Number of program headers: 7\n Size of section headers: 64 (bytes)\n Number of section headers: 35\n Section header string table index: 34\n"}, {"source1": "readelf --wide --sections {}", "source2": "readelf --wide --sections {}", "unified_diff": "@@ -1,8 +1,8 @@\n-There are 35 section headers, starting at offset 0x418b78:\n+There are 35 section headers, starting at offset 0x418ce0:\n \n Section Headers:\n [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n [ 0] NULL 0000000000000000 000000 000000 00 0 0 0\n [ 1] .note.gnu.build-id NOTE 00000000000001c8 0001c8 000024 00 A 0 0 4\n [ 2] .gnu.hash NOBITS 00000000000001f0 0001ec 019dc0 00 A 3 0 8\n [ 3] .dynsym NOBITS 0000000000019fb0 0001ec 056928 18 A 4 3 8\n@@ -24,21 +24,21 @@\n [19] .data.rel.ro NOBITS 000000000057f138 00f120 01a430 00 WA 0 0 8\n [20] .dynamic NOBITS 0000000000599568 00f120 0002a0 10 WA 4 0 8\n [21] .got NOBITS 0000000000599808 00f120 00c7f8 08 WA 0 0 8\n [22] .data NOBITS 00000000005a6000 00f120 0020a0 00 WA 0 0 8\n [23] .bss NOBITS 00000000005a80a0 00f120 002ee0 00 WA 0 0 16\n [24] .comment PROGBITS 0000000000000000 0001ec 000027 01 MS 0 0 1\n [25] .debug_aranges PROGBITS 0000000000000000 000218 000355 00 C 0 0 8\n- [26] .debug_info PROGBITS 0000000000000000 000570 167d61 00 C 0 0 8\n- [27] .debug_abbrev PROGBITS 0000000000000000 1682d8 0057b0 00 C 0 0 8\n- [28] .debug_line PROGBITS 0000000000000000 16da88 07787b 00 C 0 0 8\n- [29] .debug_str PROGBITS 0000000000000000 1e5308 023f65 01 MSC 0 0 8\n- [30] .debug_loc PROGBITS 0000000000000000 209270 0b94ef 00 C 0 0 8\n- [31] .debug_ranges PROGBITS 0000000000000000 2c2760 01cdaa 00 C 0 0 8\n- [32] .symtab SYMTAB 0000000000000000 2df510 064b60 18 33 2416 8\n- [33] .strtab STRTAB 0000000000000000 344070 0d49a5 00 0 0 1\n- [34] .shstrtab STRTAB 0000000000000000 418a15 00015c 00 0 0 1\n+ [26] .debug_info PROGBITS 0000000000000000 000570 167d7a 00 C 0 0 8\n+ [27] .debug_abbrev PROGBITS 0000000000000000 1682f0 0057b0 00 C 0 0 8\n+ [28] .debug_line PROGBITS 0000000000000000 16daa0 07787b 00 C 0 0 8\n+ [29] .debug_str PROGBITS 0000000000000000 1e5320 0240b2 01 MSC 0 0 8\n+ [30] .debug_loc PROGBITS 0000000000000000 2093d8 0b94ef 00 C 0 0 8\n+ [31] .debug_ranges PROGBITS 0000000000000000 2c28c8 01cdaa 00 C 0 0 8\n+ [32] .symtab SYMTAB 0000000000000000 2df678 064b60 18 33 2416 8\n+ [33] .strtab STRTAB 0000000000000000 3441d8 0d49a5 00 0 0 1\n+ [34] .shstrtab STRTAB 0000000000000000 418b7d 00015c 00 0 0 1\n Key to Flags:\n W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n L (link order), O (extra OS processing required), G (group), T (TLS),\n C (compressed), x (unknown), o (OS specific), E (exclude),\n D (mbind), p (processor specific)\n"}, {"source1": "readelf --wide --notes {}", "source2": "readelf --wide --notes {}", "unified_diff": "@@ -1,4 +1,4 @@\n \n Displaying notes found in: .note.gnu.build-id\n Owner Data size \tDescription\n- GNU 0x00000014\tNT_GNU_BUILD_ID (unique build ID bitstring)\t Build ID: 741ce70cae34ead8cba4b6704c2dfe9056571d39\n+ GNU 0x00000014\tNT_GNU_BUILD_ID (unique build ID bitstring)\t Build ID: 317aec252cb5a2c24a2d3a59b7970742b7060f18\n"}, {"source1": "readelf --wide --debug-dump=info {}", "source2": "readelf --wide --debug-dump=info {}", "unified_diff": "@@ -98,15 +98,15 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x32a\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 112 (DW_TAG_base_type)\n DW_AT_byte_size : (data1) 1\n DW_AT_encoding : (data1) 8\t(unsigned char)\n- DW_AT_name : (strp) (offset: 0x38f7f): character\n+ DW_AT_name : (strp) (offset: 0x38ec6): character\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xd8:\n Length: 0x1a (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -273,28 +273,28 @@\n Pointer Size: 8\n <0><228>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <229> DW_AT_stmt_list : (sec_offset) 0x476\n <22d> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><231>: Abbrev Number: 112 (DW_TAG_base_type)\n <232> DW_AT_byte_size : (data1) 8\n <233> DW_AT_encoding : (data1) 7\t(unsigned)\n- <234> DW_AT_name : (strp) (offset: 0x5ad0): system__address\n+ <234> DW_AT_name : (strp) (offset: 0x5a17): system__address\n <1><238>: Abbrev Number: 0\n Compilation Unit @ offset 0x239:\n Length: 0x18 (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><244>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <245> DW_AT_stmt_list : (sec_offset) 0x476\n <249> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><24d>: Abbrev Number: 6 (DW_TAG_base_type)\n <24e> DW_AT_byte_size : (data1) 8\n <24f> DW_AT_encoding : (data1) 5\t(signed)\n- <250> DW_AT_name : (strp) (offset: 0x5d06): system__storage_elements__Tstorage_offsetB\n+ <250> DW_AT_name : (strp) (offset: 0x5c4d): system__storage_elements__Tstorage_offsetB\n <254> DW_AT_artificial : (flag_present) 1\n <1><254>: Abbrev Number: 0\n Compilation Unit @ offset 0x255:\n Length: 0x15 (32-bit)\n Version: 4\n Abbrev Offset: 0\n Pointer Size: 8\n@@ -338,15 +338,15 @@\n Pointer Size: 8\n <0><2ab>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <2ac> DW_AT_stmt_list : (sec_offset) 0x476\n <2b0> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><2b4>: Abbrev Number: 6 (DW_TAG_base_type)\n <2b5> DW_AT_byte_size : (data1) 8\n <2b6> DW_AT_encoding : (data1) 5\t(signed)\n- <2b7> DW_AT_name : (strp) (offset: 0x3c34c): long_long_integer\n+ <2b7> DW_AT_name : (strp) (offset: 0x3c266): long_long_integer\n <2bb> DW_AT_artificial : (flag_present) 1\n <1><2bb>: Abbrev Number: 0\n Compilation Unit @ offset 0x2bc:\n Length: 0x2f (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n@@ -354,15 +354,15 @@\n <2c8> DW_AT_stmt_list : (sec_offset) 0x476\n <2cc> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><2d0>: Abbrev Number: 112 (DW_TAG_base_type)\n <2d1> DW_AT_byte_size : (data1) 8\n <2d2> DW_AT_encoding : (data1) 7\t(unsigned)\n <2d3> DW_AT_name : (strp) (offset: 0x25d8): system__storage_elements__integer_address\n <1><2d7>: Abbrev Number: 126 (DW_TAG_subprogram)\n- <2d8> DW_AT_name : (strp) (offset: 0x4b97): system__storage_elements__to_integer\n+ <2d8> DW_AT_name : (strp) (offset: 0x4ade): system__storage_elements__to_integer\n <2dc> DW_AT_decl_file : (data1) 24\n <2dd> DW_AT_decl_line : (data1) 68\n <2de> DW_AT_decl_column : (data1) 4\n <2df> DW_AT_type : (ref_udata) <0x2d0>, system__storage_elements__integer_address\n <2e0> DW_AT_inline : (data1) 3\t(declared as inline and inlined)\n <2><2e1>: Abbrev Number: 14 (DW_TAG_formal_parameter)\n <2e2> DW_AT_name : (strp) (offset: 0xf25e9): value\n@@ -379,24 +379,24 @@\n Pointer Size: 8\n <0><2fa>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <2fb> DW_AT_stmt_list : (sec_offset) 0x476\n <2ff> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><303>: Abbrev Number: 70 (DW_TAG_subprogram)\n <304> DW_AT_external : (flag_present) 1\n <304> DW_AT_declaration : (flag_present) 1\n- <304> DW_AT_linkage_name: (strp) (offset: 0x59e1): ada__tags__check_tsd\n- <308> DW_AT_name : (strp) (offset: 0x59e1): ada__tags__check_tsd\n+ <304> DW_AT_linkage_name: (strp) (offset: 0x5928): ada__tags__check_tsd\n+ <308> DW_AT_name : (strp) (offset: 0x5928): ada__tags__check_tsd\n <30c> DW_AT_decl_file : (data1) 14\n <30d> DW_AT_decl_line : (data2) 465\n <30f> DW_AT_decl_column : (data1) 14\n <1><310>: Abbrev Number: 70 (DW_TAG_subprogram)\n <311> DW_AT_external : (flag_present) 1\n <311> DW_AT_declaration : (flag_present) 1\n- <311> DW_AT_linkage_name: (strp) (offset: 0x6fb5): ada__tags__register_tag\n- <315> DW_AT_name : (strp) (offset: 0x6fb5): ada__tags__register_tag\n+ <311> DW_AT_linkage_name: (strp) (offset: 0x6efc): ada__tags__register_tag\n+ <315> DW_AT_name : (strp) (offset: 0x6efc): ada__tags__register_tag\n <319> DW_AT_decl_file : (data1) 14\n <31a> DW_AT_decl_line : (data2) 552\n <31c> DW_AT_decl_column : (data1) 14\n <1><31d>: Abbrev Number: 0\n Compilation Unit @ offset 0x31e:\n Length: 0x1a (32-bit)\n Version: 4\n@@ -404,29 +404,29 @@\n Pointer Size: 8\n <0><329>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <32a> DW_AT_stmt_list : (sec_offset) 0x476\n <32e> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><332>: Abbrev Number: 53 (DW_TAG_subprogram)\n <333> DW_AT_external : (flag_present) 1\n <333> DW_AT_declaration : (flag_present) 1\n- <333> DW_AT_linkage_name: (strp) (offset: 0x5542): __gnat_rcheck_PE_Access_Before_Elaboration\n- <337> DW_AT_name : (strp) (offset: 0x5542): __gnat_rcheck_PE_Access_Before_Elaboration\n+ <333> DW_AT_linkage_name: (strp) (offset: 0x5489): __gnat_rcheck_PE_Access_Before_Elaboration\n+ <337> DW_AT_name : (strp) (offset: 0x5489): __gnat_rcheck_PE_Access_Before_Elaboration\n <1><33b>: Abbrev Number: 0\n Compilation Unit @ offset 0x33c:\n Length: 0x1d (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><347>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <348> DW_AT_stmt_list : (sec_offset) 0x476\n <34c> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><350>: Abbrev Number: 55 (DW_TAG_subprogram)\n <351> DW_AT_external : (flag_present) 1\n <351> DW_AT_declaration : (flag_present) 1\n- <351> DW_AT_linkage_name: (strp) (offset: 0x556d): __gnat_raise_exception\n+ <351> DW_AT_linkage_name: (strp) (offset: 0x54b4): __gnat_raise_exception\n <355> DW_AT_name : (strp) (offset: 0x3da7): ada__exceptions__raise_exception_always\n <359> DW_AT_decl_file : (data1) 26\n <35a> DW_AT_decl_line : (data1) 182\n <35b> DW_AT_decl_column : (data1) 14\n <1><35c>: Abbrev Number: 0\n Compilation Unit @ offset 0x35d:\n Length: 0x18 (32-bit)\n@@ -473,30 +473,30 @@\n Pointer Size: 8\n <0><3ba>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <3bb> DW_AT_stmt_list : (sec_offset) 0x476\n <3bf> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><3c3>: Abbrev Number: 53 (DW_TAG_subprogram)\n <3c4> DW_AT_external : (flag_present) 1\n <3c4> DW_AT_declaration : (flag_present) 1\n- <3c4> DW_AT_linkage_name: (strp) (offset: 0x5f35): __gnat_rcheck_CE_Overflow_Check\n- <3c8> DW_AT_name : (strp) (offset: 0x5f35): __gnat_rcheck_CE_Overflow_Check\n+ <3c4> DW_AT_linkage_name: (strp) (offset: 0x5e7c): __gnat_rcheck_CE_Overflow_Check\n+ <3c8> DW_AT_name : (strp) (offset: 0x5e7c): __gnat_rcheck_CE_Overflow_Check\n <1><3cc>: Abbrev Number: 0\n Compilation Unit @ offset 0x3cd:\n Length: 0x1a (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><3d8>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <3d9> DW_AT_stmt_list : (sec_offset) 0x476\n <3dd> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><3e1>: Abbrev Number: 53 (DW_TAG_subprogram)\n <3e2> DW_AT_external : (flag_present) 1\n <3e2> DW_AT_declaration : (flag_present) 1\n- <3e2> DW_AT_linkage_name: (strp) (offset: 0x55b2): __gnat_rcheck_CE_Range_Check\n- <3e6> DW_AT_name : (strp) (offset: 0x55b2): __gnat_rcheck_CE_Range_Check\n+ <3e2> DW_AT_linkage_name: (strp) (offset: 0x54f9): __gnat_rcheck_CE_Range_Check\n+ <3e6> DW_AT_name : (strp) (offset: 0x54f9): __gnat_rcheck_CE_Range_Check\n <1><3ea>: Abbrev Number: 0\n Compilation Unit @ offset 0x3eb:\n Length: 0x1a (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><3f6>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -515,16 +515,16 @@\n Pointer Size: 8\n <0><414>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <415> DW_AT_stmt_list : (sec_offset) 0x476\n <419> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><41d>: Abbrev Number: 53 (DW_TAG_subprogram)\n <41e> DW_AT_external : (flag_present) 1\n <41e> DW_AT_declaration : (flag_present) 1\n- <41e> DW_AT_linkage_name: (strp) (offset: 0x5d69): __gnat_malloc\n- <422> DW_AT_name : (strp) (offset: 0x5d69): __gnat_malloc\n+ <41e> DW_AT_linkage_name: (strp) (offset: 0x5cb0): __gnat_malloc\n+ <422> DW_AT_name : (strp) (offset: 0x5cb0): __gnat_malloc\n <1><426>: Abbrev Number: 0\n Compilation Unit @ offset 0x427:\n Length: 0x1a (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><432>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -547,32 +547,32 @@\n <1><459>: Abbrev Number: 112 (DW_TAG_base_type)\n <45a> DW_AT_byte_size : (data1) 1\n <45b> DW_AT_encoding : (data1) 7\t(unsigned)\n <45c> DW_AT_name : (strp) (offset: 0x7742): ada__streams__stream_element\n <1><460>: Abbrev Number: 6 (DW_TAG_base_type)\n <461> DW_AT_byte_size : (data1) 8\n <462> DW_AT_encoding : (data1) 5\t(signed)\n- <463> DW_AT_name : (strp) (offset: 0x551c): ada__streams__Tstream_element_offsetB\n+ <463> DW_AT_name : (strp) (offset: 0x5463): ada__streams__Tstream_element_offsetB\n <467> DW_AT_artificial : (flag_present) 1\n <1><467>: Abbrev Number: 0\n Compilation Unit @ offset 0x468:\n Length: 0x41 (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><473>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <474> DW_AT_stmt_list : (sec_offset) 0x476\n <478> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><47c>: Abbrev Number: 26 (DW_TAG_subrange_type)\n <47d> DW_AT_lower_bound : (sdata) -9223372036854775808\n <487> DW_AT_upper_bound : (sdata) 9223372036854775807\n- <491> DW_AT_name : (strp) (offset: 0x5941): ada__streams__stream_element_offset\n+ <491> DW_AT_name : (strp) (offset: 0x5888): ada__streams__stream_element_offset\n <495> DW_AT_type : (ref_addr) <0x460>, ada__streams__Tstream_element_offsetB\n <1><499>: Abbrev Number: 92 (DW_TAG_array_type)\n- <49a> DW_AT_name : (strp) (offset: 0x606d): ada__streams__stream_element_array___XUA\n+ <49a> DW_AT_name : (strp) (offset: 0x5fb4): ada__streams__stream_element_array___XUA\n <49e> DW_AT_type : (ref_addr) <0x459>, ada__streams__stream_element\n <4a2> DW_AT_sibling : (ref_udata) <0x4a9>\n <2><4a3>: Abbrev Number: 4 (DW_TAG_subrange_type)\n <4a4> DW_AT_type : (ref_addr) <0x460>, ada__streams__Tstream_element_offsetB\n <2><4a8>: Abbrev Number: 0\n <1><4a9>: Abbrev Number: 5 (DW_TAG_pointer_type)\n <4aa> DW_AT_byte_size : (data1) 8\n@@ -583,29 +583,29 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><4b8>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <4b9> DW_AT_stmt_list : (sec_offset) 0x476\n <4bd> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><4c1>: Abbrev Number: 76 (DW_TAG_structure_type)\n- <4c2> DW_AT_name : (strp) (offset: 0x61a1): ada__streams__stream_element_array___XUP\n+ <4c2> DW_AT_name : (strp) (offset: 0x60e8): ada__streams__stream_element_array___XUP\n <4c6> DW_AT_byte_size : (data1) 16\n <4c7> DW_AT_decl_file : (data1) 19\n <4c8> DW_AT_decl_line : (data1) 54\n <4c9> DW_AT_decl_column : (data1) 9\n <4ca> DW_AT_sibling : (ref_udata) <0x507>\n <2><4cb>: Abbrev Number: 31 (DW_TAG_member)\n <4cc> DW_AT_name : (strp) (offset: 0x1b26): P_ARRAY\n <4d0> DW_AT_decl_file : (data1) 19\n <4d1> DW_AT_decl_line : (data1) 42\n <4d2> DW_AT_decl_column : (data1) 9\n <4d3> DW_AT_type : (ref_addr) <0x4a9>, ada__streams__stream_element_array___XUA, ada__streams__stream_element\n <4d7> DW_AT_data_member_location: (data1) 0\n <2><4d8>: Abbrev Number: 2 (DW_TAG_structure_type)\n- <4d9> DW_AT_name : (strp) (offset: 0x6096): ada__streams__stream_element_array___XUB\n+ <4d9> DW_AT_name : (strp) (offset: 0x5fdd): ada__streams__stream_element_array___XUB\n <4dd> DW_AT_byte_size : (data1) 16\n <4de> DW_AT_decl_file : (data1) 12\n <4df> DW_AT_decl_line : (data1) 0\n <4e0> DW_AT_artificial : (flag_present) 1\n <4e0> DW_AT_sibling : (ref_udata) <0x4fc>\n <3><4e1>: Abbrev Number: 1 (DW_TAG_member)\n <4e2> DW_AT_name : (string) LB0\n@@ -641,15 +641,15 @@\n Pointer Size: 8\n <0><516>: Abbrev Number: 2 (DW_TAG_partial_unit)\n <517> DW_AT_stmt_list : (sec_offset) 0x476\n <51b> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><51f>: Abbrev Number: 6 (DW_TAG_subprogram)\n <520> DW_AT_external : (flag_present) 1\n <520> DW_AT_declaration : (flag_present) 1\n- <520> DW_AT_linkage_name: (strp) (offset: 0x6b36): _Unwind_Resume\n+ <520> DW_AT_linkage_name: (strp) (offset: 0x6a7d): _Unwind_Resume\n <524> DW_AT_name : (strp) (offset: 0x373e): __builtin_unwind_resume\n <528> DW_AT_decl_file : (data1) 12\n <529> DW_AT_decl_line : (data1) 0\n <1><52a>: Abbrev Number: 0\n Compilation Unit @ offset 0x52b:\n Length: 0x29 (32-bit)\n Version: 4\n@@ -726,16 +726,16 @@\n Pointer Size: 8\n <0><5bc>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <5bd> DW_AT_stmt_list : (sec_offset) 0x476\n <5c1> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><5c5>: Abbrev Number: 55 (DW_TAG_subprogram)\n <5c6> DW_AT_external : (flag_present) 1\n <5c6> DW_AT_declaration : (flag_present) 1\n- <5c6> DW_AT_linkage_name: (strp) (offset: 0x65b1): system__secondary_stack__ss_mark\n- <5ca> DW_AT_name : (strp) (offset: 0x65b1): system__secondary_stack__ss_mark\n+ <5c6> DW_AT_linkage_name: (strp) (offset: 0x64f8): system__secondary_stack__ss_mark\n+ <5ca> DW_AT_name : (strp) (offset: 0x64f8): system__secondary_stack__ss_mark\n <5ce> DW_AT_decl_file : (data1) 25\n <5cf> DW_AT_decl_line : (data1) 92\n <5d0> DW_AT_decl_column : (data1) 13\n <1><5d1>: Abbrev Number: 0\n Compilation Unit @ offset 0x5d2:\n Length: 0x1d (32-bit)\n Version: 4\n@@ -765,16 +765,16 @@\n <608> DW_AT_external : (flag_present) 1\n <608> DW_AT_declaration : (flag_present) 1\n <608> DW_AT_linkage_name: (strp) (offset: 0x7476): __gnat_begin_handler_v1\n <60c> DW_AT_name : (strp) (offset: 0x7476): __gnat_begin_handler_v1\n <1><610>: Abbrev Number: 53 (DW_TAG_subprogram)\n <611> DW_AT_external : (flag_present) 1\n <611> DW_AT_declaration : (flag_present) 1\n- <611> DW_AT_linkage_name: (strp) (offset: 0x6f2f): __gnat_end_handler_v1\n- <615> DW_AT_name : (strp) (offset: 0x6f2f): __gnat_end_handler_v1\n+ <611> DW_AT_linkage_name: (strp) (offset: 0x6e76): __gnat_end_handler_v1\n+ <615> DW_AT_name : (strp) (offset: 0x6e76): __gnat_end_handler_v1\n <1><619>: Abbrev Number: 0\n Compilation Unit @ offset 0x61a:\n Length: 0x26 (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><625>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -787,30 +787,30 @@\n <633> DW_AT_name : (strp) (offset: 0x367e): ada__exceptions__triggered_by_abort\n <637> DW_AT_decl_file : (data1) 26\n <638> DW_AT_decl_line : (data1) 239\n <639> DW_AT_decl_column : (data1) 13\n <1><63a>: Abbrev Number: 53 (DW_TAG_subprogram)\n <63b> DW_AT_external : (flag_present) 1\n <63b> DW_AT_declaration : (flag_present) 1\n- <63b> DW_AT_linkage_name: (strp) (offset: 0x5253): __gnat_rcheck_PE_Finalize_Raised_Exception\n- <63f> DW_AT_name : (strp) (offset: 0x5253): __gnat_rcheck_PE_Finalize_Raised_Exception\n+ <63b> DW_AT_linkage_name: (strp) (offset: 0x519a): __gnat_rcheck_PE_Finalize_Raised_Exception\n+ <63f> DW_AT_name : (strp) (offset: 0x519a): __gnat_rcheck_PE_Finalize_Raised_Exception\n <1><643>: Abbrev Number: 0\n Compilation Unit @ offset 0x644:\n Length: 0x1d (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><64f>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <650> DW_AT_stmt_list : (sec_offset) 0x476\n <654> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><658>: Abbrev Number: 55 (DW_TAG_subprogram)\n <659> DW_AT_external : (flag_present) 1\n <659> DW_AT_declaration : (flag_present) 1\n- <659> DW_AT_linkage_name: (strp) (offset: 0x5f95): system__secondary_stack__ss_allocate\n- <65d> DW_AT_name : (strp) (offset: 0x5f95): system__secondary_stack__ss_allocate\n+ <659> DW_AT_linkage_name: (strp) (offset: 0x5edc): system__secondary_stack__ss_allocate\n+ <65d> DW_AT_name : (strp) (offset: 0x5edc): system__secondary_stack__ss_allocate\n <661> DW_AT_decl_file : (data1) 25\n <662> DW_AT_decl_line : (data1) 72\n <663> DW_AT_decl_column : (data1) 14\n <1><664>: Abbrev Number: 0\n Compilation Unit @ offset 0x665:\n Length: 0x1a (32-bit)\n Version: 4\n@@ -895,15 +895,15 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><737>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <738> DW_AT_stmt_list : (sec_offset) 0x476\n <73c> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><740>: Abbrev Number: 52 (DW_TAG_structure_type)\n- <741> DW_AT_name : (strp) (offset: 0x5d77): system__atomic_counters__atomic_counter\n+ <741> DW_AT_name : (strp) (offset: 0x5cbe): system__atomic_counters__atomic_counter\n <745> DW_AT_byte_size : (data1) 4\n <746> DW_AT_decl_file : (data1) 18\n <747> DW_AT_decl_line : (data1) 102\n <748> DW_AT_decl_column : (data1) 9\n <2><749>: Abbrev Number: 31 (DW_TAG_member)\n <74a> DW_AT_name : (strp) (offset: 0xf25e9): value\n <74e> DW_AT_decl_file : (data1) 18\n@@ -919,15 +919,15 @@\n Abbrev Offset: 0\n Pointer Size: 8\n <0><763>: Abbrev Number: 2 (DW_TAG_partial_unit)\n <764> DW_AT_stmt_list : (sec_offset) 0x476\n <768> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><76c>: Abbrev Number: 7 (DW_TAG_subprogram)\n <76d> DW_AT_external : (flag_present) 1\n- <76d> DW_AT_name : (strp) (offset: 0x4f86): system__standard_library__abort_undefer_direct\n+ <76d> DW_AT_name : (strp) (offset: 0x4ecd): system__standard_library__abort_undefer_direct\n <771> DW_AT_decl_file : (data1) 5\n <772> DW_AT_decl_line : (data1) 72\n <773> DW_AT_decl_column : (data1) 4\n <774> DW_AT_inline : (data1) 3\t(declared as inline and inlined)\n <1><775>: Abbrev Number: 0\n Compilation Unit @ offset 0x776:\n Length: 0x3d (32-bit)\n@@ -941,15 +941,15 @@\n <78b> DW_AT_name : (strp) (offset: 0x289a): ada__containers__helpers__tamper_counts\n <78f> DW_AT_byte_size : (data1) 8\n <790> DW_AT_decl_file : (data1) 11\n <791> DW_AT_decl_line : (data1) 43\n <792> DW_AT_decl_column : (data1) 9\n <793> DW_AT_sibling : (ref_udata) <0x7af>\n <2><794>: Abbrev Number: 31 (DW_TAG_member)\n- <795> DW_AT_name : (strp) (offset: 0x3f9eb): busy\n+ <795> DW_AT_name : (strp) (offset: 0x3f959): busy\n <799> DW_AT_decl_file : (data1) 11\n <79a> DW_AT_decl_line : (data1) 44\n <79b> DW_AT_decl_column : (data1) 7\n <79c> DW_AT_type : (ref_addr) <0x38d>, system__atomic_counters__atomic_unsigned\n <7a0> DW_AT_data_member_location: (data1) 0\n <2><7a1>: Abbrev Number: 31 (DW_TAG_member)\n <7a2> DW_AT_name : (strp) (offset: 0x3aa92): lock\n@@ -958,30 +958,30 @@\n <7a8> DW_AT_decl_column : (data1) 7\n <7a9> DW_AT_type : (ref_addr) <0x38d>, system__atomic_counters__atomic_unsigned\n <7ad> DW_AT_data_member_location: (data1) 4\n <2><7ae>: Abbrev Number: 0\n <1><7af>: Abbrev Number: 6 (DW_TAG_base_type)\n <7b0> DW_AT_byte_size : (data1) 4\n <7b1> DW_AT_encoding : (data1) 5\t(signed)\n- <7b2> DW_AT_name : (strp) (offset: 0x4964): ada__containers__Tcount_typeB\n+ <7b2> DW_AT_name : (strp) (offset: 0x48ab): ada__containers__Tcount_typeB\n <7b6> DW_AT_artificial : (flag_present) 1\n <1><7b6>: Abbrev Number: 0\n Compilation Unit @ offset 0x7b7:\n Length: 0x1e (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><7c2>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <7c3> DW_AT_stmt_list : (sec_offset) 0x476\n <7c7> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><7cb>: Abbrev Number: 70 (DW_TAG_subprogram)\n <7cc> DW_AT_external : (flag_present) 1\n <7cc> DW_AT_declaration : (flag_present) 1\n- <7cc> DW_AT_linkage_name: (strp) (offset: 0x5700): system__storage_pools__subpools__allocate_any_controlled\n- <7d0> DW_AT_name : (strp) (offset: 0x5700): system__storage_pools__subpools__allocate_any_controlled\n+ <7cc> DW_AT_linkage_name: (strp) (offset: 0x5647): system__storage_pools__subpools__allocate_any_controlled\n+ <7d0> DW_AT_name : (strp) (offset: 0x5647): system__storage_pools__subpools__allocate_any_controlled\n <7d4> DW_AT_decl_file : (data1) 32\n <7d5> DW_AT_decl_line : (data2) 263\n <7d7> DW_AT_decl_column : (data1) 14\n <1><7d8>: Abbrev Number: 0\n Compilation Unit @ offset 0x7d9:\n Length: 0x1e (32-bit)\n Version: 4\n@@ -989,16 +989,16 @@\n Pointer Size: 8\n <0><7e4>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <7e5> DW_AT_stmt_list : (sec_offset) 0x476\n <7e9> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><7ed>: Abbrev Number: 70 (DW_TAG_subprogram)\n <7ee> DW_AT_external : (flag_present) 1\n <7ee> DW_AT_declaration : (flag_present) 1\n- <7ee> DW_AT_linkage_name: (strp) (offset: 0x4a4e): system__storage_pools__subpools__deallocate_any_controlled\n- <7f2> DW_AT_name : (strp) (offset: 0x4a4e): system__storage_pools__subpools__deallocate_any_controlled\n+ <7ee> DW_AT_linkage_name: (strp) (offset: 0x4995): system__storage_pools__subpools__deallocate_any_controlled\n+ <7f2> DW_AT_name : (strp) (offset: 0x4995): system__storage_pools__subpools__deallocate_any_controlled\n <7f6> DW_AT_decl_file : (data1) 32\n <7f7> DW_AT_decl_line : (data2) 305\n <7f9> DW_AT_decl_column : (data1) 14\n <1><7fa>: Abbrev Number: 0\n Compilation Unit @ offset 0x7fb:\n Length: 0x18 (32-bit)\n Version: 4\n@@ -1006,15 +1006,15 @@\n Pointer Size: 8\n <0><806>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <807> DW_AT_stmt_list : (sec_offset) 0x476\n <80b> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><80f>: Abbrev Number: 112 (DW_TAG_base_type)\n <810> DW_AT_byte_size : (data1) 4\n <811> DW_AT_encoding : (data1) 7\t(unsigned)\n- <812> DW_AT_name : (strp) (offset: 0x5ddd): system__unsigned_types__unsigned\n+ <812> DW_AT_name : (strp) (offset: 0x5d24): system__unsigned_types__unsigned\n <1><816>: Abbrev Number: 0\n Compilation Unit @ offset 0x817:\n Length: 0x1b (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><822>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -1047,15 +1047,15 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><85e>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <85f> DW_AT_stmt_list : (sec_offset) 0x476\n <863> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><867>: Abbrev Number: 101 (DW_TAG_subprogram)\n- <868> DW_AT_name : (strp) (offset: 0x5a2e): system__atomic_counters__increment__2\n+ <868> DW_AT_name : (strp) (offset: 0x5975): system__atomic_counters__increment__2\n <86c> DW_AT_decl_file : (data1) 3\n <86d> DW_AT_decl_line : (data1) 78\n <86e> DW_AT_decl_column : (data1) 4\n <86f> DW_AT_inline : (data1) 3\t(declared as inline and inlined)\n <2><870>: Abbrev Number: 14 (DW_TAG_formal_parameter)\n <871> DW_AT_name : (strp) (offset: 0x5bbfc): item\n <875> DW_AT_decl_file : (data1) 18\n@@ -1091,29 +1091,29 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><8b4>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <8b5> DW_AT_stmt_list : (sec_offset) 0x476\n <8b9> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><8bd>: Abbrev Number: 76 (DW_TAG_structure_type)\n- <8be> DW_AT_name : (strp) (offset: 0x452b): system__finalization_masters__fm_node\n+ <8be> DW_AT_name : (strp) (offset: 0x4472): system__finalization_masters__fm_node\n <8c2> DW_AT_byte_size : (data1) 16\n <8c3> DW_AT_decl_file : (data1) 21\n <8c4> DW_AT_decl_line : (data1) 151\n <8c5> DW_AT_decl_column : (data1) 9\n <8c6> DW_AT_sibling : (ref_udata) <0x8dc>\n <2><8c7>: Abbrev Number: 13 (DW_TAG_member)\n- <8c8> DW_AT_name : (strp) (offset: 0xc286): prev\n+ <8c8> DW_AT_name : (strp) (offset: 0xc1cd): prev\n <8cc> DW_AT_decl_file : (data1) 21\n <8cd> DW_AT_decl_line : (data1) 152\n <8ce> DW_AT_decl_column : (data1) 7\n <8cf> DW_AT_type : (ref_udata) <0x8dc>, system__finalization_masters__fm_node_ptr, system__finalization_masters__fm_node\n <8d0> DW_AT_data_member_location: (data1) 0\n <2><8d1>: Abbrev Number: 13 (DW_TAG_member)\n- <8d2> DW_AT_name : (strp) (offset: 0x6a138): next\n+ <8d2> DW_AT_name : (strp) (offset: 0x6a1f1): next\n <8d6> DW_AT_decl_file : (data1) 21\n <8d7> DW_AT_decl_line : (data1) 153\n <8d8> DW_AT_decl_column : (data1) 7\n <8d9> DW_AT_type : (ref_udata) <0x8dc>, system__finalization_masters__fm_node_ptr, system__finalization_masters__fm_node\n <8da> DW_AT_data_member_location: (data1) 8\n <2><8db>: Abbrev Number: 0\n <1><8dc>: Abbrev Number: 80 (DW_TAG_typedef)\n@@ -1122,24 +1122,24 @@\n <8e2> DW_AT_decl_line : (data1) 52\n <8e3> DW_AT_decl_column : (data1) 9\n <8e4> DW_AT_type : (ref_udata) <0x8e5>, system__finalization_masters__fm_node\n <1><8e5>: Abbrev Number: 5 (DW_TAG_pointer_type)\n <8e6> DW_AT_byte_size : (data1) 8\n <8e7> DW_AT_type : (ref_udata) <0x8bd>, system__finalization_masters__fm_node\n <1><8e8>: Abbrev Number: 73 (DW_TAG_typedef)\n- <8e9> DW_AT_name : (strp) (offset: 0x5893): system__finalization_masters__finalize_address_ptr\n+ <8e9> DW_AT_name : (strp) (offset: 0x57da): system__finalization_masters__finalize_address_ptr\n <8ed> DW_AT_decl_file : (data1) 21\n <8ee> DW_AT_decl_line : (data1) 47\n <8ef> DW_AT_decl_column : (data1) 9\n <8f0> DW_AT_type : (ref_addr) <0x82b>\n <1><8f4>: Abbrev Number: 55 (DW_TAG_subprogram)\n <8f5> DW_AT_external : (flag_present) 1\n <8f5> DW_AT_declaration : (flag_present) 1\n- <8f5> DW_AT_linkage_name: (strp) (offset: 0x4afe): system__finalization_masters__base_pool\n- <8f9> DW_AT_name : (strp) (offset: 0x4afe): system__finalization_masters__base_pool\n+ <8f5> DW_AT_linkage_name: (strp) (offset: 0x4a45): system__finalization_masters__base_pool\n+ <8f9> DW_AT_name : (strp) (offset: 0x4a45): system__finalization_masters__base_pool\n <8fd> DW_AT_decl_file : (data1) 21\n <8fe> DW_AT_decl_line : (data1) 193\n <8ff> DW_AT_decl_column : (data1) 13\n <1><900>: Abbrev Number: 55 (DW_TAG_subprogram)\n <901> DW_AT_external : (flag_present) 1\n <901> DW_AT_declaration : (flag_present) 1\n <901> DW_AT_linkage_name: (strp) (offset: 0x763c): system__storage_pools__allocate_any\n@@ -1231,21 +1231,21 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0><9b7>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <9b8> DW_AT_stmt_list : (sec_offset) 0x476\n <9bc> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><9c0>: Abbrev Number: 80 (DW_TAG_typedef)\n- <9c1> DW_AT_name : (strp) (offset: 0x6cae): system__stream_attributes__s_as\n+ <9c1> DW_AT_name : (strp) (offset: 0x6bf5): system__stream_attributes__s_as\n <9c5> DW_AT_decl_file : (data1) 4\n <9c6> DW_AT_decl_line : (data1) 57\n <9c7> DW_AT_decl_column : (data1) 12\n <9c8> DW_AT_type : (ref_udata) <0x9c9>, system__stream_attributes__s_as, ada__streams__stream_element\n <1><9c9>: Abbrev Number: 115 (DW_TAG_array_type)\n- <9ca> DW_AT_name : (strp) (offset: 0x6cae): system__stream_attributes__s_as\n+ <9ca> DW_AT_name : (strp) (offset: 0x6bf5): system__stream_attributes__s_as\n <9ce> DW_AT_GNAT_descriptive_type: (ref_addr) <0x4c1>\n <9d2> DW_AT_type : (ref_addr) <0x459>, ada__streams__stream_element\n <2><9d6>: Abbrev Number: 51 (DW_TAG_subrange_type)\n <9d7> DW_AT_type : (ref_addr) <0x460>, ada__streams__Tstream_element_offsetB\n <9db> DW_AT_upper_bound : (sdata) 8\n <2><9dc>: Abbrev Number: 0\n <1><9dd>: Abbrev Number: 0\n@@ -1256,16 +1256,16 @@\n Pointer Size: 8\n <0><9e9>: Abbrev Number: 10 (DW_TAG_partial_unit)\n <9ea> DW_AT_stmt_list : (sec_offset) 0x476\n <9ee> DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1><9f2>: Abbrev Number: 70 (DW_TAG_subprogram)\n <9f3> DW_AT_external : (flag_present) 1\n <9f3> DW_AT_declaration : (flag_present) 1\n- <9f3> DW_AT_linkage_name: (strp) (offset: 0x5082): ada__strings__unbounded__finalize__2\n- <9f7> DW_AT_name : (strp) (offset: 0x5082): ada__strings__unbounded__finalize__2\n+ <9f3> DW_AT_linkage_name: (strp) (offset: 0x4fc9): ada__strings__unbounded__finalize__2\n+ <9f7> DW_AT_name : (strp) (offset: 0x4fc9): ada__strings__unbounded__finalize__2\n <9fb> DW_AT_decl_file : (data1) 17\n <9fc> DW_AT_decl_line : (data2) 749\n <9fe> DW_AT_decl_column : (data1) 25\n <1><9ff>: Abbrev Number: 0\n Compilation Unit @ offset 0xa00:\n Length: 0x1e (32-bit)\n Version: 4\n@@ -1273,16 +1273,16 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 70 (DW_TAG_subprogram)\n DW_AT_external : (flag_present) 1\n DW_AT_declaration : (flag_present) 1\n- DW_AT_linkage_name: (strp) (offset: 0x617e): ada__strings__unbounded__reference\n- DW_AT_name : (strp) (offset: 0x617e): ada__strings__unbounded__reference\n+ DW_AT_linkage_name: (strp) (offset: 0x60c5): ada__strings__unbounded__reference\n+ DW_AT_name : (strp) (offset: 0x60c5): ada__strings__unbounded__reference\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data2) 710\n DW_AT_decl_column : (data1) 14\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xa22:\n Length: 0x1d (32-bit)\n Version: 4\n@@ -1290,16 +1290,16 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 55 (DW_TAG_subprogram)\n DW_AT_external : (flag_present) 1\n DW_AT_declaration : (flag_present) 1\n- DW_AT_linkage_name: (strp) (offset: 0x5108): ada__strings__unbounded__to_string\n- DW_AT_name : (strp) (offset: 0x5108): ada__strings__unbounded__to_string\n+ DW_AT_linkage_name: (strp) (offset: 0x504f): ada__strings__unbounded__to_string\n+ DW_AT_name : (strp) (offset: 0x504f): ada__strings__unbounded__to_string\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data1) 116\n DW_AT_decl_column : (data1) 13\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xa43:\n Length: 0x5d (32-bit)\n Version: 4\n@@ -1332,15 +1332,15 @@\n DW_AT_name : (string) LB0\n DW_AT_decl_file : (data1) 12\n DW_AT_decl_line : (data1) 0\n DW_AT_type : (ref_udata) <0xa7e>, positive___XDLU_1__2147483647, integer\n DW_AT_data_member_location: (data1) 0\n <3>: Abbrev Number: 69 (DW_TAG_subrange_type)\n DW_AT_upper_bound : (sdata) 2147483647\n- DW_AT_name : (strp) (offset: 0x5c7f): positive___XDLU_1__2147483647\n+ DW_AT_name : (strp) (offset: 0x5bc6): positive___XDLU_1__2147483647\n DW_AT_type : (ref_addr) <0xb4>, integer\n DW_AT_artificial : (flag_present) 1\n <3>: Abbrev Number: 86 (DW_TAG_member)\n DW_AT_name : (string) UB0\n DW_AT_decl_file : (data1) 12\n DW_AT_decl_line : (data1) 0\n DW_AT_type : (ref_udata) <0xa7e>, positive___XDLU_1__2147483647, integer\n@@ -1362,15 +1362,15 @@\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 73 (DW_TAG_typedef)\n- DW_AT_name : (strp) (offset: 0x5e08): system__strings__string_access\n+ DW_AT_name : (strp) (offset: 0x5d4f): system__strings__string_access\n DW_AT_decl_file : (data1) 13\n DW_AT_decl_line : (data1) 45\n DW_AT_decl_column : (data1) 9\n DW_AT_type : (ref_addr) <0xa57>, string___XUP\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xac5:\n Length: 0x9e (32-bit)\n@@ -1386,21 +1386,21 @@\n DW_AT_decl_line : (data2) 268\n DW_AT_decl_column : (data1) 9\n DW_AT_type : (ref1) <0xae3>, ada__tags__dispatch_table, ada__tags__dispatch_table, ada__tags__prim_ptr\n <1>: Abbrev Number: 36 (DW_TAG_pointer_type)\n DW_AT_byte_size : (data1) 8\n DW_AT_type : (ref1) <0xae6>, ada__tags__dispatch_table, ada__tags__dispatch_table, ada__tags__prim_ptr\n <1>: Abbrev Number: 46 (DW_TAG_typedef)\n- DW_AT_name : (strp) (offset: 0x66ba): ada__tags__dispatch_table\n+ DW_AT_name : (strp) (offset: 0x6601): ada__tags__dispatch_table\n DW_AT_decl_file : (data1) 14\n DW_AT_decl_line : (data2) 263\n DW_AT_decl_column : (data1) 12\n DW_AT_type : (ref1) <0xaf0>, ada__tags__dispatch_table, ada__tags__prim_ptr\n <1>: Abbrev Number: 23 (DW_TAG_array_type)\n- DW_AT_name : (strp) (offset: 0x66ba): ada__tags__dispatch_table\n+ DW_AT_name : (strp) (offset: 0x6601): ada__tags__dispatch_table\n DW_AT_GNAT_descriptive_type: (ref1) <0xb02>\n DW_AT_type : (ref_addr) <0x28f>, ada__tags__prim_ptr\n DW_AT_sibling : (ref1) <0xb02>\n <2>: Abbrev Number: 51 (DW_TAG_subrange_type)\n DW_AT_type : (ref_addr) <0xb4>, integer\n DW_AT_upper_bound : (sdata) 1\n <2>: Abbrev Number: 0\n@@ -1474,21 +1474,21 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 3 (DW_TAG_imported_unit)\n DW_AT_import : (ref_addr) <0xad0>\t[Abbrev Number: 10 (DW_TAG_partial_unit)]\n <1>: Abbrev Number: 52 (DW_TAG_structure_type)\n- DW_AT_name : (strp) (offset: 0x50ea): ada__finalization__controlled\n+ DW_AT_name : (strp) (offset: 0x5031): ada__finalization__controlled\n DW_AT_byte_size : (data1) 8\n DW_AT_decl_file : (data1) 16\n DW_AT_decl_line : (data1) 59\n DW_AT_decl_column : (data1) 9\n <2>: Abbrev Number: 39 (DW_TAG_member)\n- DW_AT_name : (strp) (offset: 0x6cfcb): _parent\n+ DW_AT_name : (strp) (offset: 0x6d084): _parent\n DW_AT_decl_file : (data1) 14\n DW_AT_decl_line : (data2) 268\n DW_AT_decl_column : (data1) 9\n DW_AT_type : (ref_addr) <0xb52>, system__finalization_root__root_controlled\n DW_AT_data_member_location: (data1) 0\n <2>: Abbrev Number: 0\n <1>: Abbrev Number: 0\n@@ -1539,37 +1539,37 @@\n <1>: Abbrev Number: 3 (DW_TAG_imported_unit)\n DW_AT_import : (ref_addr) <0x6eb2>\t[Abbrev Number: 127 (DW_TAG_partial_unit)]\n <1>: Abbrev Number: 3 (DW_TAG_imported_unit)\n DW_AT_import : (ref_addr) <0x6ec9>\t[Abbrev Number: 127 (DW_TAG_partial_unit)]\n <1>: Abbrev Number: 3 (DW_TAG_imported_unit)\n DW_AT_import : (ref_addr) <0x7199>\t[Abbrev Number: 127 (DW_TAG_partial_unit)]\n <1>: Abbrev Number: 30 (DW_TAG_structure_type)\n- DW_AT_name : (strp) (offset: 0x527e): ada__streams__root_stream_type\n+ DW_AT_name : (strp) (offset: 0x51c5): ada__streams__root_stream_type\n DW_AT_byte_size : (data1) 8\n DW_AT_decl_file : (data1) 19\n DW_AT_decl_line : (data1) 70\n DW_AT_decl_column : (data1) 9\n DW_AT_sibling : (ref1) <0xc2e>\n <2>: Abbrev Number: 31 (DW_TAG_member)\n DW_AT_name : (strp) (offset: 0x345e): _tag\n DW_AT_decl_file : (data1) 19\n DW_AT_decl_line : (data1) 70\n DW_AT_decl_column : (data1) 53\n DW_AT_type : (ref_addr) <0xad9>, ada__tags__tag, ada__tags__dispatch_table, ada__tags__dispatch_table, ada__tags__prim_ptr\n DW_AT_data_member_location: (data1) 0\n <2>: Abbrev Number: 0\n <1>: Abbrev Number: 30 (DW_TAG_structure_type)\n- DW_AT_name : (strp) (offset: 0x5381): ada__finalization__limited_controlled\n+ DW_AT_name : (strp) (offset: 0x52c8): ada__finalization__limited_controlled\n DW_AT_byte_size : (data1) 8\n DW_AT_decl_file : (data1) 16\n DW_AT_decl_line : (data1) 65\n DW_AT_decl_column : (data1) 9\n DW_AT_sibling : (ref1) <0xc46>\n <2>: Abbrev Number: 31 (DW_TAG_member)\n- DW_AT_name : (strp) (offset: 0x6cfcb): _parent\n+ DW_AT_name : (strp) (offset: 0x6d084): _parent\n DW_AT_decl_file : (data1) 16\n DW_AT_decl_line : (data1) 65\n DW_AT_decl_column : (data1) 9\n DW_AT_type : (ref_addr) <0xb52>, system__finalization_root__root_controlled\n DW_AT_data_member_location: (data1) 0\n <2>: Abbrev Number: 0\n <1>: Abbrev Number: 60 (DW_TAG_typedef)\n@@ -1586,30 +1586,30 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 53 (DW_TAG_subprogram)\n DW_AT_external : (flag_present) 1\n DW_AT_declaration : (flag_present) 1\n- DW_AT_linkage_name: (strp) (offset: 0x6b54): __gnat_set_exception_parameter\n- DW_AT_name : (strp) (offset: 0x6b54): __gnat_set_exception_parameter\n+ DW_AT_linkage_name: (strp) (offset: 0x6a9b): __gnat_set_exception_parameter\n+ DW_AT_name : (strp) (offset: 0x6a9b): __gnat_set_exception_parameter\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xc72:\n Length: 0x1d (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 55 (DW_TAG_subprogram)\n DW_AT_external : (flag_present) 1\n DW_AT_declaration : (flag_present) 1\n- DW_AT_linkage_name: (strp) (offset: 0x5bca): ada__strings__unbounded__to_unbounded_string\n- DW_AT_name : (strp) (offset: 0x5bca): ada__strings__unbounded__to_unbounded_string\n+ DW_AT_linkage_name: (strp) (offset: 0x5b11): ada__strings__unbounded__to_unbounded_string\n+ DW_AT_name : (strp) (offset: 0x5b11): ada__strings__unbounded__to_unbounded_string\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data1) 103\n DW_AT_decl_column : (data1) 13\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xc93:\n Length: 0x1a (32-bit)\n Version: 4\n@@ -1617,16 +1617,16 @@\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n DW_AT_stmt_list : (sec_offset) 0x476\n DW_AT_comp_dir : (strp) (offset: 0x98): ./obj/gnatcoll/relocatable\n <1>: Abbrev Number: 53 (DW_TAG_subprogram)\n DW_AT_external : (flag_present) 1\n DW_AT_declaration : (flag_present) 1\n- DW_AT_linkage_name: (strp) (offset: 0x546a): ada__strings__unbounded___assign__2\n- DW_AT_name : (strp) (offset: 0x546a): ada__strings__unbounded___assign__2\n+ DW_AT_linkage_name: (strp) (offset: 0x53b1): ada__strings__unbounded___assign__2\n+ DW_AT_name : (strp) (offset: 0x53b1): ada__strings__unbounded___assign__2\n <1>: Abbrev Number: 0\n Compilation Unit @ offset 0xcb1:\n Length: 0x1d (32-bit)\n Version: 4\n Abbrev Offset: 0x5c\n Pointer Size: 8\n <0>: Abbrev Number: 10 (DW_TAG_partial_unit)\n@@ -1709,37 +1709,37 @@\n <2>: Abbrev Number: 37 (DW_TAG_subrange_type)\n DW_AT_lower_bound : (sdata) 0\n DW_AT_upper_bound : (sdata) 2147483647\n DW_AT_name : (strp) (offset: 0x15cc): natural___XDLU_0__2147483647\n DW_AT_type : (ref_addr) <0xb4>, integer\n DW_AT_artificial : (flag_present) 1\n <2>: Abbrev Number: 39 (DW_TAG_member)\n- DW_AT_name : (strp) (offset: 0x5d97): counter\n+ DW_AT_name : (strp) (offset: 0x5cde): counter\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data2) 699\n DW_AT_decl_column : (data1) 7\n DW_AT_type : (ref_addr) <0x740>, system__atomic_counters__atomic_counter\n DW_AT_data_member_location: (data1) 4\n <2>: Abbrev Number: 17 (DW_TAG_member)\n DW_AT_name : (strp) (offset: 0x7530): last\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data2) 702\n DW_AT_decl_column : (data1) 7\n DW_AT_type : (ref1) <0xd4b>, natural___XDLU_0__2147483647, integer\n DW_AT_data_member_location: (data1) 8\n <2>: Abbrev Number: 23 (DW_TAG_array_type)\n- DW_AT_name : (strp) (offset: 0x6758): ada__strings__unbounded__shared_string__T80s\n+ DW_AT_name : (strp) (offset: 0x669f): ada__strings__unbounded__shared_string__T80s\n DW_AT_GNAT_descriptive_type: (ref1) <0xd84>\n DW_AT_type : (ref_addr) <0xd0>, character\n DW_AT_sibling : (ref1) <0xd84>\n <3>: Abbrev Number: 4 (DW_TAG_subrange_type)\n DW_AT_type : (ref_addr) <0xb4>, integer\n <3>: Abbrev Number: 0\n <2>: Abbrev Number: 47 (DW_TAG_structure_type)\n- DW_AT_name : (strp) (offset: 0x52e9): ada__strings__unbounded__shared_string__T80s___XA\n+ DW_AT_name : (strp) (offset: 0x5230): ada__strings__unbounded__shared_string__T80s___XA\n DW_AT_byte_size : (data1) 4\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data2) 703\n DW_AT_decl_column : (data1) 27\n DW_AT_artificial : (flag_present) 1\n DW_AT_sibling : (ref1) <0xda4>\n <3>: Abbrev Number: 17 (DW_TAG_member)\n@@ -1774,15 +1774,15 @@\n DW_AT_name : (strp) (offset: 0x286e): max_length\n DW_AT_decl_file : (data1) 17\n DW_AT_decl_line : (data2) 703\n