> > Sigh. Of course *I* know this. But:
> >
> > a) there is no pointer on how to report bugs on mingw.org
> > b) the bug reporting page on SF *requires* someone to have
> >    an SF account to report a bug, although this is not a
> >    SF requirement. (maybe it is to discourage a lot of beginner
> >    type of 'bug' reports, but is is also a *huge* block. In practice
> >    I only get bug reports on GNAT on Ada mailing lists, comp.lang.ada
> >    and direct email.)
> Okay gcc -v --help prints this at the end of its output:
> For bug reporting instructions, please see:
> <URL:http://www.gnu.org/software/gcc/bugs.html>
> This can be changed, and in fact mingw is supposed to
> (from gcc/version.c):
> /* This is the location of the online document giving instructions for
>    reporting bugs.  If you distribute a modified version of GCC,
>    please change this to refer to a document giving instructions for
>    reporting bugs to you, not us.  (You are of course welcome to
>    forward us bugs reported to you, if you determine that they are
>    not bugs in your modifications.)  */
> const char bug_report_url[] =
> "<URL:http://www.gnu.org/software/gcc/bugs.html>";
> I'm not sure but that string might also get put into info files.
> Should we modify this built-in bug report url for mingw-gcc(3.3) to the
> SF page, or to a friendlier page at mingw.org that links to gcc,
> binutils, etc, as well as the SF page?

     This, at least to me, is a much more complex question than it initially appears to be.  I will attempt to stay focussed on the question itself.

     Personally I am inclined to believe that the friendlier page is the better way to go for a couple of reasons: a) It keeps Mingw forefront when it comes to reporting a mingw-gcc related bug b) It gives a reference, in the case it is not a mingw-gcc specific bug, for the user to submit the bug to the gcc url:  http://www.gnu.org/software/gcc/bugs.html.

     My suggestion would be, in its simplest form, to determine the "specific", and output the appropriate place to report the bug based on the "specific" behavior of the bug in question.

     I think it is important to keep the two gcc's (Mingw-gcc and Gnu-gcc) synchronized for as long as it is at all possible to do so.

     My biggest question:  How can it be initially determined whether the bug is in fact Mingw- gcc specific (eg. Mingw runtime interface) or Gnu-gcc specific?  If I can answer that question, then I can say which would be the more appropriate URL reference to use.

     Here is one possible solution/suggestion (please ignore if it has already been, in the community of Mingw developers, adequately addressed):

          Track all the mingw-gcc specific changes (ie. those that make mingw-gcc different than gnu-gcc).

     What that "tracking" might look like (please ignore if this has already been, in the community of Mingw developers, adequately addressed):

          Being able to quickly check/detect (cvs changelog perhaps?) what has been specifically modified to support the mingw runtime (within Gnu-gcc which allows Mingw-gcc to exist as different (diffs?) than Gnu-gcc) and can be seen in the latest Mingw-gcc source code release, but may not be apparent or even existent (in terms of diffs) within Gnu-gcc source code release. (I know that there are  some things in the Mingw-gcc(3.3) version that do not exist in the Gnu-gcc(3.3) version -- I am still not exactly sure how to reference those things.  For ease of communication, I typically consider those differences between Mingw- gcc(3.3) as extensions to Gnu-Gcc(3.3) specifically implemented and tailored to work with the Mingw runtime.).

     The actual source code variances between the two gccs (Mingw-gcc and Gnu-gcc) may be deduced.  I am assuming that Gnu-gcc and Mingw-gcc are on a kind of "continuum" with Gnu-gcc at one end of that "continuum" and Mingw-gcc at the other end of that "continuum".

     As to how to implement such a thing at the source code level?  Not sure.  Even so, here is one suggestion -- it assumes that the internal gcc exception/bug detection sequence has been executed:

     Run a diff (cron?) between all of Gnu-gcc specific source code and Mingw-gcc specific source code on a periodic basis (to be determined by those who are or will be modifyiing/developing the Mingw variation of Gcc) based on the gcc detected bug.

     Ultimately, what you would have is the following algorithm:

          mingw-gcc-diffs =
               diffs between Gnu-Gcc-latest-release and Mingw-gcc-latest-release

          Gnu-gcc-diffs = (Gnu-gcc-latest-diffs)

          Gnu-gcc-latest = (Gnu-gcc-latest-stable-release)


          Check submitted bug-report against mingw-gcc-diffs;
               if bug report not handled/covered/previously-assigned within mingw-gcc-diffs,
                    then check to see if bug report is handled/covered/previously-assigned
                         within the gnu-gcc-diffs;
               if bug report not handled/covered/previously-applied within gnu-gcc-diffs, then                     apply/assign/send bug-report/bug to Gnu-gcc-latest;
                    apply/assign/send bug-report/bug to Mingw-gcc;;

(end pseudo-code)

     The above is intended to indicate "how" and "what" should be provided whenever the "built-in bug report exception" is actually executed by the Mingw variation of Gcc.

     I really have no idea, at least not right now (this moment), as to "how the above pseudo- code might be implemented at the source code level of the Gcc being used (as part of distro/install) for Mingw" or "What the scope of such an implementation might include".

     Even so, it does seem to be a logical way/method to implement (which url should be noted) in terms of "how to approach modification of the automated bug-report facility".

Danny wrote:

> Should we modify this built-in bug report url for mingw-gcc(3.3) to the
> SF page, or to a friendlier page at mingw.org that links to gcc,
> binutils, etc, as well as the SF page?

     What about a special page (perhaps a .cgi or .php page?) which can determine (for the end-user wanting to report the bug) where the end-user should actually report/submit the bug?

     If that were implemented, then the URL output (from gcc) would always direct the end- user to that particular web page (mingwbugs.sf.net?).  The web page itself would/could manage the rest.

     Paul G.