ANN: Kickstarter for beginning work on a new open-source Compiler

ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

It is my belief that a new, non-GNAT, open-source [and free] Ada 2012 translator would be a good thing for both the Ada community and the general programming population -- this without even breaking from the traditional approaches. However, I think that a good, quality IDE/PSE could be quite advantageous; offering better project-management, documentation, verification, versioning, and correctness/consistency checking.

The working-copy of the proposal is here:
https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing

The link to the Kickstarter is here:
https://www.kickstarter.com/projects/871049686/squid-open-source-compiler-and-ide-for-the-ada-201

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Maciej Sobczak]

W dniu środa, 19 marca 2014 00:23:57 UTC+1 użytkownik Shark8 napisał:

> The working-copy of the proposal is here:
> 
> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing

Short version: this will fail.

Long version follows.

The proposal itself is fundamentally broken. You have to be aware that the biggest challenge for the Ada community is that of industry awareness. That is, most of the programming community never heard about Ada and those few that did do not see any reason to invest their time in it. The proposal for starting a significant project with public funding should focus on the rationale to explain why such an investment makes sense. But your proposal does not even attempt to do that. In fact, I think that the word "Ada" appears there fewer times than, say, "Delphi". Leaving aside my own relationship with Ada ;-), I see no reason whatsoever why I should give my money to this project.
You can see this problem in the following way: what will happen if you replace the word"Ada" with "Java" or "Scala" in this proposal? It will still be the same proposal and will still make as much (or as little) sense. Which means that this proposal is *not* about Ada. It is about your opinion about how IDE should look like.

Which brings us to another important flaw. The Ada (or Java or Scala, if you decide to replace words) programming language was *defined* in terms of text. It *is* a text-based language. If you think it is a problem, you will not fix it by reinventing the IDE. You have to redefine the programming language to break its natural ties the text format, but if you take the text-based language and try to work with it as if there is no text, you will fail. This idea (should I write IDEa?) is not even new, it was already practiced. I have had a misfortune to work with something like this in the past and it was utter crap that prevented programmers from doing their work efficiently, because the whole concept isolated the programmers from the existing tools. You will never solve all problems in the IDE, at best you will end up with something that is miserable at some selected aspect of programming work and that instead of enabling programmers to spread their wings, just pisses everybody off.

Which basically already started by fixing parts of the solution before exploring the problem - I'm talking about the precise selection of tools that you have proposed at the very beginning: Delphi + .NET + Mono + InterBase? Really?

No, REALLY?

I just fail to imagine Ada enthusiasts (and you need *a lot* of enthusiasm to make something as significant) running to contribute to this.

Sorry.

-- 
Maciej Sobczak * http://www.msobczak.com * http://www.inspirel.com

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Peter Chapin]

I think the proposal is interesting and I would love to see it succeed.
 Maciej Sobczak is concerned about the tool isolation that might arise
by storing program information in a database of ASTs (or similar). I can
see how that might be a problem. An IDE of the proposed nature would
definitely require a robust way to import/export traditional source
text. A user of such an IDE could then still use traditional version
control systems, CI systems, documentation generators, etc.

I understand that environments such as the one proposed have been
attempted before. However, just because they didn't work well in the
past doesn't mean this attempt must necessarily fail. This attempt could
take lessons from the other systems and, perhaps, avoid or work around
the issues that caused problems in the past.

The proposal is very ambitious because it provides both a complex IDE
and a compiler for Ada 2012. Either one of those projects would be
daunting on its own. To the OP: have you considered ways of having the
IDE interact with existing compilers? Ada, in particular, does have an
ASIS standard that can guide, to some extent, the design of abstract
program representations.

I ask this because I have a pet project of my own to write an Ada 2012
compiler from scratch. I will post more about that in another thread to
avoid hijacking this one. However, my vision follows the lead of clang,
Microsoft's Roslyn C# compiler, and to a lesser extent the Scala
compiler. Modern compilers, I believe, should not just slurp up text and
output object code. Instead they should be provided as a collection of
well documented libraries that can be directly loaded into other
applications. This allows applications, such as IDEs, to exchange
information with the compiler using abstract representations while at
the same time keeping both projects well isolated. See the clang
documentation for what I believe is the right way to do it.

Thus as a potential Ada 2012 compiler writer I ask: what sort of APIs
would be useful if one wanted to split off the code analysis and
generation from the IDE itself and move it into a separately developed
library?

Peter

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dmitry A. Kazakov]

On Wed, 19 Mar 2014 09:02:02 -0400, Peter Chapin wrote:

> The proposal is very ambitious because it provides both a complex IDE
> and a compiler for Ada 2012.

... designed in a [obscene, dying, vendor-locked, the list can easily be
continued] language like Delphi. I doubt Ada community will be eager to
contribute in Delphi. I did projects in Turbo, Object Pascal and Delphi,
never again!

> Thus as a potential Ada 2012 compiler writer I ask: what sort of APIs
> would be useful if one wanted to split off the code analysis and
> generation from the IDE itself and move it into a separately developed
> library?

Yes, and it is not the compiler alone to interact with the system. No less
important components are:

- source code control system
- project management system 
- debugger

Project management is especially important for Ada because Ada projects
mainly are cross-platform and/or embedded. That require handling of various
targets, cross-compilation, linking, uploading (for embedded targets) etc.
For example, mere abstraction of OS-specific dynamic linking as done by
GNAT project system is a huge task.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Stephen Leake]

Shark8 <onewingedshark@gmail.com> writes:

> The working-copy of the proposal is here:
> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing

You have clearly put a lot of thought into this.

I have a few comments/questions.

1) Why write the new tool in Delphi and not Ada?
    
    The Rationale section "Why implement in Delphi 2007" provides a
    rationale for implementing in dotnet, not Delphi. There is an Ada
    compiler for dotnet (I think it needs work, but you are already
    proposing a huge amount of work, so what's a little more?).

    And even that rationale is not convincing. Emacs, Eclipse, GPS are
    all portable to Linux and Windows; in what other environments do you
    require running the IDE?

2) The Rationale section "Why Write an Ada Compiler?" provides a
   justification for writing an IDE plugin, not an Ada compiler.

   You can easily extract text from the database and feed it to gnat, or
   any other Ada compiler.

3) Storing text as correct, structured data:

    a) has been tried before; in Rational R1000
       (http://en.wikipedia.org/wiki/R1000 - not a very informative
       link, unfortunately). Did you review any lessons learned from
       that?

    b) Prevents people checking in code so colleagues can answer the
       question "why doesn't this compile"?

    c) Prevents writing skeletons; something I do when starting a
       totally new project.

4) You don't address "Why write a new IDE rather than a plugin for an
   existing one?"

    IDEs are huge, complex beasts. What you propose to do can be
    accommodated as a plugin for Eclipse, Emacs, or GPS.

    GPS from AdaCore is a nice Ada IDE, but it lacks many features that
    I find essential on a daily basis, which is why I use Emacs instead.
    Any new tool you start will be even more limited.

5) Current IDEs (GPS, Eclipse, less so Emacs) use a parsed
   representation of the source for refactoring, completion, and the
   other tasks you require in an IDE. That gives the best of both
   worlds.

6) What is your business plan? You are proposing to directly compete
   with AdaCore; it is not at all clear from the proposal that you
   understand what that means.

-- 
-- Stephe

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

[I'm trying Thunderbird as a news-reader; I believe it sent Mr. Leake an email reply rather than the desired public-posting here.]

On 19-Mar-14 07:25, Stephen Leake wrote:
> Shark8 <onewingedshark@gmail.com> writes:
>
>> The working-copy of the proposal is here:
>> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing
>
> You have clearly put a lot of thought into this.
>
> I have a few comments/questions.
>
> 1) Why write the new tool in Delphi and not Ada?
>
>      The Rationale section "Why implement in Delphi 2007" provides a
>      rationale for implementing in dotnet, not Delphi. There is an Ada
>      compiler for dotnet (I think it needs work, but you are already
>      proposing a huge amount of work, so what's a little more?).
>
>      And even that rationale is not convincing. Emacs, Eclipse, GPS are
>      all portable to Linux and Windows; in what other environments do you
>      require running the IDE?

Good points; very good.
I'll try to address them in the next update, right now I have no good 
and articulable reasons.

One reason to use Delphi rather than Ada is licensing; IIUC the license 
for GNAT would prohibit development of a commercial product and 
[probably] the development of something that /would be/ used in a 
commercial product -- I simply do not wish to burden users of this 
system in that manner.

I do need to elaborate on that [the rationale] to flesh it out, which is 
why the proposal is a "working copy" -- I was afraid that failing to 
commit to publishing it would lead to an "endless planning" circuit in 
myself.

> 2) The Rationale section "Why Write an Ada Compiler?" provides a
>     justification for writing an IDE plugin, not an Ada compiler.
>
>     You can easily extract text from the database and feed it to gnat, or
>     any other Ada compiler.

True.
But storing it as unprocessed text means that you [well, your 
computer/tools] have to repeat a lot of work (e.g. parsing) again and 
again. "Moving that processing to the outer loop" can reduce that, and 
given the advantages of working w/ meaningful-data vs. generalized-text 
it seems like a reasonable thing to do.

> 3) Storing text as correct, structured data:
>
>      a) has been tried before; in Rational R1000
>         (http://en.wikipedia.org/wiki/R1000 - not a very informative
>         link, unfortunately). Did you review any lessons learned from
>         that?

I've heard some good things about the R1000, but haven't seen a lot of 
information on it -- I did find a PDF on a review of it, which I still 
need to read, I'm currently working on the Ada 83 Rationale (for a 
better understanding of the language's roots/ideologies).

Evaluation of the Rational Environment
URL: http://www.sei.cmu.edu/reports/88tr015.pdf

>
>      b) Prevents people checking in code so colleagues can answer the
>         question "why doesn't this compile"?
>

Non-working code should be kept out of the [main] code-base; this 
situation can be handled with a chat/message-board (or similar) sort of 
functionality -- There's *no* need to pollute your revisions with code 
that cannot work. (i.e. Don't compromise your secure communication 
network by forcing acceptance of unsecured components. // In-band 
communication [of metadata] is a Bad-Thing(tm).)

>      c) Prevents writing skeletons; something I do when starting a
>         totally new project.

Howso?
You can still have the procedure's "is null" spec; and Delphi itself has 
been generating empty subprograms forever.

>
> 4) You don't address "Why write a new IDE rather than a plugin for an
>     existing one?"
>
>      IDEs are huge, complex beasts. What you propose to do can be
>      accommodated as a plugin for Eclipse, Emacs, or GPS.

So?
That argument would preclude development of new OSes; which would be 
detrimental, especially considering that we are right-now at the cusp of 
real need for formally validated/verified (and therefore [more] secure 
and stable) OSes.

>      GPS from AdaCore is a nice Ada IDE, but it lacks many features that
>      I find essential on a daily basis, which is why I use Emacs instead.
>      Any new tool you start will be even more limited.

Agreed (that GPS is pretty nice, yet missing a lot).

> 5) Current IDEs (GPS, Eclipse, less so Emacs) use a parsed
>     representation of the source for refactoring, completion, and the
>     other tasks you require in an IDE. That gives the best of both
>     worlds.

Yes, and given how nicely that works it makes sense that other tools 
could benefit from operating with parsed info rather than "plain text" 
(e.g. repositories, which could store name-changes as updating a 
property in the stored object and allow for ignoring non-meaningful 
changes [like tabs vs. spaces]).

> 6) What is your business plan? You are proposing to directly compete
>     with AdaCore; it is not at all clear from the proposal that you
>     understand what that means.

I understand that AdaCore mainly deals in support not, strictly 
speaking, the compiler itself; but even if this weren't the case, I'm of 
the opinion that the programming community could benefit from another 
freely available implementation... especially one which doesn't share 
the same codebase.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Alan Browne]

On 2014.03.18, 19:23 , Shark8 wrote:
> It is my belief that a new, non-GNAT, open-source [and free] Ada 2012 translator would be a good thing for both the Ada community and the general programming population -- this without even breaking from the traditional approaches. However, I think that a good, quality IDE/PSE could be quite advantageous; offering better project-management, documentation, verification, versioning, and correctness/consistency checking.
>
> The working-copy of the proposal is here:
> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing

0. Why is your exec summary so detailed?

1. Delphi?   Why not in Ada?

2. Your subject is "... a new open-source Compiler".  Your project is 
not so much about a compiler.

3. Text.  Nothing wrong with that.  You can ridicule it all you like 
with quotations, but it is the lowest common denominator.  Strawmen 
arguments like EOL and character sets is just distraction - such are 
easily fixed/translated if not handled automatically.

4. References to alleged poor design practices at Toyota are specious 
and irrelevant.  The Sony reference too.  (You're employing "scare" 
marketing.  Bzzzt.).

5. This whole project, to me, puts the programmer too far away from the 
source code.  Buries it.  That is not a good objective.

-- 
    ... it may be that "in the cloud" really isn't the best term
    for the services these companies offer.  What they really
    want is to have us "on the leash."
                   -David Pogue, Scientific American, 2014.02

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Peter Chapin" <PChapin@vtc.vsc.edu> wrote in message 
news:fKSdnQj47oHXCLTO4p2dnAA@giganews.com...
>I think the proposal is interesting and I would love to see it succeed.
> Maciej Sobczak is concerned about the tool isolation that might arise
> by storing program information in a database of ASTs (or similar). I can
> see how that might be a problem. An IDE of the proposed nature would
> definitely require a robust way to import/export traditional source
> text. A user of such an IDE could then still use traditional version
> control systems, CI systems, documentation generators, etc.

It has to provide text import to be considered an Ada 2012 compiler. Ada 
2012 requires the compiler to process UTF-8 text in specific formats in 
order to meet the standard. That's a new requirement for Ada 2012, although 
as a practical matter any Ada compiler has to be able to process the ACATS 
and thus needs to have some way to import text.

Unless you're insisting on being an island (and that's not what Ada's about, 
IMHO), you also need to to have export, for no other reason than to allow 
your code to be used on other Ada compilers when necessary.

                           Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Peter Chapin" <PChapin@vtc.vsc.edu> wrote in message 
news:fKSdnQj47oHXCLTO4p2dnAA@giganews.com...
...
> I ask this because I have a pet project of my own to write an Ada 2012
> compiler from scratch.

Ah, another delusional soul. ;-) Take it from someone who seriously followed 
that path -- there be dragons. :-) For one thing, if you're at all 
successful, you'll be stuck there for the rest of your working life. And to 
get far enough to be at all successful, you'll have to figure out how to 
deal with lovely things like resolution, visibility, and tyranny of 
interfaces. Odds are, you'll never get far enough to work on anything 
interesting.

                       Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:wajahqy00a66$.1hz593k34vcwt$.dlg@40tude.net...
>> The proposal is very ambitious because it provides both a complex IDE
>> and a compiler for Ada 2012.
>
> ... designed in a [obscene, dying, vendor-locked, the list can easily be
> continued] language like Delphi. I doubt Ada community will be eager to
> contribute in Delphi. I did projects in Turbo, Object Pascal and Delphi,
> never again!

Beyond that, I'd be very suspious of any supposedly general purpose 
programming system that couldn't be created in itself. There is a great 
value to eating your own dogfood (as the saying goes). It gets rid of gross 
usability problems in a hurry, and it reduces risk in the project (as there 
cannot be show-stopping bugs in the development tools -- you just have to 
fix any problems that occur).

It does require care to avoid the Catch 22 situation where an old bug is 
preventing work using the old compiler and a new bug is preventing work 
using a new compiler so that there isn't any obvious way to do any work. 
(That happened to us once in the mid-1980s - I had to fix the bug in the old 
compiler with a binary patch in order to cut the Gordian knot and continue. 
Have been much more careful about regression testing before abandoning old 
compiler versions since.)

And of course, we all know that Ada is the best language for creating large 
projects. An Ada development system is surely a large project. There's a 
reason that virtually all Ada compilers are largely written in Ada. (Some 
share backends with other systems, but I don't know of any Ada frontends not 
written in Ada.)

                                             Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Alan Browne" <alan.browne@FreelunchVideotron.ca> wrote in message 
news:h4-dnfOe2fPtm7fOnZ2dnUVZ_rudnZ2d@giganews.com...
...
> 3. Text.  Nothing wrong with that.  You can ridicule it all you like with 
> quotations, but it is the lowest common denominator.  Strawmen arguments 
> like EOL and character sets is just distraction - such are easily 
> fixed/translated if not handled automatically.

Plus *wrong* for Ada 2012 -- the language standard specifies a standard text 
format that all Ada compilers must support (see my other message). We even 
specified how line endings are interpreted in that text format, so there is 
not problem whatsoever with interpreting code in that format. Moreover, the 
vast majority of existing Ada source code is already in that format (code in 
7-bit Ascii is encoded the same way in UTF-8), the line ending match the 
standard way that Windows and Linux represent text.

Obviously, one can have problems with weird source representations, as those 
are allowed but not required. But all an IDE has to do to avoid them is to 
make it hard to save text in non-standard formats.

                          Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Shark8" <onewingedshark@gmail.com> wrote in message 
news:0d9343e9-6190-46b0-a313-bc33ed17f28d@googlegroups.com...
...
> But storing it as unprocessed text means that you [well, your
> computer/tools] have to repeat a lot of work (e.g. parsing) again and
> again. "Moving that processing to the outer loop" can reduce that, and
> given the advantages of working w/ meaningful-data vs. generalized-text
> it seems like a reasonable thing to do.

*Seems* reasonable, but actually is just premature optimization.

Computers have gotten amazingly fast these days -- a lot of the design 
decisions that we made with Janus/Ada to reduce compilation time and storage 
requirements don't do much today.

And remember that an IDE needs human-level response times. On a modern 
computer, one can do a heck of a lot in between keypresses or mouse 
movements. On top of that, parsing is relatively easy and cheap. Parsing is 
one of the cheaper phases of a compiler, and it's dubious that it would be 
worth a complex (and likely to be much more fragile) data structure in order 
to save that small amount of time. Especially with the other costs of going 
away from standard text representations.

                                 Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Brian Drummond]

On Wed, 19 Mar 2014 12:55:39 -0700, Shark8 wrote:

> One reason to use Delphi rather than Ada is licensing; IIUC the license
> for GNAT would prohibit development of a commercial product and
> [probably] the development of something that /would be/ used in a
> commercial product -- I simply do not wish to burden users of this
> system in that manner.

Look into that a little more closely ... it is not the case that code 
*compiled* with a gpl compiler is itself gpl'ed. 

However it *is* the case that code *linked* (statically) with a pure gpl 
runtime system is gpl if the runtime does not have the old "gnat modified 
gpl" license (aka GMGPL) making an exception by permitting linking to the 
runtime without extending gpl to the entire executable. 

The Libre version of Gnat no longer has GMGPL so you cannot use its 
runtime in a non-GPL executable.

However, you can build a "zero footprint" Ada program ( without the RTS) 
as is done for very small embedded MPUs, Atmel AVR. MSP430 etc. and 
(unliss I misread the licensing) these should be gpl-free.

Which means you could in principle substitute another RTS licensed under 
another license (GMGPL or GPLv3 with the equivalent runtime exception) 
and link your program (in this case, your own compiler) to that RTS.

And you have to provide such an RTS anyway.

So to use Gnat to bring up your compiler, write the RTS first.


Here's another alternative Ada compiler project... 
https://sourceforge.net/projects/hacadacompiler/

- Brian

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

Peter Chapin <PChapin@vtc.vsc.edu> wrote:


> IDE interact with existing compilers? Ada, in particular, does have an
> ASIS standard that can guide, to some extent, the design of abstract
> program representations.

ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
extensions, do you have links?

Luke

Re: Kickstarter for beginning work on a new open-source Compiler

[Peter Chapin]

On 2014-03-19 20:12, Luke A. Guest wrote:

> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
> extensions, do you have links?

I'm sorry I don't. I guess I assumed ASIS will be updated for Ada 2012,
but of course that depends on the hard work of those involved in the
standard.

Peter

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

Peter Chapin <PChapin@vtc.vsc.edu> wrote:
> On 2014-03-19 20:12, Luke A. Guest wrote:
> 
>> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
>> extensions, do you have links?
> 
> I'm sorry I don't. I guess I assumed ASIS will be updated for Ada 2012,
> but of course that depends on the hard work of those involved in the
> standard.

This is why you should not attempt to use ASIS as your AST.

Luke

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Lucretia]

On Wednesday, 19 March 2014 19:55:39 UTC, Shark8  wrote:
> > 1) Why write the new tool in Delphi and not Ada?
> >
> One reason to use Delphi rather than Ada is licensing; IIUC the license
> for GNAT would prohibit development of a commercial product and
> [probably] the development of something that /would be/ used in a
> commercial product -- I simply do not wish to burden users of this
> system in that manner.

There is no reason why you cannot use the FSF GNAT, I use this instead of GPL GNAT for the same reason. Plus I think that GPL is not right for libs.

Luke.

Re: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

Luke A. Guest <laguest@archeia.com> writes:

> Peter Chapin <PChapin@vtc.vsc.edu> wrote:
>
>> IDE interact with existing compilers? Ada, in particular, does have
>> an ASIS standard that can guide, to some extent, the design of
>> abstract program representations.
>
> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
> extensions, do you have links?

GCC 4.8 supports ASIS to the extent that this

   package Ada2012 is
      subtype Even is Natural with Dynamic_Predicate => Even mod 2 = 0;
   end Ada2012;

translates (using ASIS GPL 2012 and my ASIS2XML) to

    <unit_declaration>
      <package_declaration>
        <defining_identifier>Ada2012</defining_identifier>
        <subtype_declaration>
          <defining_identifier>Even</defining_identifier>
          <subtype_indication>
            <identifier>Natural</identifier>
          </subtype_indication>
          <aspect_specification>
            <identifier>Dynamic_Predicate</identifier>
            <function_call prefixed="false">
              <parameter_association>
                <function_call prefixed="false">
                  <parameter_association>
                    <identifier>Even</identifier>
                  </parameter_association>
                  <operator_symbol>"mod"</operator_symbol>
                  <parameter_association>
                    <integer_literal>2</integer_literal>
                  </parameter_association>
                </function_call>
              </parameter_association>
              <operator_symbol>"="</operator_symbol>
              <parameter_association>
                <integer_literal>0</integer_literal>
              </parameter_association>
            </function_call>
          </aspect_specification>
        </subtype_declaration>
      </package_declaration>
    </unit_declaration>

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

Simon Wright <simon@pushface.org> wrote:
> Luke A. Guest <laguest@archeia.com> writes:
> 
>> Peter Chapin <PChapin@vtc.vsc.edu> wrote:
>> 
>>> IDE interact with existing compilers? Ada, in particular, does have
>>> an ASIS standard that can guide, to some extent, the design of
>>> abstract program representations.
>> 
>> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
>> extensions, do you have links?
> 
> GCC 4.8 supports ASIS to the extent that this
> 
>    package Ada2012 is
>       subtype Even is Natural with Dynamic_Predicate => Even mod 2 = 0;
>    end Ada2012;

So the Ada 2012 extensions are in that package?

No offence, but I have no idea what I'm looking at (the XML stuff).

Re: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

Luke A. Guest <laguest@archeia.com> writes:

> Simon Wright <simon@pushface.org> wrote:
>> Luke A. Guest <laguest@archeia.com> writes:
>> 
>>> Peter Chapin <PChapin@vtc.vsc.edu> wrote:
>>> 
>>>> IDE interact with existing compilers? Ada, in particular, does have
>>>> an ASIS standard that can guide, to some extent, the design of
>>>> abstract program representations.
>>> 
>>> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
>>> extensions, do you have links?
>> 
>> GCC 4.8 supports ASIS to the extent that this
>> 
>>    package Ada2012 is
>>       subtype Even is Natural with Dynamic_Predicate => Even mod 2 = 0;
>>    end Ada2012;
>
> So the Ada 2012 extensions are in that package?
>
> No offence, but I have no idea what I'm looking at (the XML stuff).

Um. Sorry.

I wrote that package to use one of the Ada 2012 extensions
(aspects). The XML demonstrates that GNAT's internal representation, as
well as supporting aspects (a given), is exported to the ASIS
environment in a usable way: the fact you can see <aspect_specification>
in the output indicates (to me!) that there is an enumeration literal
An_Aspect_Specification in the GNAT ASIS library.

Likewise, after further invesitigation, An_Expression_Function_Declaration.

Of course this is all GNAT-specific; I don't know what the success rate
is for AdaCore implementations to end up as ASIS specs, or whether the
ASIS folks are actively considering updates for Ada 2012.

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

Simon Wright <simon@pushface.org> wrote:
> I wrote that package to use one of the Ada 2012 extensions
> (aspects). The XML demonstrates that GNAT's internal representation, as
> well as supporting aspects (a given), is exported to the ASIS
> environment in a usable way: the fact you can see <aspect_specification>
> in the output indicates (to me!) that there is an enumeration literal
> An_Aspect_Specification in the GNAT ASIS library.
>

Ok

> Likewise, after further invesitigation, An_Expression_Function_Declaration.
> 
> Of course this is all GNAT-specific; I don't know what the success rate
> is for AdaCore implementations to end up as ASIS specs, or whether the

Yeah I don't know.

> ASIS folks are actively considering updates for Ada 2012.

They are actively working on it as I asked in this group months ago as I
was considering including what I could in my implementation, but at this
rate Ada 2020 will be out before ASIS 2012.

I could trawl through the ASIS issues but I don't think the new stuff is
public.

Luke

Re: Kickstarter for beginning work on a new open-source Compiler

[J-P. Rosen]

Le 20/03/2014 14:22, Simon Wright a écrit :
> Of course this is all GNAT-specific; I don't know what the success rate
> is for AdaCore implementations to end up as ASIS specs, or whether the
> ASIS folks are actively considering updates for Ada 2012.

Since there is currently only one implementation of Ada 2012, and since
this implementation's ASIS is following the compiler, the decision was
taken that the only sensible path was to let Gnat do the work, and
standardize on that.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Robert A Duff]

"Randy Brukardt" <randy@rrsoftware.com> writes:

>...I don't know of any Ada frontends not 
> written in Ada.)

The AdaMagic front end is written primarily in C, although I wrote
an optimization pass for it in Ada when I was at Intermetrics.
The run-time system is written in Ada.

AdaMagic is used by Green Hills, ADI, and others.

If I were writing an Ada compiler from scratch, I would write it in Ada,
using GNAT at first, and then bootstrap.  Bootstrapping removes any
licensing concerns -- you can use whatever license you want for your own
work.

Of course, writing an Ada compiler and an IDE is many, many
years of work, as has been pointed out.

- Bob

Re: Kickstarter for beginning work on a new open-source Compiler

[Robert A Duff]

Simon Wright <simon@pushface.org> writes:

> Luke A. Guest <laguest@archeia.com> writes:
>> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
>> extensions, do you have links?

The latest GNAT Pro ASIS fully supports Ada 2012.  I don't know if that
has made it into the GPL version yet.

It will likely be updated to support Ada 2022 (or whatever it will be)
when that comes along.

> translates (using ASIS GPL 2012 and my ASIS2XML) to

I didn't know about your ASIS2XML project until now.

Do you know about gnat2xml?  It is a similar tool produced by AdaCore.
(I wrote it.)  It is based on ASIS, and supports Ada 2012.
Looking at:

http://gnat-asis.sourceforge.net/pmwiki.php/Main/ASIS2XML

I see some differences:

gnat2xml has cross-links.  E.g. each name points to the declaration
it denotes, and each expression points to its type.

There is an XML schema, automatically generated by an ASIS-based tool
called gnat2xsd.

Each XML element has a "source location", which tells you the starting
and ending line and column numbers for the corresponding source text.
The root of the tree has various information, including the name
of the source file.
There is also a mode in which gnat2xml generates XML interspersed
with Ada source text, including comments.

I think XML is horrible.  But it has the advantage of being standard,
and everybody uses it, and there are all sorts of useful XML-based
tools out there.

- Bob

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dmitry A. Kazakov]

On Thu, 20 Mar 2014 10:55:39 -0700, Shark8 wrote:

> Fair points; but it still seems wrongheaded to treat the program-source 
> as mere text unless absolutely needed.

It is *absolutely* needed in order to keep it formal.

> As someone said, text is the 
> lowest common denominator... which is an absolutely stupid restriction 
> when it comes to talking about tools; if everybody stuck to that 
> ideology we'd all have vi or Notepad as our "standard programming editor".

Maybe, but to get rid of this ideology you need to roll up a theory of
formal languages based on an alphabet of graphics, scents, gestures,
sounds, whatever you wished to replace traditional alphabets, or, possibly,
invent an idea of a formal language with no alphabet at all. Good luck with
that.

http://en.wikipedia.org/wiki/Formal_language

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 19-Mar-14 15:28, Randy Brukardt wrote:
> "Shark8" <onewingedshark@gmail.com> wrote in message
> news:0d9343e9-6190-46b0-a313-bc33ed17f28d@googlegroups.com...
> ...
>> But storing it as unprocessed text means that you [well, your
>> computer/tools] have to repeat a lot of work (e.g. parsing) again and
>> again. "Moving that processing to the outer loop" can reduce that, and
>> given the advantages of working w/ meaningful-data vs. generalized-text
>> it seems like a reasonable thing to do.
>
> *Seems* reasonable, but actually is just premature optimization.
>
> Computers have gotten amazingly fast these days -- a lot of the design
> decisions that we made with Janus/Ada to reduce compilation time and storage
> requirements don't do much today.
>
> And remember that an IDE needs human-level response times. On a modern
> computer, one can do a heck of a lot in between keypresses or mouse
> movements. On top of that, parsing is relatively easy and cheap. Parsing is
> one of the cheaper phases of a compiler, and it's dubious that it would be
> worth a complex (and likely to be much more fragile) data structure in order
> to save that small amount of time. Especially with the other costs of going
> away from standard text representations.

Fair points; but it still seems wrongheaded to treat the program-source 
as mere text unless absolutely needed. As someone said, text is the 
lowest common denominator... which is an absolutely stupid restriction 
when it comes to talking about tools; if everybody stuck to that 
ideology we'd all have vi or Notepad as our "standard programming editor".

Freeing the tools from the concerns of text (and files/filesystems) so 
they can concentrate on the job they're supposed to be doing is also one 
of the points I mention... this applies to programmers, too. (If you 
hate the company's officially approved style, there should be no reason 
whatsoever that the editor couldn't automatically translate between your 
preferred and the company's official style; if you're storing the code 
as an AST [or similar] then you have to handle that transition 
(txt->AST, AST->txt) anyway.... and switching styles should have no 
impact as "changes" in the Version-control system.)

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 19-Mar-14 14:04, Alan Browne wrote:
> On 2014.03.18, 19:23 , Shark8 wrote:
>> It is my belief that a new, non-GNAT, open-source [and free] Ada 2012
>> translator would be a good thing for both the Ada community and the
>> general programming population -- this without even breaking from the
>> traditional approaches. However, I think that a good, quality IDE/PSE
>> could be quite advantageous; offering better project-management,
>> documentation, verification, versioning, and correctness/consistency
>> checking.
>>
>> The working-copy of the proposal is here:
>> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit?usp=sharing
>>
>
> 0. Why is your exec summary so detailed?

Because it's a working copy and I still have a lot to do, esp. WRT 
describing the tools-set.

> 1. Delphi?   Why not in Ada?

Answered upthread: mostly possible issues in licensing and my rotten 
luck getting DB bindings to compile/link correctly.

> 2. Your subject is "... a new open-source Compiler".  Your project is
> not so much about a compiler.

Well, true: it's about a whole PSE (Programming Support Environment), 
but the Ada 83 Library is a decent step in that direction already.

> 3. Text.  Nothing wrong with that.  You can ridicule it all you like
> with quotations, but it is the lowest common denominator.

That's a horrid argument; if we did that with editors we'd be using vi 
and Notepad (actually probably not even Notepad, as its interface is a 
direct result of Larry Tesler's crusade against modes, which was [then] 
the common thing in computers.)

> Strawmen arguments like EOL and character sets is just distraction - such are
> easily fixed/translated if not handled automatically.

And yet they are relevant in that they are (sometimes surprisingly) more 
difficult to fix than you would initially think; there was one incident 
with CSV exported from Excel on PC vs Excel on a Mac that lead to 
some... interesting behavior in an import procedure.

> 4. References to alleged poor design practices at Toyota are specious
> and irrelevant.  The Sony reference too.  (You're employing "scare"
> marketing.  Bzzzt.).

Really?
Correctness should be a concern for programmers; could Toyota's errors 
have been made using Ada... *sure*, but some of them would have been 
easy to avoid (e.g. using protected objects for shared values.) Plus, I 
think Toyota would disagree that it's irrelevent, seeing how they just 
$1.2 bn settlement. See: 
http://www.politico.com/story/2014/03/toyota-settlement-doj-104809.html

> 5. This whole project, to me, puts the programmer too far away from the
> source code.  Buries it.  That is not a good objective.

That's one problem I'm trying to address, it's not about burring the 
source, but getting closer to the [underlying] structure and ideas that 
the code is expressing. An example would be CASE statements, the 
language mandates that they have complete coverage (individually or via 
OTHERS) so would it be putting the programmer "too far away from the 
source" to allow something like "right-click > show as table" to convert 
the [possibly nested] CASE statement into a decision table? I mean we 
already have the mandate that all the possibilities must be covered.

Or, imagine having the ability to visually tinker with a [sub]type; say 
you have Type Voltage is new Natural range 0 .. 220. that you could have 
represented with two sliders in the same channel (for 'First and 'Last) 
and possibly a tab for indicating [or specifying] the 
default/uninitialized value. (Perhaps packaging Annex H's "Pragma 
Normalize_Scalars" value right there with the type.)

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 19-Mar-14 15:03, Randy Brukardt wrote:
> "Peter Chapin" <PChapin@vtc.vsc.edu> wrote in message
> news:fKSdnQj47oHXCLTO4p2dnAA@giganews.com...
> ...
>> I ask this because I have a pet project of my own to write an Ada 2012
>> compiler from scratch.
>
> Ah, another delusional soul. ;-) Take it from someone who seriously followed
> that path -- there be dragons. :-)

Well, at least we'll have company, right?

> For one thing, if you're at all  successful, you'll be stuck there for the
> rest of your working life. And to get far enough to be at all successful,
> you'll have to figure out how to deal with lovely things like resolution,
> visibility, and tyranny of interfaces.

Visibility is an important thing, as is resolution -- though maybe they 
are more on the complex side of things than we'd like.

With the "tyranny of interfaces" do you mean in-general like like a 
generic's formal parameters and a subprogram's signature? Or do you mean 
the construct of the 'interface' keyword?

> Odds are, you'll never get far enough to work on anything interesting.

This is true.

Re: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

Robert A Duff <bobduff@shell01.TheWorld.com> writes:

> Simon Wright <simon@pushface.org> writes:
>
>> Luke A. Guest <laguest@archeia.com> writes:
>>> ASIS doesn't have Ada 2012 support, yet. Unless there are unofficial
>>> extensions, do you have links?
>
> The latest GNAT Pro ASIS fully supports Ada 2012.  I don't know if
> that has made it into the GPL version yet.

GNAT & ASIS GPL 2013 seem to do a pretty good job.

>> translates (using ASIS GPL 2012 and my ASIS2XML) to
>
> I didn't know about your ASIS2XML project until now.
>
> Do you know about gnat2xml?  It is a similar tool produced by AdaCore.
> (I wrote it.)  It is based on ASIS, and supports Ada 2012.

Yes, I saw it in ASIS GPL 2013. I was specially interested in the
ability to re-generate code from (possibly-modified) XML; but perhaps
this is only for testing purposes?

I was somewhat put off by what seemed to be unneeded verbosity: the code
fragment above starts

<compilation_unit 
  unit_kind="A_Package"
  unit_class="A_Public_Declaration"
  unit_origin="An_Application_Unit"
  unit_full_name="Ada2012"
  def_name="Ada2012"
  source_file="ada2012.ads">
   <sloc line="1" col="1" endline="5" endcol="12"/>
   <context_clause_elements_ql>
   </context_clause_elements_ql>
   <unit_declaration_q>
      <package_declaration>
         <sloc line="1" col="1" endline="5" endcol="12"/>
         <names_ql>
            <defining_identifier 
              def_name="Ada2012" def="ada://package/Ada2012-1:9" type="null">
               <sloc line="1" col="9" endline="1" endcol="15"/>
            </defining_identifier>
         </names_ql>
         <aspect_specifications_ql>
         </aspect_specifications_ql>

vs

<asis>
  <compilation_unit
    file="/Users/simon/sf/gnat-asis/tools/asis2xml/testing/ada2012.ads"
    unit="Ada2012">
    <context_clauses></context_clauses>
    <unit_declaration>
      <package_declaration>
        <defining_identifier>Ada2012</defining_identifier>

I guess you use the _ql in <context_clause_elements_ql/> because that's
the result of a Query called Context_Clause_Elements that returns a
List; I didn't think the user needed to know that, so used just
<context_clauses/> (and I wonder whether it'd have been better to omit
an empty context clause list altogether).

This exercise has revealed a bug: I've left out all mention of private
parts! That's going to take some fixing ...

> Looking at:
>
> http://gnat-asis.sourceforge.net/pmwiki.php/Main/ASIS2XML
>
> I see some differences:
>
> gnat2xml has cross-links.  E.g. each name points to the declaration
> it denotes, and each expression points to its type.

That wasn't necessary for the original motivations for ASIS2XML (one of
which you could now do using AdaControl, I'm sure).

> There is an XML schema, automatically generated by an ASIS-based tool
> called gnat2xsd.

Haven't seen that.

> Each XML element has a "source location", which tells you the starting
> and ending line and column numbers for the corresponding source text.

I can see where that would be useful! but not needed for my use case.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[gautier_niouzes]

Good luck with this ambitious project. A challenge is that at some point the AST knows too much about the program. I've developed a similar system 25 years ago (in Turbo Pascal!) for Ada 83. The pros: no more parsing, compilation is straightforward, links are readily available, the system is able to manage the layout itself, to indent etc. . The cons: formatting rigidity, and if the programer needs to make a big change, use another package, types and so on, plus all depending changes, he needs to have his program "incorrect" for a while. In my system, it meant export to text, rework the text and then reimport the changed text. Too cumbersome - and tools like GPS offer nowadays navigation tools and autocomplete even in the middle of a such a rework, thanks to smart guessing, and all that at text level...
_________________________
Gautier's Ada programming
http://gautiersblog.blogspot.com/search/label/Ada

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:8uHWu.228$ui6.50@fx27.iad...
> On 19-Mar-14 15:03, Randy Brukardt wrote:
...
>> For one thing, if you're at all  successful, you'll be stuck there for 
>> the
>> rest of your working life. And to get far enough to be at all successful,
>> you'll have to figure out how to deal with lovely things like resolution,
>> visibility, and tyranny of interfaces.
>
> Visibility is an important thing, as is resolution -- though maybe they 
> are more on the complex side of things than we'd like.
>
> With the "tyranny of interfaces" do you mean in-general like like a 
> generic's formal parameters and a subprogram's signature? Or do you mean 
> the construct of the 'interface' keyword?

The interface construct itself. The issues with actually implementing 
multi-dispatching are quite daunting, especially given the other 
requirements of Ada. It clearly can be done; whether I could actually do it 
is a much more interesting question (particularly without abandoning other 
properties of our implementation).

                          Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Stephen Leake]

Shark8 <onewingedshark@gmail.com> writes:

> One reason to use Delphi rather than Ada is licensing; IIUC the license 
> for GNAT would prohibit development of a commercial product and 
> [probably] the development of something that /would be/ used in a 
> commercial product -- I simply do not wish to burden users of this 
> system in that manner.

You are confusing "making money" with "distributing source code".
AdaCore makes money and distributes source code. Other business plans
differ.

>> 2) The Rationale section "Why Write an Ada Compiler?" provides a
>>     justification for writing an IDE plugin, not an Ada compiler.
>>
>>     You can easily extract text from the database and feed it to gnat, or
>>     any other Ada compiler.
>
> True.
> But storing it as unprocessed text means that you [well, your 
> computer/tools] have to repeat a lot of work (e.g. parsing) again and 
> again. 

Parsing is very cheap (Emacs Ada mode does it for indentation); the rest
of the compiler is hard.

GNAT is open source; you might be able to split out the parsing phase
from the rest, and use that parsed representation as the interface
between the IDE and the compiler (I have no idea if the GNAT Ada front
end is divided that way).

>>      b) Prevents people checking in code so colleagues can answer the
>>         question "why doesn't this compile"?
>>
>
> Non-working code should be kept out of the [main] code-base; this 
> situation can be handled with a chat/message-board (or similar) sort of 
> functionality -- There's *no* need to pollute your revisions with code 
> that cannot work. 

Not true; sometimes the reason it doesn't compile is related to some
other change you made. So you need _all_ of the code. And that's what CM
system branches are for.

What is in the main branch of your CM is different than what is in some
developer's branch; controlling the flow from developer branches to the
main (release) branch is a CM issue, not an IDE source code
represntation issue.

>>      c) Prevents writing skeletons; something I do when starting a
>>         totally new project.
>
> Howso?
> You can still have the procedure's "is null" spec; and Delphi itself has 
> been generating empty subprograms forever.

Emacs Ada mode skeletons don't compile in GNAT, but the indentation
parser accepts them. For example, 'case foo C-e' expands to:

   case Foo is
   when =>
   end case;

I can store that in a file, and since it doesn't compile, I'm reminded
to finish it.

Can I store that in your database?

>> 6) What is your business plan? You are proposing to directly compete
>>     with AdaCore; it is not at all clear from the proposal that you
>>     understand what that means.
>
> I understand that AdaCore mainly deals in support not, strictly 
> speaking, the compiler itself; 

Yes, because that's the way to make money. They use the money to improve
the compiler and associated tools.

> but even if this weren't the case, I'm of
> the opinion that the programming community could benefit from another 
> freely available implementation... especially one which doesn't share 
> the same codebase.

So you say. I have yet to hear why you think that.

-- 
-- Stephe

Re: Kickstarter for beginning work on a new open-source Compiler

[Lucretia]

On Thursday, 20 March 2014 14:17:26 UTC, J-P. Rosen  wrote:

> Since there is currently only one implementation of Ada 2012, and since
> this implementation's ASIS is following the compiler, the decision was
> taken that the only sensible path was to let Gnat do the work, and
> standardize on that.

Thanks, at least I know where to look for the specs. Hopefully though, the ASIS WG will come out with the proper specs soon.

And FYI, another reason why we need another competing implementation :D

Luke.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Lucretia]

On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
> On 19-Mar-14 14:04, Alan Browne wrote:
> > On 2014.03.18, 19:23 , Shark8 wrote:

> > 1. Delphi?   Why not in Ada?
> 
> Answered upthread: mostly possible issues in licensing and my rotten 
> luck getting DB bindings to compile/link correctly.

Really? You couldn't get postgres-ada to compile? Really easy. If you're talking gnatcoll, then yeah, that's a complete bitch, don't think anyone's been too successful there.

TBH, using Ada with GNAT and then bootstrapping with your compiler is the way to go.

Luke.

Re: Kickstarter for beginning work on a new open-source Compiler

[J-P. Rosen]

Le 21/03/2014 03:13, Lucretia a écrit :
>  Hopefully though, the ASIS WG will come out with the proper specs soon.
That's the problem: there is no ASIS WG any more. The ARG tried to take
over, but it's resources are limited, and better used to the maintenance
of the language.

> And FYI, another reason why we need another competing implementation :D
As far as ASIS is concerned, the Gela project was promising. The idea
was to have a compiler targeting ASIS, and then make code generation
from ASIS. It was sufficiently advanced that AdaControl compiled with it
(except for Gnat extensions for Ada 2005/2012), and even passed a good
part of its test suite.

Unfortunately, the author turned to other occupations. It would be nice
to have volunteers taking over this project.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: Kickstarter for beginning work on a new open-source Compiler

[Lucretia]

On Friday, 21 March 2014 05:23:35 UTC, J-P. Rosen  wrote:
> Le 21/03/2014 03:13, Lucretia a écrit :
> 
> >  Hopefully though, the ASIS WG will come out with the proper specs soon.
> 
> That's the problem: there is no ASIS WG any more. The ARG tried to take
> over, but it's resources are limited, and better used to the maintenance
> of the language.

Well that's a shame, could we possibly have:

1) http://www.sigada.org/wg/asiswg/ updated to reflect ASIS WG is dead?
2) Have any private documents made public so that we or others who want to try to implement it, can do? That is, if there are any that are still private.
 
> > And FYI, another reason why we need another competing implementation :D
> As far as ASIS is concerned, the Gela project was promising. The idea

Gela was part of Tendra which was abandoned by the UK government (or whoever created it) ages ago.

> was to have a compiler targeting ASIS, and then make code generation
> from ASIS. It was sufficiently advanced that AdaControl compiled with it
> (except for Gnat extensions for Ada 2005/2012), and even passed a good
> part of its test suite.
> 
> Unfortunately, the author turned to other occupations. It would be nice
> to have volunteers taking over this project.

Maybe.

Luke.

Re: Kickstarter for beginning work on a new open-source Compiler

[J-P. Rosen]

Le 21/03/2014 06:33, Lucretia a écrit :
>> That's the problem: there is no ASIS WG any more. The ARG tried to
>> take
>>> over, but it's resources are limited, and better used to the
>>> maintenance of the language.
> Well that's a shame, could we possibly have:
> 
> 1) http://www.sigada.org/wg/asiswg/ updated to reflect ASIS WG is
> dead?
If you look closely at the page, it says that ISO/IEC 15291:1999 has
just been issued...

> 2) Have any private documents made public so that we or others who
> want to try to implement it, can do? That is, if there are any that
> are still private.
> 
The de-facto standard is now Asis-for-Gnat, which is public.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

Stephen Leake <stephen_leake@stephe-leake.org> writes:

> Emacs Ada mode skeletons don't compile in GNAT, but the indentation
> parser accepts them. For example, 'case foo C-e' expands to:
>
>    case Foo is
>    when =>
>    end case;

The Rational Environment used to include recognisable and storable
markers in such cases: for example {statement}. As far as I remember
they were displayed in inverse video to make them stand out!

Re: Kickstarter for beginning work on a new open-source Compiler

[Robert A Duff]

Simon Wright <simon@pushface.org> writes:

> Yes, I saw it in ASIS GPL 2013. I was specially interested in the
> ability to re-generate code from (possibly-modified) XML; but perhaps
> this is only for testing purposes?

That's the xml2gnat tool, which back-translates XML into Ada.
It was originally developed for testing purposes:  Ada-->XML--Ada
ought to produce an Ada program that has identical output to the
original.

Then I rewrote the pretty-printer (gnatpp) to use that same Ada-generating
code.  gnatpp does not use XML, but almost all of the code in xml2gnat is
shared by gnatpp.

You could use xml2gnat on modified XML, but you would have to make sure
the XML looks like what gnat2xml would generate from some legal Ada.
Validating it against the schema using xmllint would help with that.
But nobody at AdaCore has ever done that; we use xml2gnat purely for
testing gnat2xml.  For example, we run all the executable ACATS tests
that way (translate the test into XML, then back into Ada, then compile
and run the generated Ada, and the output should be identical
to the output of the original ACATS test, with the usual
"===== PASSED ================" message).

The first version of xml2gnat left out all the comments, which aren't
needed for the above kind of testing.  But of course gnatpp can't
leave out comments, so now xml2gnat also includes the comments,
using the same shared code.

> I was somewhat put off by what seemed to be unneeded verbosity: the code
> fragment above starts
> ...

Looks like the gnat2xml output contains more information, so I'm not
surprised it's more verbose.  The source locations, for example,
take up a lot of space.

> I guess you use the _ql in <context_clause_elements_ql/> because that's
> the result of a Query called Context_Clause_Elements that returns a
> List; ...

Yes, "_q" is for "query returning a non-list", and "_ql" is for
"query returning a list".  All the names are taken directly from
ASIS names, with systematic changes (like removing the annoying
"A_" or "An_" from element type names).

> ...I didn't think the user needed to know that, so used just
> <context_clauses/> (and I wonder whether it'd have been better to omit
> an empty context clause list altogether).

Well, leaving out empty things makes it more compact, but probably
makes XML-processing tools have more special cases.

> This exercise has revealed a bug: I've left out all mention of private
> parts! That's going to take some fixing ...

Interesting.  ;-)

- Bob

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 20-Mar-14 19:18, Lucretia wrote:
> On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
>> On 19-Mar-14 14:04, Alan Browne wrote:
>>> On 2014.03.18, 19:23 , Shark8 wrote:
>
>>> 1. Delphi?   Why not in Ada?
>>
>> Answered upthread: mostly possible issues in licensing and my rotten
>> luck getting DB bindings to compile/link correctly.
>
> Really? You couldn't get postgres-ada to compile? Really easy. If you're talking gnatcoll, then yeah, that's a complete bitch, don't think anyone's been too successful there.

I tried three or four bindings; I'm not sure if I did postgres-ada, but 
yeah... gnatcoll. It's the most memorable, and not in a good way.


> TBH, using Ada with GNAT and then bootstrapping with your compiler is the way to go.

That's something I was considering doing; particularly for a possible 
commercial offering for a fully validated/verified compiler.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

[-- Attachment #1: Type: text/plain, Size: 1719 bytes --]

On 20-Mar-14 14:35, gautier_niouzes@hotmail.com wrote:
> Good luck with this ambitious project.

Thank you.

> A challenge is that at some point the AST knows too much about the program.

Ah, you mean things like visibility and private/public access to things, 
right?

> I've developed a similar system 25 years ago (in Turbo Pascal!) for Ada 83.

Heh! so then this is in a lot of ways a re-hash of your work. :D
If you'd like to share tips/, info, or even stories about it I'd love to 
hear.

> The pros: no more parsing, compilation is straightforward, links are readily available,
> the system is able to manage the layout itself, to indent etc.

Much the same that I was thinking.

> The cons: formatting rigidity, and if the programer needs to make a big change,  use
> another package, types and so on, plus all depending changes, he needs to have his
> program "incorrect" for a while. In my system, it meant export to text, rework the
> text and then reimport the changed text. Too cumbersome - and tools like GPS offer
> nowadays navigation tools and autocomplete even in the middle of a such a rework,
> thanks to smart guessing, and all that at text level...

Ah, I see. The export/edit/import is certainly a way to handle that -- I 
was leaning towards a sort of buffer/workspace methodology, keeping the 
inconsistent things separated out of the [main/shared] system.

One of the references "Workspaces and Experimental Databases: Automated 
Support for Software Maintenance and Evolution" (URI: 
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.26.2533&rep=rep1&type=pdf 
) shows an interesting way to use a hierarchical structuring of 
databases to handle consistency/correctness for a project.

[-- Attachment #2: Workspaces and Experimental Databases.pdf --]
[-- Type: application/pdf, Size: 40688 bytes --]

Re: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Lucretia" <laguest9000@googlemail.com> wrote in message 
news:2e025cd0-76c9-4c42-a635-b8e2876e5bff@googlegroups.com...
...
>Well that's a shame, could we possibly have:
...
>2) Have any private documents made public so that we or others who want
> to try to implement it, can do? That is, if there are any that are still 
> private.

No. ASIS (unlike the Ada standard) is owned by ISO, and we can't give away 
their "property". In any case, the updated ASIS standard draft was 
effectively rejected by the ASIS implementors (by ignoring it and doing 
their own thing). Vendors have told us outright that they don't think there 
is any value to an ASIS standard and that they won't support one if it is 
made. As such, there is no point in putting any more effort into it.

I suggest considering ASIS past Ada 95 as implementation-specific. Perhaps 
someday there will be agreement on a way forward, but it really only matters 
for people that want to port ASIS tools. At this point, that community 
appears to exist solely of J-P Rosen -- everybody else seems to be using 
GNAT ASIS only (or one of the Atego ASIS implementations only). So there's 
little point to a standard.

If you disagree, then you need to form your own ASIS WG, put pressure on 
ASIS vendors to define a consistent set of extensions and ways to plug the 
many holes in the ASIS standard, and then it's likely that the energy to 
actually update the standard will materialize. The key here is the pressure 
on vendors from customers -- they have to see a benefit from having a 
standard -- they don't see that now.

                                 Randy.

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

"Randy Brukardt" <randy@rrsoftware.com> wrote:

> their "property". In any case, the updated ASIS standard draft was 
> effectively rejected by the ASIS implementors (by ignoring it and doing 
> their own thing). Vendors have told us outright that they don't think there 

In that case there's no point in bothering with ASIS. Good to know.

Thanks,
Luke

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[J-P. Rosen]

Le 21/03/2014 22:51, Shark8 a écrit :
>> TBH, using Ada with GNAT and then bootstrapping with your compiler is
>> the way to go.
> 
> That's something I was considering doing; particularly for a possible
> commercial offering for a fully validated/verified compiler.

FYI, Gnat was always written in Ada, bootstrapped from the Alsys compiler.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Jeffrey Carter]

On 03/21/2014 10:48 PM, J-P. Rosen wrote:
>
> FYI, Gnat was always written in Ada, bootstrapped from the Alsys compiler.

IIRC, the Alsys compiler was also written in Ada, though initially an Ada-to-PL1 
translator was used until the compiler could compile itself.

-- 
Jeff Carter
"That was the most fun I've ever had without laughing."
Annie Hall
43

Re: Kickstarter for beginning work on a new open-source Compiler

[Tero Koskinen]

22.3.2014 0:51, Randy Brukardt wrote:
> I suggest considering ASIS past Ada 95 as implementation-specific. Perhaps
> someday there will be agreement on a way forward, but it really only matters
> for people that want to port ASIS tools. At this point, that community
> appears to exist solely of J-P Rosen -- everybody else seems to be using
> GNAT ASIS only (or one of the Atego ASIS implementations only). So there's
> little point to a standard.

There is also GELA ASIS:
http://gela.ada-ru.org/gela_asis_ug

which is used by one of the QtAda projects (http://www.qtada.com/).

>                                   Randy.

Yours,
  Tero

Re: Kickstarter for beginning work on a new open-source Compiler

[J-P. Rosen]

Le 22/03/2014 07:27, Tero Koskinen a écrit :
> There is also GELA ASIS:
> http://gela.ada-ru.org/gela_asis_ug
> 
> which is used by one of the QtAda projects (http://www.qtada.com/).
Unfortunately, still incomplete and not making progresses any more.


-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dmitry A. Kazakov]

On Fri, 21 Mar 2014 14:51:03 -0700, Shark8 wrote:

> I tried three or four bindings;

Use ODBC. DB-specific bindings make no sense, most of the time. The only
exceptions could be bindings to a single-file DB like SQLite, Berkeley
Kyoto Cabinet etc.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Ludovic Brenta]

"J-P. Rosen" <rosen@adalog.fr> writes:
> Le 21/03/2014 22:51, Shark8 a écrit :
>>> TBH, using Ada with GNAT and then bootstrapping with your compiler
>>> is the way to go.
>> 
>> That's something I was considering doing; particularly for a possible
>> commercial offering for a fully validated/verified compiler.
>
> FYI, Gnat was always written in Ada, bootstrapped from the Alsys
> compiler.

Really?  I always thought it was bootstrapped from Ada/Ed?  So what's
the relationship between Ada/Ed and GNAT, apart from both being
developed at New York University?

-- 
Ludovic Brenta.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Pascal Obry]

Le samedi 22 mars 2014 à 10:14 +0100, Ludovic Brenta a écrit : 
> Really?  I always thought it was bootstrapped from Ada/Ed?  So what's
> the relationship between Ada/Ed and GNAT, apart from both being
> developed at New York University?

None, I think Ada/Ed has been a kind of test-bed and GNAT has borrowed
the good idea from Ada/Ed and avoided the mistakes.

And yes it was bootstrapped from Alsys compiler. I was there at the NYU
when the first bootstrap was conducted in 1992 :) I still remember this
magic moment!

-- 
  Pascal Obry /  Magny Les Hameaux (78)

  The best way to travel is by means of imagination

  http://v2p.fr.eu.org
  http://www.obry.net

  gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dirk Craeynest]

In article <87txaqd28v.fsf@ludovic-brenta.org>,
Ludovic Brenta  <ludovic@ludovic-brenta.org> wrote:
>"J-P. Rosen" <rosen@adalog.fr> writes:
>> FYI, Gnat was always written in Ada, bootstrapped from the Alsys
>> compiler.
>
>Really?  I always thought it was bootstrapped from Ada/Ed?

Yes, really.  The first successful bootstrap of GNAT, using the Alsys
Ada 83 compiler, was announced at the Ada-Europe conference in June
1993 in Paris (by Robert Dewar, IIRC).

And no, it wasn't by using Ada/Ed, as that was an interpreter
and didn't generate any object code or executable.  Ada/Ed did
generate some high-level intermediate representation, which was
then interpreted.

>So what's
>the relationship between Ada/Ed and GNAT, apart from both being
>developed at New York University?

You got it: both are implementations of Ada, developed at NYU.

Ada/Ed was intended as a kind of operational specification of Ada,
and was developed in parallel with the Ada 83 language.

Some more trivia...

The first Ada/Ed version was written in SETL (a programming language
based on sets), which was also interpreted.  Hence two levels
of step-by-step execution: SETL interprets Ada/Ed, which in turn
interprets your Ada program.  Clearly the result was "rather slow".

I still remember a tiny Towers-of-Hanoi demo-program we wrote, with
a basic ASCII-graphics display for the 3 stacks of disks.  With 5
disks, it took two nights and a full day to run!  (I must still have
the output file somewhere...).

Later on a second version of Ada/Ed was made available, which was
written in C.  That one was already more suitable for teaching purposes
(which was what we used it for at the Leuven university at that time).

End of trivia... ;-)

Dirk
Dirk.Craeynest@cs.kuleuven.be (for Ada-Belgium/-Europe/SIGAda/WG9 mail)

*** 19th Intl.Conf.on Reliable Software Technologies - Ada-Europe'2014
*** June 23-27, 2014 **** Paris, France **** http://www.ada-europe.org

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Niklas Holsti]

On 14-03-22 11:25 , Dirk Craeynest wrote:
> In article <87txaqd28v.fsf@ludovic-brenta.org>,
> Ludovic Brenta  <ludovic@ludovic-brenta.org> wrote:
>> "J-P. Rosen" <rosen@adalog.fr> writes:
>>> FYI, Gnat was always written in Ada, bootstrapped from the Alsys
>>> compiler.
>>
>> Really?  I always thought it was bootstrapped from Ada/Ed?
> 
> Yes, really.  The first successful bootstrap of GNAT, using the Alsys
> Ada 83 compiler, was announced at the Ada-Europe conference in June
> 1993 in Paris (by Robert Dewar, IIRC).
> 
> And no, it wasn't by using Ada/Ed, as that was an interpreter
> and didn't generate any object code or executable. 

The way you worded that suggests that Ada/Ed being an interpreter would
have prevented using it to bootstrap GNAT, but of course that is not so.
As long as *GNAT* was able to generate an executable, one could have
used Ada/Ed to execute GNAT (albeit through interpretation) to compile
the GNAT source code into an executable GNAT.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dirk Craeynest]

In article <bp5enaF87mnU1@mid.individual.net>,
Niklas Holsti  <niklas.holsti@tidorum.invalid> wrote:
>The way you worded that suggests that Ada/Ed being an interpreter would
>have prevented using it to bootstrap GNAT, but of course that is not so.
>As long as *GNAT* was able to generate an executable, one could have
>used Ada/Ed to execute GNAT (albeit through interpretation) to compile
>the GNAT source code into an executable GNAT.

You are right, of course.  Thanks for correcting.
(I don't know where my mind was when I wrote that.)

Dirk

PS: It would've take "quite" some time to bootstrap, though...

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Niklas Holsti]

On 14-03-22 15:59 , Dirk Craeynest wrote:
> In article <bp5enaF87mnU1@mid.individual.net>,
> Niklas Holsti  <niklas.holsti@tidorum.invalid> wrote:
>> The way you worded that suggests that Ada/Ed being an interpreter would
>> have prevented using it to bootstrap GNAT, but of course that is not so.
>> As long as *GNAT* was able to generate an executable, one could have
>> used Ada/Ed to execute GNAT (albeit through interpretation) to compile
>> the GNAT source code into an executable GNAT.
> 
> You are right, of course.  Thanks for correcting.
> (I don't know where my mind was when I wrote that.)
> 
> Dirk
> 
> PS: It would've take "quite" some time to bootstrap, though...

Certainly with the SETL version of Ada/Ed, yes. The C version might have
been fast enough.

But it occurs to me now that perhaps the interpreter nature of Ada/Ed
was indeed an obstacle to GNAT bootstrapping, because, AIUI, only the
front-end of GNAT is written in Ada; the rest is C/C++ from GCC. So
Ada/Ed could execute only the front-end of GNAT. A bootstrap with Ada/Ed
would have required a file-based (or piped) transfer of the intermediate
output from the front-end to the back-end. I don't know if GCC already
had some file-based intermediate representation; if not, it would have
been extra work for the GNAT team to implement one.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Ludovic Brenta]

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:
> On 14-03-22 15:59 , Dirk Craeynest wrote:
>> In article <bp5enaF87mnU1@mid.individual.net>,
>> Niklas Holsti  <niklas.holsti@tidorum.invalid> wrote:
>>> The way you worded that suggests that Ada/Ed being an interpreter
>>> would have prevented using it to bootstrap GNAT, but of course that
>>> is not so.  As long as *GNAT* was able to generate an executable,
>>> one could have used Ada/Ed to execute GNAT (albeit through
>>> interpretation) to compile the GNAT source code into an executable
>>> GNAT.
>> 
>> You are right, of course.  Thanks for correcting.  (I don't know
>> where my mind was when I wrote that.)
>> 
>> Dirk
>> 
>> PS: It would've take "quite" some time to bootstrap, though...
>
> Certainly with the SETL version of Ada/Ed, yes. The C version might
> have been fast enough.
>
> But it occurs to me now that perhaps the interpreter nature of Ada/Ed
> was indeed an obstacle to GNAT bootstrapping, because, AIUI, only the
> front-end of GNAT is written in Ada; the rest is C/C++ from GCC. So
> Ada/Ed could execute only the front-end of GNAT. A bootstrap with
> Ada/Ed would have required a file-based (or piped) transfer of the
> intermediate output from the front-end to the back-end. I don't know
> if GCC already had some file-based intermediate representation; if
> not, it would have been extra work for the GNAT team to implement one.

In the olden days, temporary files were the default mechanism that GCC
front-ends used to send their output to the back-end, for memory
allocation reasons.  There was a non-default option, "-pipe", that
allowed the front-end and the back-end to work in parallel.

Still, even the GNAT front-end has parts written in C and Ada/Ed would
not have been able to run them.  But perhaps it would have been possible
to compile those C parts to object code, using a C compiler, and call
them from the interpreted Ada parts?  Anyway, all of this is
theoretical...

-- 
Ludovic Brenta.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Stephen Leake]

Lucretia <laguest9000@googlemail.com> writes:

> On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
>> On 19-Mar-14 14:04, Alan Browne wrote:
>> > On 2014.03.18, 19:23 , Shark8 wrote:
>
>> > 1. Delphi?   Why not in Ada?
>> 
>> Answered upthread: mostly possible issues in licensing and my rotten 
>> luck getting DB bindings to compile/link correctly.
>
> Really? You couldn't get postgres-ada to compile? Really easy. If
> you're talking gnatcoll, then yeah, that's a complete bitch, don't
> think anyone's been too successful there.

I use gnatcoll for db access. There are quirks, but it works quite well.

-- 
-- Stephe

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 22-Mar-14 12:28, Stephen Leake wrote:
> Lucretia <laguest9000@googlemail.com> writes:
>
>> On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
>>> On 19-Mar-14 14:04, Alan Browne wrote:
>>>> On 2014.03.18, 19:23 , Shark8 wrote:
>>
>>>> 1. Delphi?   Why not in Ada?
>>>
>>> Answered upthread: mostly possible issues in licensing and my rotten
>>> luck getting DB bindings to compile/link correctly.
>>
>> Really? You couldn't get postgres-ada to compile? Really easy. If
>> you're talking gnatcoll, then yeah, that's a complete bitch, don't
>> think anyone's been too successful there.
>
> I use gnatcoll for db access. There are quirks, but it works quite well.

I could never get gnatcoll to work; it took a /lot/ of time/effort to 
get it so it would compiler and link... and even then it wouldn't work 
when I tried to use it.

I'm going to hazard a guess that you were using a linux-system, yes? 
(I'm on a Windows system, and the building process [IMO] seems to be 
overly dependent on the OS.)

Re: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

Robert A Duff <bobduff@shell01.TheWorld.com> writes:

>> This exercise has revealed a bug: I've left out all mention of private
>> parts! That's going to take some fixing ...
>
> Interesting.  ;-)

:-)

Now fixed.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[erlo]

On 03/21/2014 09:17 AM, Simon Wright wrote:
> Stephen Leake <stephen_leake@stephe-leake.org> writes:
> 
>> Emacs Ada mode skeletons don't compile in GNAT, but the indentation
>> parser accepts them. For example, 'case foo C-e' expands to:
>>
>>    case Foo is
>>    when =>
>>    end case;
> 
> The Rational Environment used to include recognisable and storable
> markers in such cases: for example {statement}. As far as I remember
> they were displayed in inverse video to make them stand out!
> 
The problem was (at least for the OS/9 cross) that the programs would
compile and link, resulting in an exception (Illegal program, I think)
when you tried to execute the code.

Erlo

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Simon Wright]

erlo <erlo@valid.not> writes:

> On 03/21/2014 09:17 AM, Simon Wright wrote:
>> Stephen Leake <stephen_leake@stephe-leake.org> writes:
>> 
>>> Emacs Ada mode skeletons don't compile in GNAT, but the indentation
>>> parser accepts them. For example, 'case foo C-e' expands to:
>>>
>>>    case Foo is
>>>    when =>
>>>    end case;
>> 
>> The Rational Environment used to include recognisable and storable
>> markers in such cases: for example {statement}. As far as I remember
>> they were displayed in inverse video to make them stand out!
>> 
> The problem was (at least for the OS/9 cross) that the programs would
> compile and link, resulting in an exception (Illegal program, I think)
> when you tried to execute the code.

AFAICR the R1000 wouldn't do (the equivalent of) object code generation
- "promoting to the code state"? - with placeholders present. But it's a
while back!

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Stephen Leake]

Shark8 <OneWingedShark@gmail.com> writes:

> On 22-Mar-14 12:28, Stephen Leake wrote:
>> Lucretia <laguest9000@googlemail.com> writes:
>>
>>> On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
>>>> On 19-Mar-14 14:04, Alan Browne wrote:
>>>>> On 2014.03.18, 19:23 , Shark8 wrote:
>>>
>>>>> 1. Delphi?   Why not in Ada?
>>>>
>>>> Answered upthread: mostly possible issues in licensing and my rotten
>>>> luck getting DB bindings to compile/link correctly.
>>>
>>> Really? You couldn't get postgres-ada to compile? Really easy. If
>>> you're talking gnatcoll, then yeah, that's a complete bitch, don't
>>> think anyone's been too successful there.
>>
>> I use gnatcoll for db access. There are quirks, but it works quite well.
>
> I could never get gnatcoll to work; it took a /lot/ of time/effort to
> get it so it would compiler and link... and even then it wouldn't work
> when I tried to use it.
>
> I'm going to hazard a guess that you were using a linux-system, yes?
> (I'm on a Windows system, and the building process [IMO] seems to be
> overly dependent on the OS.)

I use debian, red hat, and windows; and both gnatpro and gnat gpl.

Never had a problem building and installing gnatcoll.

I do have cygwin installed on Windows; I'm not sure if that's the key or
not. 

-- 
-- Stephe

Re: Kickstarter for beginning work on a new open-source Compiler

[Luke A. Guest]

> (2) have the second be written in Ada 2012 (probably w/ SPARK
> verification/proving) -- hopefully w/ all annexes (though that's a LOT of
> work) -- and this would be the commercial product, then
> (3) have that compiler/PSE/IDE available for implementing a verified/proved OS.
> 
> Like I said upthread; I believe that we /need/ our foundational tools to
> be without error... and that means investing in verification & correctness checking.

I had a quick look at spark 2012, and it stated that anything with pointers
can't be reliably verified. Good luck with that.

I think the spark stuff is really for embedded projects only.

Luke

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 23-Mar-14 18:16, Stephen Leake wrote:
> Shark8 <OneWingedShark@gmail.com> writes:
>
>> On 22-Mar-14 12:28, Stephen Leake wrote:
>>> Lucretia <laguest9000@googlemail.com> writes:
>>>
>>>> On Thursday, 20 March 2014 19:28:48 UTC, Shark8  wrote:
>>>>> On 19-Mar-14 14:04, Alan Browne wrote:
>>>>>> On 2014.03.18, 19:23 , Shark8 wrote:
>>>>
>>>>>> 1. Delphi?   Why not in Ada?
>>>>>
>>>>> Answered upthread: mostly possible issues in licensing and my rotten
>>>>> luck getting DB bindings to compile/link correctly.
>>>>
>>>> Really? You couldn't get postgres-ada to compile? Really easy. If
>>>> you're talking gnatcoll, then yeah, that's a complete bitch, don't
>>>> think anyone's been too successful there.
>>>
>>> I use gnatcoll for db access. There are quirks, but it works quite well.
>>
>> I could never get gnatcoll to work; it took a /lot/ of time/effort to
>> get it so it would compiler and link... and even then it wouldn't work
>> when I tried to use it.
>>
>> I'm going to hazard a guess that you were using a linux-system, yes?
>> (I'm on a Windows system, and the building process [IMO] seems to be
>> overly dependent on the OS.)
>
> I use debian, red hat, and windows; and both gnatpro and gnat gpl.
>
> Never had a problem building and installing gnatcoll.
>
> I do have cygwin installed on Windows; I'm not sure if that's the key or
> not.

I had cygwin, too; IIRC there was some oddities/dificulties trying to 
get it to link w/ postgres... and after that, there were some problems 
w/ getting GNAT/GPS to use the compilation-results.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Shark8]

On 21-Mar-14 22:48, J-P. Rosen wrote:
> FYI, Gnat was always written in Ada, bootstrapped from the Alsys compiler.

Cool; I didn't know that.
My grand, overarching idea was basically:
(1) to have the first (and open-source / freely-available) Ada 2012 
compiler be written (implementation language rather irrelevant), then
(2) have the second be written in Ada 2012 (probably w/ SPARK 
verification/proving) -- hopefully w/ all annexes (though that's a LOT 
of work) -- and this would be the commercial product, then
(3) have that compiler/PSE/IDE available for implementing a 
verified/proved OS.

Like I said upthread; I believe that we /need/ our foundational tools to 
be without error... and that means investing in verification & 
correctness checking.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[erlo]

On 03/23/2014 11:36 PM, Simon Wright wrote:

>>> The Rational Environment used to include recognisable and storable
>>> markers in such cases: for example {statement}. As far as I remember
>>> they were displayed in inverse video to make them stand out!
>>>
>> The problem was (at least for the OS/9 cross) that the programs would
>> compile and link, resulting in an exception (Illegal program, I think)
>> when you tried to execute the code.
> 
> AFAICR the R1000 wouldn't do (the equivalent of) object code generation
> - "promoting to the code state"? - with placeholders present. But it's a
> while back!
> 
Been a while for me too! I remember this because it occured to me that
this was a major bummer. It happended more than once that we got these
'illegal program' exceptions on the target caused by placeholders.
WHen the guys at datamuseum.dk
(http://datamuseum.dk/wiki/Rational/R1000s400) get their machine
running, it's woth a test.

Erlo

Re: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 686 bytes --]

"J-P. Rosen" <rosen@adalog.fr> wrote in message 
news:lgjcj2$6hj$1@dont-email.me...
> Le 22/03/2014 07:27, Tero Koskinen a écrit :
>> There is also GELA ASIS:
>> http://gela.ada-ru.org/gela_asis_ug
>>
>> which is used by one of the QtAda projects (http://www.qtada.com/).
> Unfortunately, still incomplete and not making progresses any more.

Not to mention that all of the links I can find for it are dead, other than 
summaries of the project (like the one above). [I just tried some of the 
links on that page and none worked.] I took it off of the AdaIC page more 
than a year ago because dead links show the wrong thing about Ada.

                                       Randy.

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Randy Brukardt]

"Jeffrey Carter" <spam.jrcarter.not@spam.not.acm.org> wrote in message 
news:lgj90b$kdo$1@dont-email.me...
> On 03/21/2014 10:48 PM, J-P. Rosen wrote:
>>
>> FYI, Gnat was always written in Ada, bootstrapped from the Alsys 
>> compiler.
>
> IIRC, the Alsys compiler was also written in Ada, though initially an 
> Ada-to-PL1 translator was used until the compiler could compile itself.

Probably no one cares, but Janus/Ada was originally written in Pascal, and 
translated by our PasTran product into Ada even before it was initially 
released. (The runtime licensing of the Pascal compiler was murky, so we 
avoided the problem by using our own.) Don't recall precisely when it was 
bootstrapped (as with all of those sorts of milestones, they don't really 
happen at a point, it's rather than matter of translating it, fixing things 
to get it to compile, fixing more things to get it to run at all, and 
finally fixing the things that cause problems on some tests -- it's usually 
a relief when you get a clean test run, not such much excitement). But it 
had to be prior to November 1981, so the Pascal version was only around a 
year or so before it was translated and discarded. It's been in Ada the 32+ 
years since.

                                   Randy.

Re: Kickstarter for beginning work on a new open-source Compiler

[Qun-Ying]

It seems there are a little activity on this just about a few days ago
(for the Gela ASIS part of source repository):
http://forge.ada-ru.org/gela/wiki

Randy Brukardt wrote:
> "J-P. Rosen" <rosen@adalog.fr> wrote in message
> news:lgjcj2$6hj$1@dont-email.me...
>> Le 22/03/2014 07:27, Tero Koskinen a écrit :
>>> There is also GELA ASIS:
>>> http://gela.ada-ru.org/gela_asis_ug
>>>
>>> which is used by one of the QtAda projects (http://www.qtada.com/).
>> Unfortunately, still incomplete and not making progresses any more.
>
> Not to mention that all of the links I can find for it are dead, other than
> summaries of the project (like the one above). [I just tried some of the
> links on that page and none worked.] I took it off of the AdaIC page more
> than a year ago because dead links show the wrong thing about Ada.
>
>                                         Randy.
>
>

Re: Kickstarter for beginning work on a new open-source Compiler

[Tero Koskinen]

25.3.2014 0:42, Qun-Ying wrote:
> Randy Brukardt wrote:
>> "J-P. Rosen" <rosen@adalog.fr> wrote in message
>> news:lgjcj2$6hj$1@dont-email.me...
>>> Le 22/03/2014 07:27, Tero Koskinen a écrit :
>>>> There is also GELA ASIS: http://gela.ada-ru.org/gela_asis_ug
>>>>
>>>> which is used by one of the QtAda projects
>>>> (http://www.qtada.com/).
>>> Unfortunately, still incomplete and not making progresses any
>>> more.
>>
>> Not to mention that all of the links I can find for it are dead,
>> other than summaries of the project (like the one above). [I just
>> tried some of the links on that page and none worked.] I took it
>> off of the AdaIC page more than a year ago because dead links show
>> the wrong thing about Ada.
>>
>> Randy.
>
> It seems there are a little activity on this just about a few days
> ago (for the Gela ASIS part of source repository):
> http://forge.ada-ru.org/gela/wiki
>

Yes, the project itself is kind of alive (or zombie at least?).
Source repository saw commits just 9 days ago:
http://forge.ada-ru.org/gela/browser

And the latest release (0.3.2) is from December 2013:
http://www.ada-ru.org/files/gela-asis-0.3.2.tar.bz2

I guess the author is not that active on keeping the documentation
up-to-date. :)

-Tero

(Ps. most of this was provided via #ada@Freenode IRC channel.
It is quite good information source for all kinds of informal
"news".)

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Stephen Leake]

Shark8 <OneWingedShark@gmail.com> writes:

>> I use debian, red hat, and windows; and both gnatpro and gnat gpl.
>>
>> Never had a problem building and installing gnatcoll.
>>
>> I do have cygwin installed on Windows; I'm not sure if that's the key or
>> not.
>
> I had cygwin, too; IIRC there was some oddities/dificulties trying to
> get it to link w/ postgres... 

Ok, I never tried postgres; the included sqlite was all I needed.

>and after that, there were some problems
> w/ getting GNAT/GPS to use the compilation-results.

That works fine with sqlite.

-- 
-- Stephe

Re: ANN: Kickstarter for beginning work on a new open-source Compiler

[Dmitry A. Kazakov]

On Tue, 25 Mar 2014 15:04:34 -0500, Stephen Leake wrote:

> Shark8 <OneWingedShark@gmail.com> writes:
> 
>>> I use debian, red hat, and windows; and both gnatpro and gnat gpl.
>>> Never had a problem building and installing gnatcoll.
>>> I do have cygwin installed on Windows; I'm not sure if that's the key or
>>> not.
>>
>> I had cygwin, too; IIRC there was some oddities/dificulties trying to
>> get it to link w/ postgres... 
> 
> Ok, I never tried postgres; the included sqlite was all I needed.

Both work perfectly well under Windows and MinGW GNAT.

>>and after that, there were some problems
>> w/ getting GNAT/GPS to use the compilation-results.
> 
> That works fine with sqlite.

SQLite is different from PostgreSQL in every possible aspect. SQLite is not
client/server and has no separate DBMS, to start with. So, whatever
problems gnatcoll might have or not with one (I never used gnatcoll), that
should have no effect on another.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de