C Macros and their equivalent in Ada

C Macros and their equivalent in Ada

[RasikaSrinivasan]

are there Ada equivalents of the C macros like :

__DATE__, __TIME__

My searches have not revealed anything. have i missed any obvious
pragmas?

thanks, srini

Re: C Macros and their equivalent in Ada

[Colin Paul Gloster]

On Tue, 9 Sep 2008, RasikaSrinivasan@gmail.com wrote:

|-----------------------------------------------------------------|
|"are there Ada equivalents of the C macros like :                |
|                                                                 |
|__DATE__, __TIME__                                               |
|                                                                 |
|My searches have not revealed anything. have i missed any obvious|
|pragmas?"                                                        |
|-----------------------------------------------------------------|

How about the function
Ada.Calendar.Clock
to get the current instant and passing that to the Date parameter of
the Ada.Calendar.Split procedure (such that the date would be output
to the other parameters)?

Similarly you could use / and mod to get the time of day from
Ada.Calendar.Seconds.

See
WWW.AdaIC.org/standards/05rm/html/RM-9-6.html#I3741
.

Regards,
Colin Paul Gloster

Re: C Macros and their equivalent in Ada

[Jeffrey R. Carter]

RasikaSrinivasan@gmail.com wrote:
> are there Ada equivalents of the C macros like :
> 
> __DATE__, __TIME__

I have no idea. Perhaps if you told us what you are trying to achieve, rather 
than how you achieved it in some other language we may not know, you would get a 
more useful reply.

-- 
Jeff Carter
"When danger reared its ugly head, he bravely
turned his tail and fled."
Monty Python and the Holy Grail
60

Re: C Macros and their equivalent in Ada

[Ludovic Brenta]

RasikaSrinivasan@gmail.com wrote:
> are there Ada equivalents of the C macros like :
>
> __DATE__, __TIME__
>
> My searches have not revealed anything. have i missed any obvious
> pragmas?

No, Ada does not have macros. I am not aware of any compiler that
provides the equivalent of C's __DATE__ and __TIME__ macros (which,
for those here who don't know C, expand to the date and time at which
preprocessing took place, as strings).

If you need that feature, you're better off generating an Ada source
file from the "date" utility, e.g.

echo "package Compilation_Date is" > compilation_date.ads
echo "   Timestamp : constant String := \"$(date --full-ISO)\";" >>
compilation_date.ads
echo "end Compilation_Date;" >> compilation_date.ads

HTH

--
Ludovic Brenta.

Re: C Macros and their equivalent in Ada

[Adam Beneschan]

On Sep 9, 3:43 am, "RasikaSriniva...@gmail.com"
<RasikaSriniva...@gmail.com> wrote:
> are there Ada equivalents of the C macros like :
>
> __DATE__, __TIME__
>
> My searches have not revealed anything. have i missed any obvious
> pragmas?
>
> thanks, srini

Ada doesn't have a standard mechanism for providing the compilation
date and time.  There's no reason why a particular implementation
couldn't provide something like this, though---perhaps a package with
special String constants or functions (most likely using pragma
Import) that would cause the compiler to substitute the compile date/
time when the constant or function is used.  Our compiler has
something like this.  Don't know whether GNAT does.  If you need it,
you may want to ask your compiler vendor for this sort of feature.  It
shouldn't be terribly difficult to implement.

                                  -- Adam

Re: C Macros and their equivalent in Ada

[Ray Blaak]

Colin Paul Gloster <Colin_Paul_Gloster@ACM.org> writes:
> On Tue, 9 Sep 2008, RasikaSrinivasan@gmail.com wrote:
> |"are there Ada equivalents of the C macros like :                |
> |                                                                 |
> |__DATE__, __TIME__                                               |
>
> How about the function Ada.Calendar.Clock to get the current instant

The idea is to get the date/time the file was compiled.

Rasika, what I have often done is generate a source file from my build script
that has the version and build dates baked in. E.g. using ant:

  <property name="VERSION" value="1.1"/>

  <target name="generate.version">
    <tstamp>
      <format property="yyyyMMdd" pattern="yyyyMMdd"/>
    </tstamp>
    <echo file="src/Support/Version.adb">
package body Version is

  function Version return String is
  begin
    return "${VERSION}";
  end;

  function Build return String is
  begin
    return "${yyyyMMdd}";
  end;
end;
    </echo>
  </target>

Apologies for any errors, but it should get the idea across.

-- 
Cheers,                                        The Rhythm is around me,
                                               The Rhythm has control.
Ray Blaak                                      The Rhythm is inside me,
rAYblaaK@STRIPCAPStelus.net                    The Rhythm has my soul.

Re: C Macros and their equivalent in Ada

[RasikaSrinivasan]

I have a similar solution implemented. thanks. was just trying to
figure out if there was anything recent.


On Sep 9, 12:33 pm, Ray Blaak <rAYbl...@STRIPCAPStelus.net> wrote:
> Colin Paul Gloster <Colin_Paul_Glos...@ACM.org> writes:
>
> > On Tue, 9 Sep 2008, RasikaSriniva...@gmail.com wrote:
> > |"are there Ada equivalents of the C macros like :                |
> > |                                                                 |
> > |__DATE__, __TIME__                                               |
>
> > How about the function Ada.Calendar.Clock to get the current instant
>
> The idea is to get the date/time the file was compiled.
>
> Rasika, what I have often done is generate a source file from my build script
> that has the version and build dates baked in. E.g. using ant:
>
>   <property name="VERSION" value="1.1"/>
>
>   <target name="generate.version">
>     <tstamp>
>       <format property="yyyyMMdd" pattern="yyyyMMdd"/>
>     </tstamp>
>     <echo file="src/Support/Version.adb">
> package body Version is
>
>   function Version return String is
>   begin
>     return "${VERSION}";
>   end;
>
>   function Build return String is
>   begin
>     return "${yyyyMMdd}";
>   end;
> end;
>     </echo>
>   </target>
>
> Apologies for any errors, but it should get the idea across.
>
> --
> Cheers,                                        The Rhythm is around me,
>                                                The Rhythm has control.
> Ray Blaak                                      The Rhythm is inside me,
> rAYbl...@STRIPCAPStelus.net                    The Rhythm has my soul.

Re: C Macros and their equivalent in Ada

[Maciej Sobczak]

On 9 Wrz, 16:39, Ludovic Brenta <ludo...@ludovic-brenta.org> wrote:

> If you need that feature, you're better off generating an Ada source
> file from the "date" utility, e.g.
>
> echo "package Compilation_Date is" > compilation_date.ads
> echo "   Timestamp : constant String := \"$(date --full-ISO)\";" >>
> compilation_date.ads
> echo "end Compilation_Date;" >> compilation_date.ads

This is a simple and valid approach but works only for things that are
build-wide.
The other extremely useful macros from the C world are __FILE__ and
__LINE__. I'm afraid there is no way to simulate them using any
external solutions, short of using the real preprocessor (why not?).

Yeah - why not use the cpp preprocessor?

Let's say that instead of implementing the .adb file we write
something that will be used to generate it:

$ cat a.adbs
with Ada.Text_IO;
procedure A is
begin
   Ada.Text_IO.Put_Line (__DATE__ & " " & __TIME__);
end A;
$ cpp -P a.adbs > a.adb
$ gnatmake a
gcc -c a.adb
gnatbind -x a.ali
gnatlink a.ali
$ ./a
Sep  9 2008 22:53:23
$

Works for me. I can even write a rule in Makefile to make (pun
intended) that automated. Not sure if GNAT project files can do it,
though.

--
Maciej Sobczak * www.msobczak.com * www.inspirel.com

Database Access Library for Ada: www.inspirel.com/soci-ada

Re: C Macros and their equivalent in Ada

[Ray Blaak]

"RasikaSrinivasan@gmail.com" <RasikaSrinivasan@gmail.com> writes:
> I have a similar solution implemented. thanks. was just trying to
> figure out if there was anything recent.

I would argue that generating the version file explicitly from a build script
is actually superior to __DATE__/__TIME__ macros, since the actual compilation
build time is often inconsistent.

If the version file has not actually changed in a while, for example, typical
build environments just use the last object file, meaning the datestamps can
be quite obsolete and thus inaccurate.

By tying it to the build script, you can do things like saying "make a
official release NOW", and know that the version datestamp is tied to that
explicit action.

This is important to allow one to correlate the datestamp to changelongs,
release notes, etc.
-- 
Cheers,                                        The Rhythm is around me,
                                               The Rhythm has control.
Ray Blaak                                      The Rhythm is inside me,
rAYblaaK@STRIPCAPStelus.net                    The Rhythm has my soul.

Re: C Macros and their equivalent in Ada

[Per Sandberg]

If using GNAT the simple approach for those two macros could be found in 
the package:
   GNAT.Source_Info
where you could find:
    function File return String; -- Current file
    function Line return Positive; -- Current Line
    function Source_Location return String; -- Current file & Line
    function Enclosing_Entity return String; -- Enclosing name.
/Per

Maciej Sobczak wrote:
> On 9 Wrz, 16:39, Ludovic Brenta <ludo...@ludovic-brenta.org> wrote:
> 
>> If you need that feature, you're better off generating an Ada source
>> file from the "date" utility, e.g.
>>
>> echo "package Compilation_Date is" > compilation_date.ads
>> echo "   Timestamp : constant String := \"$(date --full-ISO)\";" >>
>> compilation_date.ads
>> echo "end Compilation_Date;" >> compilation_date.ads
> 
> This is a simple and valid approach but works only for things that are
> build-wide.
> The other extremely useful macros from the C world are __FILE__ and
> __LINE__. I'm afraid there is no way to simulate them using any
> external solutions, short of using the real preprocessor (why not?).
> 
> Yeah - why not use the cpp preprocessor?
> 
> Let's say that instead of implementing the .adb file we write
> something that will be used to generate it:
> 
> $ cat a.adbs
> with Ada.Text_IO;
> procedure A is
> begin
>    Ada.Text_IO.Put_Line (__DATE__ & " " & __TIME__);
> end A;
> $ cpp -P a.adbs > a.adb
> $ gnatmake a
> gcc -c a.adb
> gnatbind -x a.ali
> gnatlink a.ali
> $ ./a
> Sep  9 2008 22:53:23
> $
> 
> Works for me. I can even write a rule in Makefile to make (pun
> intended) that automated. Not sure if GNAT project files can do it,
> though.
> 
> --
> Maciej Sobczak * www.msobczak.com * www.inspirel.com
> 
> Database Access Library for Ada: www.inspirel.com/soci-ada

Re: C Macros and their equivalent in Ada

[Keith Thompson]

Maciej Sobczak <see.my.homepage@gmail.com> writes:
[...]
> The other extremely useful macros from the C world are __FILE__ and
> __LINE__. I'm afraid there is no way to simulate them using any
> external solutions, short of using the real preprocessor (why not?).
>
> Yeah - why not use the cpp preprocessor?
[...]

The cpp preprocessor is designed to be used with C and C++.

For example, the apostrophe character in C, if it appears outside a
string literal, is used only as a delimiter for a character constant.
If you have a single apostrophe on a line because you're using an Ada
qualified expression or attribute, or even in an Ada comment (the
leading -- will be treated as an operator symbol), then cpp is likely
to complain or even terminate.

One implementation I just tried issued a warning message and continued
processing, but that's not guaranteed.

-- 
Keith Thompson (The_Other_Keith) kst-u@mib.org  <http://www.ghoti.net/~kst>
Nokia
"We must do something.  This is something.  Therefore, we must do this."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"

Re: C Macros and their equivalent in Ada

[Steve]

<RasikaSrinivasan@gmail.com> wrote in message 
news:f0560361-31c2-4a3d-851c-639cdfc5ac46@i76g2000hsf.googlegroups.com...
> are there Ada equivalents of the C macros like :
>
> __DATE__, __TIME__
>
> My searches have not revealed anything. have i missed any obvious
> pragmas?
>
> thanks, srini

Years ago I was looking for exactly the same thing on a Windows target.  So 
far as I could find, Ada doesn't have a standard way of accessing this 
information.

The reason I was looking for the information is so that a program could 
report when it was built.

I found an alternative that works on Windows.  There is a windows API 
function GetFileVersionInfo that may be used to obtain the date and time the 
executable was linked.

If this happens to be what you're looking for, let me know and I can send 
(or post) source code.

Regards,
Steve