Ada's Dirty Pointer Secrets: to Access, or to Address?



May 6th, 2021 by Diana Coman

~This seems to turn into a mini-series of sorts, see the previous example of passing dynamically allocated arrays from Ada to C~

In true ladylike fashion, Ada deals with the unmentionable -but useful, darn it- dirtiness of pointers by calling them something entirely else: if p is for pointers and a is for Ada, then at least be civilised enough to use a-words when working directly with memory! So the type for pointers in Ada is not denoted by * (does that stand for some expletive in C, I wonder?) but by the magic word "access" that is used to denote a pointer type and wards off segfaults as well as more general memory read/write mishaps. And like any other magic, if it didn't work for you, it's because you used it wrongly!

The core of the access type idea in Ada is to leverage the overall strongly typed approach to provide at least some amount of automated checks and safeguards even when using pointers. So there is never a "pointer" variable but only a "pointer to this exact type" variable, at most (aka "access" is a generic type that needs specific instantiation before any use). As a result and in the otherwise overall Ada-style, there is no implicit conversion between pointer types, even if or when they might happen to point to the same type of thing otherwise!

Each access type can also contain further constraints such as not accepting null values (basically enforcing an automated check for that very common null value bane of pointer use) or allowing access only to some (as opposed to any) memory spaces (storage pools and even subpools, in Ada terminology). The significant advantage of this is that one can at all times be quite specific and therefore know exactly what sort of thing they expect to find the pointer pointing to, so that it's at least harder to mess it all up. The disadvantage is at times quite the same: having to be very specific about details when not needing the details or having to be very specific about things that are not yet known or even possible to know upfront can create its own sort of mess (although it's indeed one way more subtle than a segfault, granted).

For those cases when the neat access types are just too much overhead or too much of a straightjacket or simply not needed, one can still ask in principle directly for the memory address of anything at all: simply add 'Address after the name of the thing and there you go, what you get as a result is what you expect (and if you expected something else than what you got, it's because you had the wrong expectations, obviously). Note however that from Ada's point of view, access and the result of 'Address are two different sort of things and as such don't easily mix1.

The 'Address attribute2 is very useful indeed to do basically memory overlays (mappings) that are just about the fastest and most convenient way of converting between two types no matter how complex, with the only real requirement that they are of exactly the same size. This is absolutely invaluable when needing to get the raw representation of complex types for whatever purpose (mine tend to include at the moment encrypting/decrypting and/or fast storage). All that is required is to simply declare one variable of each type, make sure that they do indeed have addresses (by declaring them as "aliased" since otherwise Ada might optimize them into registers) and then request that they use the very same memory address. For instance, to convert a whole array, no matter how big, from the C-compatible char_array type to the one underlying raw type used everywhere in the Ada code around Eulora's client, all it takes is one function wrapping the few lines of code to map the memory and return the contents read with the expected type:

-- NB: result has length exactly A'Length
function Char_Array_To_Octets(A: in Interfaces.C.char_array)
return Raw_Types.Octets is
ca: aliased Interfaces.C.char_array(1..A'Length) := A;
o : aliased Raw_Types.Octets(1..A'Length);
for o'Address use ca'Address;
begin
return o;
end Char_Array_To_Octets;

Of course, direct memory mapping via the 'Address attribute as above is as dangerous as it gets and as such entirely not in keeping with Ada's style. Except, of course, that Ada fully allows it in the first place and provides the means to do it too but probably averts her eyes whenever you do it, then moves on and pretends it never happened. So it still works but it's also all clean, neat and tidy, unlike that ugly, dirty C. And if anyone asks about it, it's all *your* fault, too, you made her do it!


  1. There's a whole package to convert from one to the other (System.Address_To_Access_Conversions) and it even uses the unmentionable word "pointer" as in having a function named To_Pointer returning an Object_Pointer!  

  2. Ada has this concept of attributes: things one can get and/or set about any entity, simply using the syntax entity'attribute_name. For example, one can get the size of the Integer type simply by writing Integer'Size, one can get the size of a variable x by writing x'Size and one can set the size of some MyType by writing for MyType'Size use 133525. 

Comments feed: RSS 2.0

5 Responses to “Ada's Dirty Pointer Secrets: to Access, or to Address?”

  1. -----BEGIN PGP MESSAGE-----
    Version: GnuPG v1.4.10 (GNU/Linux)

    hQIMA3U2qif5BrDFAQ/8C+gbVKxPpORx82QgktyvTiKjR+GXDG5v9LvHK6z5g5Kw
    5l8BKPdFLi2kgcn9mqfIq1g/AxSG6yYDNEqO9EYgCmsD+Y1RXXEsx4RK8dMLY3BH
    FX+VCoQufyNK6IyWw9i8e7vO+GN+31U1WiaK9xEBa5sG4h7+1VEaT81u24NUOIoc
    zSbrSETdxLq8VIJ+Gap6JQMDBp5IlBCPJpI4KrLFTJ7Y5q5LXPIZRMtA5Szbrt64
    H8dlv76CViw3aeRsgKZUUw6LcyDfoJAkWjPAmniGmzeiplNz5JVFECkhX1PdL5Ih
    bYlgcSbvZVvjVBbUPHSnXXe3Dc/DcsryY5xrV6EPMWctfCPgtBmULziOb8zFKCrB
    KtLIvoKepkX2WaGTTKt+/hd2UVvqmNUB53iB78HG+JcWCGXdzCcg5rIp/LTb6hXB
    EA83BMtVAy5LkpojVq78yyu3vHyUo/EncKy9Yuh+UFrQh+apcGBJ1My8nOpceCE2
    NS7Q2JExeN2P3hbKsSzrsv7qmeEVHAZJ24Q1o8sO0vY68oVL1om5AnOFxNowq2vT
    8i/dgksCdnhWvc7EWqkQOLAcxgcMcXakYnBHgqWxgweEikXhsqlkHlN0KO1iS456
    +L385j0LdXuS4COvt9ssZRF1m3oJfWLOw9Nxzt/WMeTG+uCtZlScVQP0FofUEo3S
    6QHaPgjgDTsH4FA8S8Vq3bZpllaKoBTgfJ2KCFgQqZ6T2GS88iuGw0Bqr1+df6oT
    qV9OoCE7ib+np2OrtXce35owBupEj+H0g4+ZFXofaFcd0089jwRULdiDKvZrXunU
    HSSTKMEDPSi/MHZp6x/Mn1XIcJH/DT5sDmaDeZ5Ux8aOzWCZK0I1RBZfoLFY75zQ
    rt+exOQ2OVs1dl/SluOuPDF9R/kLFOqbKCV7yRGrXmu37GYGAwqC1HG4HrfTwatI
    758rw9tTLNjwK+pRluU9LCobfAeneSWondt6vOG14ACe6bPHLL6CCkeET8uHmNuN
    9PMBbHXmelHHqMQ5mQE3Pi/uGZgVjfWjWf6F3ROBis2JfXBmTGn//8JAVdOKq8NT
    i4E1RKucayP4GZCeOnSJkLIvpqbiUOmo1+5LWNcWCLN09vHi99F/Odh4wjMwVOiw
    Pmgxw7ADOzBnzX0sb6JlzKdo5RP9z4KN5pZa1RGqgCfAz8EzeFMRDujyESmKEhw2
    ilFFfLPBdQlCo2nyZ+4BkdfPB66weAhxnKxQCPqXKzI3Jc0d0dhZZdj9apJ9kKoI
    cBeQpRbnJfEQqT14pwlFpgw/k/ootHnIRy5/b03gOkYGpc5zFJ3/0CyZI0RQU9rC
    ojVQH4w/OO8VSbjxcYId7ZVmUe0X9+NhWUXmbLBL6SsYwH/WH2IvA6qEEjaXpreL
    3gmppFqCGq/SjROz0Swmoos5iMp2yBuo1RL7fLTIVuHMMXOektgRY4FckUv2qlC0
    MjoDOce6dfMQiSMoL89RA13jxWA8nHGQaosiyaZOSfW+KaRnu837qvmrpcHOFYzC
    6nMPvnnyCcuSfDffce32kjSF5NnLKJvYt9oBocJNf3Q2AA4d8QJCQt4lMlzDF4+/
    0qg881kcovmAexZ1E6GTnrEM8ySLDPKPxlOiLdRzREHUHDItduI0w45PPDgdy91t
    l3+3Ddyk8itavSzELJIe/JWEqheYWVkgz/9X8ffh00/wJewaSd+3u/kV6N5Go+6J
    Ligt+XpAdPj08EeLmfwyj7odQLWb26+4RWGSUBoKMJXwIllww/TlBDAl4jzBft3l
    jXXNB8KT57l0VCHpr4CTa3zf
    =ugTw
    -----END PGP MESSAGE-----
  2. Diana Coman says:
    -----BEGIN PGP MESSAGE-----

    hQILA3U2qif5BrDFAQ/3ZMofAIbcc9DVfnkKaVKptxOkVyBy0CGvne0uY17gW0PZ
    mO44XtUcw8iFrJGgGSUqvuyysPG1y3IbemCVXRlJlpLHtowkz7gqF69SYJxI3XxQ
    IE2bo2aDACSN5Nl7SuPbwmdPBjhEvk3osNLC7EiWjK1cqzXlmWiGRC4GV5oE7rje
    jtl23piNpjJ3P49fNtofXlWJhK0k2weBDncga68IgQKYkjSoU0iwT9UIVxOz/0Uc
    pQv2usbOyHV5Lf8A4s0hDP99AfpSRi0UvZ3XZM6HLW4hSbWSAMNr4zI9NXuE4j+L
    9ZgsQVVtYnUQFlnvzh11dibPpfQp4trJcpz/Vkvi13Ip8DZ0UhswRx7CH/mhcloJ
    ouWxggiX/sTUkqydq3IJ8ZBlYFfld6kNTVeyJGu7Ah9WVjj/VM7XSHLY1DH9EbVb
    HSgNF+i+5OwNHiw4t3/gtlpzQsz0MgQIRPDjPIzxVn+6unwH6bpz5vbtsIX6RjDy
    q5vzo73JUphV8piBq8fx3/8+Rtee8rTOeyydNgHboPsK3XQozrl9z1t4Nt86n7bP
    nYP03nUkfLnTnYJ8w0lZliSZqg8yCWXGRjVboSbxF7cP/CyWqUHCpvT7BJvygSwu
    a2KrDEP1+JEWaqm/FgeSQVwAPPRf7ZBQuH8WsSZLHAYB1fQE0AYUrblB3vV644UC
    DAPG2c7OFrjjLgEP/jd4Zl2Soz8FLwyVmMZljIVWkiqN9Nm46LX9xIkFTMEnmj6G
    PNrDzzQ1sZZrkbisAF2iJdWuE0OvRqKRzkoBtn/bqn8cBCx2wQLjGDHTTdjded0J
    cq77NPNkUGXSvokqtSWcImU0c445elKc31GUbl5HUHr47hjwDYU0YZP29xv8pQ7n
    EYg4f1RFmpvPTBaSZi1cRYDRCqR4cplHMWQ/LfnkkUUFgfmRrRN6lrZMv+tPtMK1
    jMXsBgfr1bOGnkhrjL5iBBgP6RWTXnfU8aCDA2hsc03qfe6ehSDWLootSgtXGI0I
    hADhzzPUx2fz6oziF5bGZMyphUiSMciv7svG5YDN+EwlFJQ0myWTjSJkj+QmGPYc
    t5GwFFx8AS/MDLgc47LDbZIzMR9KKQjJdiHVYqj2jnhdBoxx6wnN90Q3zGbvuB3G
    cDrWkgSYZ9pMgY4bsuY5u9KjrbpqybnNVclB8Ol4X0JaNw9tSWB6iuH5xDAj2QyU
    /G7+nYXkPBCNP/Ar8BYT3YCzD4pWhQVLP4qQIX0L2KBw6eiftcPAzS0UW2M5PkxH
    I8sWrxy4hf/yjDkjjc5rtT9rpyw+eYinhnDDHeAzP8KmAtr9xwKVcaPJD8/HJqCc
    z01hchhzAbEjlCpND4CMpzlvMZkbHLW6VWo91ozS2yMiSOUNrHQJZ2YBIMWghQIM
    A9Hv9VQ+I3IRARAAjG51UAtL7D8lddA+NK6OpMEu39Dk75Pq41z6KYQGqyv8RDJ2
    LKBkTBgwxCt/CcXJSzk2EUfU0GhELGBbvzDmHXIjA9eXuiAOmWGpMDrEdODpqsDN
    luXRAgyzY9pXwP7Yy5v7Q/Elq9koXnIeDh5+eqmTGKcZnRpfK3XjXb0v1VKq8PgQ
    4HElEMT4s0DeD4PDxuA3HrHx9lFSRf8t+AuCnGlU/jPCOxmNhH/gwK1VR0FC9dsT
    aaBE+QZopMp+O7kj1LY1ty0YvbTTcGNuLG4Hq9l3Alp8NyhqFmgJsCnoiG2wrj3Q
    L+NyhEYFLerVoiPgilBC7yGvTmSa5Kf18gQmA6Zbd/W0kV3dXYxFjO4LpWAcGft/
    NUrZMtA+ziuIBuj9KJyXqKdiVhdYFre2UD9WMgkxpvhCthVXden67sKsQ6lF28n0
    VDH8zwxuDL6KKJzrdWEaaW41PQkePvW0QbK4VC9Do4c0oqfall+t1/i3ERuaxqWV
    jolm21smD56Jaa4MzX+6GsogsETFPx+1FaZHgZqqznd+jGiTqdcTArb7j5rqlepT
    jKJmYvcQz/JNDBA/lsY554l3jUU2SXAbJRWGSVf0vkDbdZQTwPKBQopP3EdVgjfI
    pgw6m8hZHZ2YIZvV1d6jqKgt+btYfjLvPLxv1PQU1LKHbGrp+xYQSIc7+k3S6gG+
    0acmLDc2bPOpnPBxzIHKw2yVCQr3KihX+dz/kRTMaXUFQvjJlYDfS4NsrXHapWyA
    AD8LpqF+b3wkQq5KCbqX1MFRENS13mp3NLJu5ucLEZuCMBfSOLLwBBAOjQq7NVQE
    QIhqm7dR7KaaE7cKrMJy/BN9tcIRpsruK/pErRfxIp8S/dhnJP6+fzf4Lg4SjjDX
    qHlmGr2/MtvXZ3zI2jWDHCmgKHRYVr5kX7mgnHMDfad5CWrQw24dhq5or+GdWZxs
    ZsOZhod0seE7QAEMpsQPxIkweSe+nkBfMhKtYuqbxfrkwj8d49RUQme1NKE3VGr+
    igCo5c/K6EzFRDyWg1OG+QYj4kXcZmbn+Xgie55u2IMJASG8jgCM8IsvoJL8gQk9
    PESbZpqWixq7Qa1IEBOBWSlVuVF1n0hYO1fO8dT34vpJuQfme/6tQaCAB4YR9jIG
    sWYk0dIC2qsDzMqe/ZBv4WflFfWbbdKfRoPjCvVGDBHlxiOAz1KBQ4O+X/zmlQ16
    vdsjjnSlI0mmX5sDJ599w/0JELAxF4q9gZdIlJI6tDPdAbsW1tTXfAoZC6/25fIk
    PU5zPDSwM4aOcYBKPoQvnRrmKSpcO5aGzPvRh/04w86CMN/Ijdl1yBDz/Y1EGusz
    U0oC6kHhsJ+O+dIvXS6fQQm4Y+W0CideRX1QgPN9r9Khao/gt3megSK19exgUQk9
    m/fBByHWBb6GUKTodvn/WxKlVPSokWhmYYkru0EP/e2yOFHbyoMMMyu7Nq09dyft
    Y2mD/3/gRaoU+mIHoGZrW5fWBpwhRO5ylIRdhK4zYb2A0U3Z3g4JfXKANe+zyPGM
    xDcUssWAc8thp3mG4J24a/VWUAhTBEENkHvi4BLWZjY5v0ooh8bTpf5bs8XSvHLg
    rYpL/yW1VUIqa36QlfFGIoFxuJX92hVtbw9lZThlcAQ6r4VZTT5bHdkNdWTeZ35x
    8ZgLP58C1deS6wWHtvK/SRsHEQr2qiFqfDONVBHtRuzk4ECy48Lx5YbIQat2etXH
    C1Td1EGs/1KmgTdidFw+v2kb218kZ5cwFDOnBeSIxRHOpztgt3Pn0thBz0+Pbbye
    Gh/0FP7kj2rXL7XtHkeWQKdeTZrhKSSjN6aqGYz0kQ+ol2XSzJ7lNSpL+Gqxrtam
    1RoD1wNh5bYh+laOq++sKpQpym5HHDl4Kx4NANdwDf75JUi6FpUi246rzDRbyjQg
    LQMDTA9+bM7+lAr3x0henL0G+9yAOH38FZMMFK88RgKtto3fFI3Iyj9fKjIuiFVf
    fMGc2uVVNHwFJBf7ov0lkzk9F5m7XnYiK5+HEWvBd/IEmH8GWWlvlO2aKsbhJZNw
    SFbPcxrXhL912v4sFjPAPY3tEHVbsvWZFMlkHe7Jk8mp9IZZBkTDDyY4gz7ILT4u
    qXzTM7XJ2TyDF0zqqRZuZuZYh7jva1mQmeMgjQ6LwwSuIHyJIED8e4jnAcqrT7XG
    25ytqQElCzmzo4HtVQKO/kD3Xhbow/BAe7UjSKSmEDqKIUyYWLz1v/f646OtCanA
    zczTqt1hFk/kgF2VjEPHfW0WLwEjWSxCsTCBQ+MebHiXKYFUmTpJDS/+jYbvcbpI
    7uSZRlPaSlWdehsHin7NPwnlNS9KUeTdVJ1h4iFE/gW5UyIWs3l1BMjOhimZDlQY
    lbntCnwacegS+euYJLEYzLvwsDDxejRU24GBTRI=
    =nFUK
    -----END PGP MESSAGE-----
  3. -----BEGIN PGP MESSAGE-----
    Version: GnuPG v1.4.10 (GNU/Linux)

    hQIMA3U2qif5BrDFARAAwpE9D4plund1E98uy2ky97yn20G8ZlYHSn0MMRRjj8Hp
    9lnDmGKH1Iqv/UvWJBoNkg2v1TBPU0wsztoywOtix5pdPrW9pX1NYliOC/l4y4Sp
    eVc03GoHDSZoZG6Fhu+TB50sK2hhQHFRJ8H+0cbVX/v3m4VRV2936qtNUNU+D4lV
    txFtWdACF5nhfbPfwHnu4MNv4f1+7Dc3iSEwn6TJEJ5koxs443eAmidJVXF8DXsg
    Vz0R+ynbrXRpLsNQaO9kn/vAEWTpv6gJ7OyoP5stetrlwkrdV8KGwTrMsYMdsaLk
    cMnWRmTT3zEZYoa2vBzENv1ZXMNOcocara4LCvIMkHbSlxxf+Hy9QmBCOqImR3wf
    iUz/TJ1nHokn9lkEtl2IyRZr98NhUgMNrtLvWZjpq79QVRctyeN9TNUg+X2xR9ra
    MEJ//U/VPPbUTGMiH33gqCb4SHt+Po7jqpOxRVsDfG25pl1nqwtRvnEqx6MVBSWz
    ripY/dwG6yBdt2FyzQI+adxa2BgZ3IbVShYoqIJ081tvDlRxTY+y7sKSlTDCyopB
    SrMSN/DtwhWDxjx/B1cZkPiETNtHt2oukHKYOvkMSm/9r/rIJ0F8fY3AW1WDHG7g
    5APwjwvHu18nPSuUYrDSC6z4BVPvAoCzX9GAFIWJOR6UsTAaIGuHXoeq77+OzFWF
    AgwD0e/1VD4jchEBD/498cVv69f+qmzkWR4OLI7VRL/s/rSenUcQRAL4aohUTzIL
    XeGfTrxvBsGLGK59cO6A+q7KE28GpbApu4FSkH/kMqI0WhxGM7lR5Q79z3TpDMWw
    PqeRzbYFksoMUhK40zvHe3/KpDS/SWc1wuijqRrHksFcj0bQUYBvI6lWLwze2XEE
    RLMjBIktusDYcQqz/HiktlMIUgd3XbzVNykQsaAcglE794/0N0saGRpcwd42RDMe
    0DZ15GUX/IAAt6ltCtalhGVYn897hr22Yg9h2rDxsM6O58XQLJktPaUE09fvi9/t
    xqrbHeUZWaCxenqH8W+c9+tHDnlsJaoN+sCxD3q7FHfZOxtMbIuGWT/nNr4pGdcY
    HW8mnJeqChlHHmVMUvziZuZn7UO3fZV1FFjncwQaDXPC8hEj7nTJ7au9oNEEwAen
    IRtCu8DTYK2JkA6uvmx97jT245gkcbt76zA9Ha5iV7PkjE/o+cr68AXJweRopTuz
    raH9NbpGp0vybriY7tLOWVynQrNtdR6FjdkG6JLVSxAFOEjnijoS4Z+wQsI+4eAU
    PehivAJrXmsAPPMu5igx5PJiwa7Lc0X+Pg8pZlIXnbr2Cyy1OW1Hw6qoMt+plk4e
    wYjIM8pkHlVTXn3crmG8ZKiGEGUGyy7VzbMNXoUEe/U9GLccK/rPVemGF0/dUNLq
    AZ2NVhDK+x1wk6slb2MGKrayTxj2fcu3wA04QzHt+We8T3Q05k+3+vmfaW3G+9ed
    sFnqVvc3S6T5hqsP7M77bK/ZKsXN8uDI2ETN94Pk76oBlqPN18mUHP52FRTBGxHS
    cS6ZhKanvkrZoYQ1vxcdFDKNQfc7C+0msc8F6K785j8Rb5ZLCdBudxYEDuGlp2P0
    iRtUAA/eJ+18xkyFKcvEXtLfyGhpxVFCHTqiXRGO8NGLmMKujgGew5/NxJF1dxov
    6ge2Da252MEnPY3IlBQc16sFKrcL/y9TBVNJh1sdWOMaGfunxhXM8Uv7gDQAMFSA
    c/m5aT35/0yITkxDA8ys+SEXkwEpn99KRTb6AKM0xXk9Tg3+Bt+jQjCh8OLCp7fz
    R+VZQKZzVyQVPbzIlX2nVGfCaAVaL06XssgzNwFm8AC9XV3T+tCFTQG5XG+dKDvU
    MQ9hK/cmSZ6wTmbN7YWw0JycKxCY8o28SFZGzpnGv7Adsv3GKr9yDdVWuk9StvhM
    XlRXffQw8zb3RRaJGbV347J1AErMgJOet3jIQhNMSPkoZjdyVXh70g0PouseqL/U
    9TbgT+Js4cKkZ3kpk836ZVZJ5pvdjdjlDVKPdpU1xoCUgYKp/MKkmE/+qw68nkST
    mMN/G3Pm4AiLas0gW8yRkJiInAcdpBC9TiP2Z9+1aKe3sRzw39GhAx7Yg4gDdHtI
    zbNPqYTJ6DAyIplwhNANtgv04Dauu2VSvc+nT9JaqZtewK0rAUGMX9MOCdislvjH
    2Bj6V8S3fwn8rWlG1P7xl66Fw/GjuEHhMswhePgtalQ4x9n69cW+k9MndEF8WwH0
    L6sWVyiIBMQurvG6ohtvwplpoRSVLwtDTT5FFjxKoQVsXdSSntSM8rYzWijMBbGo
    TuXL+ohuILhIn1tEBpbQHk57DcgpyEobBwwDAIby43buA9+BGOP0IwUkJpXXEbJm
    SxmOBRFDDlEs3HCZCc/diZDuTLHD/ouAuHONM4B283o+ZMdd5raD6j9VOLgiPXVt
    3Xe7AEBcXLL/uXSgJ0wzFQJUeoZdDsa/146TOQhKDqNxaWTe+Lzb4O+nRDiLMS2Q
    159Glfdf69h0+xZAg3/QjnajLRe4tyQNHpS/AjwjaW3OBwetVf1Z4nqRIDwH7zCS
    6q7AZefKCyGzmKmiqks0iLFQITMmpd1tbksNokZt7KRHQ9mtrg1NImrOl/TAP5PF
    NtMwjIqGrNQaeOXgZW6H3679n/V5jjZXErYlPu/z5v3aAbSqHe+gcxBmQoubU1ch
    5M+EZbsSO74s2472GIQ1CcCSSqRaN4Noz5z8+bgxQp5p4WIpMuEPyx7eqiZsdFsC
    okNJLtOBmSckudU/x9Gn8o9BM78J6VGJMKNkSekCljyShGBTrLGWqT4tMCiaW/g2
    70iGqsQUxHQtl3hK1vD6UF8qcIlKO6/qNarvAbNgOrPa3CK4Ixq2q1/CEmi1OBHZ
    b6qfXWrAb8fZ/rHuZ7BwGZekw/sJ3bsIOU7qOpWcURQelvhpeeFvjOEr/YoqEsSc
    wLaKTmJYbFTK8SPVZAc/jw==
    =m6J/
    -----END PGP MESSAGE-----
  4. Diana Coman says:

    Seems clear enough.

  5. [...] (over which GNAT wraps layers upon layers of obfuscation more than usefulness) and uses otherwise direct memory mapping to convert between any given type to its raw representation and [...]

Leave a Reply