[GRASS5] Re: i.ortho.photo - XDRIVER bug detected

On Mon, 22 May 2000, Markus Neteler wrote:

I feel that keeping:

      non interactive
              CELL
              HTMLMAP

      interactive
              XDRIVER

is enough. Any other comments from other developers?

  I agree. Simplify whenever possible.

Rich

Dr. Richard B. Shepard, President

                       Applied Ecosystem Services, Inc. (TM)
              Making environmentally-responsible mining happen. (SM)
                       --------------------------------
            2404 SW 22nd Street | Troutdale, OR 97060-1247 | U.S.A.
+ 1 503-667-4517 (voice) | + 1 503-667-8863 (fax) | rshepard@appl-ecosys.com

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Markus Neteler wrote:

I feel that keeping:

       non interactive
               CELL
               HTMLMAP

       interactive
               XDRIVER

.is enough. Any other comments from other developers?

Best wishes

Markus

Hi,

i want to second that. No need to keep backward compatibility with
systems that are on the scrap heap since years.

Another suggestion:
Is someone using xgrass with grass5.0? Did anyone try to compile it
under grass5.0?

If there is no one using xgrass and no one wants to work with this code,
Markus could delete it in the CVS (and possibly make a tarball from the
last version for download on the ftp server). This will save some space
in the next source distribution.

What about switching to bzip2 for the source distribution of beta8 ?
Or will that confuse people too much?

cu,

Andreas

--
Andreas Lange, 65187 Wiesbaden, Germany, Tel. +49 611 807850
Andreas.Lange@Rhein-Main.de, A.C.Lange@GMX.net

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Mon, 22 May 2000, Andreas Lange wrote:

If there is no one using xgrass and no one wants to work with this code,
Markus could delete it in the CVS (and possibly make a tarball from the
last version for download on the ftp server). This will save some space in
the next source distribution.

  I never have quite understood what xgrass gives me, so I have not used it.
Again, thinking ahead, this looks like a good candidate for ending, too.

What about switching to bzip2 for the source distribution of beta8?

  Everyone can get bz2 executables so it should not be a big deal.

Rich

Dr. Richard B. Shepard, President

                       Applied Ecosystem Services, Inc. (TM)
              Making environmentally-responsible mining happen. (SM)
                       --------------------------------
            2404 SW 22nd Street | Troutdale, OR 97060-1247 | U.S.A.
+ 1 503-667-4517 (voice) | + 1 503-667-8863 (fax) | rshepard@appl-ecosys.com

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Rich Shepard wrote:

On Mon, 22 May 2000, Andreas Lange wrote:

> If there is no one using xgrass and no one wants to work with this code,
> Markus could delete it in the CVS (and possibly make a tarball from the
> last version for download on the ftp server). This will save some space in
> the next source distribution.

  I never have quite understood what xgrass gives me, so I have not used it.
Again, thinking ahead, this looks like a good candidate for ending, too.

I agree... Another idea is to take the opposite way : what are the
Grass functions _really_ used ? As we are thinking about a 5.1 "stable"
version, it could be interesting to add only those ones...

AFAIK, there is no stats about grass functions usage. Since all
functions are run via a single launcher program (linked to all
function names), this one can be modified to create a stat log file
that can be further exploited (perl script) to send the stats to
some repository site... that can also be a way to know how many peoples
are actually using Grass.

Does anybody have some idea of that number ?

--
Michel Wurtz ENGEES - CEREG
                1, quai Koch - BP 1039, F-67070 STRASBOURG cedex
                Tel: +33 03.88.24.82.45 Fax: +33 03.88.37.04.97

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Tue, May 23, 2000 at 09:08:39AM +0200, Michel Wurtz - ENGEES/CEREG wrote:

Rich Shepard wrote:
>
> On Mon, 22 May 2000, Andreas Lange wrote:
>
> > If there is no one using xgrass and no one wants to work with this code,
> > Markus could delete it in the CVS (and possibly make a tarball from the
> > last version for download on the ftp server). This will save some space in
> > the next source distribution.
>
> I never have quite understood what xgrass gives me, so I have not used it.
> Again, thinking ahead, this looks like a good candidate for ending, too.

I agree... Another idea is to take the opposite way : what are the
Grass functions _really_ used ? As we are thinking about a 5.1 "stable"
version, it could be interesting to add only those ones...

I still vote to make 5.0.x the stable tree numbers.
So Markus, my suggestion is that you create a branch on the whole source
tree for the stable version according to the CVS book.

So every developer should be aware of the two retrieving tags.
The development branch should be the head or default branch.
New features and massive code moving/deleting should be done in the
development branch then and people who know that they are doing minor
bugfixes should use the stable branche first.

AFAIK, there is no stats about grass functions usage. Since all
functions are run via a single launcher program (linked to all
function names), this one can be modified to create a stat log file
that can be further exploited (perl script) to send the stats to
some repository site... that can also be a way to know how many peoples
are actually using Grass.

You are getting a double *ouch* from me.
The first is because I think perl is overly difficult as a scripting
languange, but that is minor. I guess that most people will dislike the
idea to have stats send to some repository site from their computer.
So we should not add that feature.

Otherwise stats are good and it is alsways nice too keep them.
I do not think that we really can construct a good system of GRASS
function calls just by looking at their stats, though.

Does anybody have some idea of that number ?

  Bernhard

--
Professional Service around Free Software (intevation.net)
The FreeGIS Project (freegis.org)
Association for a Free Informational Infrastructure (ffii.org)

On Mon, May 22, 2000 at 03:36:58PM -0700, Rich Shepard wrote:

On Mon, 22 May 2000, Andreas Lange wrote:

> If there is no one using xgrass and no one wants to work with this code,
> Markus could delete it in the CVS (and possibly make a tarball from the
> last version for download on the ftp server). This will save some space in
> the next source distribution.

  I never have quite understood what xgrass gives me, so I have not used it.
Again, thinking ahead, this looks like a good candidate for ending, too.

My comments here:

I do not use XGRASS and already asked a few people if we should
remove it (but keep separately in CVS).
My opinion: remove XGRASS!

XGRASS libs are required to compile
src.contrib/GMSL/ogl3d_linux/
but as NVIZ is running well, noone will use ogl3d.

> What about switching to bzip2 for the source distribution of beta8?

  Everyone can get bz2 executables so it should not be a big deal.

Here I feel that maybe people will complain as this requires
an extra step. But on the other hand: who wants to compile GRASS
should be able to install bzip2...

XGRASS takes 6.5MB currently :slight_smile:

Regards

Markus Neteler

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

The only drivers I have used in the last five years of using GRASS are
the XDRIVER and CELL series. I did use the SUNVIEW version once on an
old (at the time) SUN box that ran either sunview or X. Unfortunately, I
also had to run ERDAS/SUNVIEW at the time.

Angus Carr.

Markus Neteler wrote:

Subject: Re: i.ortho.photo - XDRIVER bug detected
Date: Mon, 22 May 2000 17:45:45 +0100
I feel that keeping:

       non interactive
               CELL
               HTMLMAP

       interactive
               XDRIVER

.is enough. Any other comments from other developers?

Best wishes

Markus

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Dear developers,

a first version of the new GRASS 5 Programmer's Manual
is available.

WARNING:
- several parts are not merged properly yet
- layout is partly done
-> see page 6/7 for status details
- things could be wrong

http://www.geog.uni-hannover.de/users/neteler/progmangrass50.pdf
400 pages, 1.9MB

I have converted it to Latex, but several chapters are not
ready yet. All available GRASS 5 HTML pages are included
(except src/libes/ogsf library used by NVIZ). Perhaps it
is already interesting for you.

Your comments are welcome, further authors wanted!
As usual it is managed in CVS. Proof-reading is not
possible yet, I shall layout the missing chapters
first.

In case of error, wrong citation, missing authorships etc,
please let me know. If you want to suggest a different structure,
just tell me. You will see that it is based on the 4.x
manual with many additions.

Best wishes

Markus Neteler

--
Dipl.-Geogr. Markus Neteler * University of Hannover
Institute of Physical Geography and Landscape Ecology
Schneiderberg 50 * D-30167 Hannover * Germany
Tel: ++49-(0)511-762-4494 Fax: -3984

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Michel Wurtz - ENGEES/CEREG wrote:

AFAIK, there is no stats about grass functions usage. Since all
functions are run via a single launcher program (linked to all
function names), this one can be modified to create a stat log file
that can be further exploited (perl script) to send the stats to
some repository site... that can also be a way to know how many peoples
are actually using Grass.

I don't think that you can conclude from the number of calls of a
function/module to its usefulness. Remember that no one until now missed
m.datum.shift, perhaps for the reason that you do not miss a module if
it is not mentioned anywhere.

There are other methods of feedback than mailing log files to a central
point.
I personally do not trust any software that contacts someone without my
consent.
I think the feedback should come from the users on the grasslist (and
maybe success storys on webpages).

Does anybody have some idea of that number ?

I would be interested in a number of the grass installations, too, but i
think that this is generally not known for open software. You never can
be shure how many people use free software. The number of downloads of
souce/binary from a server is always misleading.
But on the other hand, why care. If there are subscribers to grasslist
and you/i do useful things with grass...

cu,

Andreas

--
Andreas Lange, 65187 Wiesbaden, Germany, Tel. +49 611 807850
Andreas.Lange@Rhein-Main.de, A.C.Lange@GMX.net

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Andreas Lange wrote:

There are other methods of feedback than mailing log files to a central
point.
I personally do not trust any software that contacts someone without my
consent.
I think the feedback should come from the users on the grasslist (and
maybe success storys on webpages).

Well, it was not in my intents to _automatically_ send something.
I too don't like software that access network without my consent !
I like better the idea of a welcome screen that suggest to send
some feedback to the developpers (and a log file can be used to
make a extensive list of function used, without lost of memory)

--
Michel Wurtz ENGEES - CEREG
                1, quai Koch - BP 1039, F-67070 STRASBOURG cedex
                Tel: +33 03.88.24.82.45 Fax: +33 03.88.37.04.97

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Markus Neteler wrote:

Dear developers,

a first version of the new GRASS 5 Programmer's Manual
is available.

...

Markus

There is a discrepancy between the documented behaviour of the
function G__write_cats and what it actually does:

This function returns 1 on successful completion (see
libes/gis/cats.c:997), but the documentation reports that it
returns 0 on success. This affects at least G_write_cats and
G_write_vector_cats.

Best wishes

David

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Hi David,

On Sat, May 27, 2000 at 04:38:18AM +0100, David D Gray wrote:

> a first version of the new GRASS 5 Programmer's Manual
> is available.

Markus

There is a discrepancy between the documented behaviour of the
function G__write_cats and what it actually does:

This function returns 1 on successful completion (see
libes/gis/cats.c:997), but the documentation reports that it
returns 0 on success. This affects at least G_write_cats and
G_write_vector_cats.

Thanks, I have updated it.

Note for all:

It seems a set of functions returns 0 on success, other 1.
Should this be consistent?

In case you find further "book-bugs", please let me know.
Layout work is proceeding...

Best wishes

Markus

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Sat, 27 May 2000, Markus Neteler wrote:

Note for all:

It seems a set of functions returns 0 on success, other 1. Should this be
consistent?

Markus,

  Yes. As far as I can recall, all my programs defined TRUE as 0 and FALSE
as 1. Standard exit codes include 0 as success, 1 (or greater) as failure.
Let's stick with this standard.

Rich

Dr. Richard B. Shepard, President

                       Applied Ecosystem Services, Inc. (TM)
              Making environmentally-responsible mining happen. (SM)
                       --------------------------------
            2404 SW 22nd Street | Troutdale, OR 97060-1247 | U.S.A.
+ 1 503-667-4517 (voice) | + 1 503-667-8863 (fax) | rshepard@appl-ecosys.com

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Markus Neteler wrote:

Note for all:

It seems a set of functions returns 0 on success, other 1.
Should this be consistent?

In case you find further "book-bugs", please let me know.
Layout work is proceeding...

Hi Markus, hi Rich, hi all,

there is no general consistency in GRASS if a function returns 0 or 1 on
success. The majority of functions return 0 on error and 1 on success,
but there are many which return 0 on success and a negative value on
failure.

The only way to find out is to RTS (read the source). It is not possible
to change this, because all modules must be changed for checking the new
values. It is more or less a general design thing of the whole library.

Some functions use an int return value not only to signal a
success/error condition, but return an index to a list or a
filedescriptor (have no GRASS examples at hand), these functions return
a negative value on error, as the index or fd could be zero.

I think some programmers derived the return values from c stdio
functions, which return EOF (defined as -1) on error and 0 on success.
This is usual practice in c.

The code of the libraries and modules mixes 0 (numerical zero) with NULL
(the null pointer), which i personally find confusing too. Some modules
use 0 (numerical zero) interchangebly with `\0` (string terminator),
which is also confusing. Many modules use -1, but mean EOF. Although
there are in most cases no compile or run-time errors with this, it is
not a good practice and i think everyone writing new code should be
encouraged to use this consistently. Yes, and there are many many
problematic typecasts or missing typecasts, so that gcc or a linter
complains about incompatible pointer types.

hope that did not confuse you even more,

Andreas

--
Andreas Lange, 65187 Wiesbaden, Germany, Tel. +49 611 807850
Andreas.Lange@Rhein-Main.de, A.C.Lange@GMX.net

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Sun, 28 May 2000, Andreas Lange wrote:

I think some programmers derived the return values from c stdio
functions, which return EOF (defined as -1) on error and 0 on success.
This is usual practice in c.

Andreas,

  You are, of course, correct. It's been a couple of years (or more) since I
did any coding.
  

The code of the libraries and modules mixes 0 (numerical zero) with NULL
(the null pointer), which i personally find confusing too. Some modules
use 0 (numerical zero) interchangebly with `\0` (string terminator),
which is also confusing. Many modules use -1, but mean EOF. Although
there are in most cases no compile or run-time errors with this, it is
not a good practice and i think everyone writing new code should be
encouraged to use this consistently. Yes, and there are many many
problematic typecasts or missing typecasts, so that gcc or a linter
complains about incompatible pointer types.

  This seems like a good time to switch to a consistent system. Zero could
represent success, -1 represent failure (for whatever reason), and other
return codes could be tested in context. That is, if a file handle is to be
returned, then that's what the int represents. If you are trying to open a
file, then only 0 and -1 are possible return options.

  If this is made the programming standard, it should be simple (but time
consuming) to fix one module at a time. Change the one, see what breaks, fix
the breaks, repeat.

  Perhaps I'm out of line here, but sometimes -- quite often, in fact --
it's worth taking extra time to fix what was poorly done way back when
rather than trying to maintain the mess. Is this reasonable? After all,
there has been discussion of making other changes and cleaning up the system
in other areas. This should pay off handsomely in future revisions.

Rich

Dr. Richard B. Shepard, President

                       Applied Ecosystem Services, Inc. (TM)
              Making environmentally-responsible mining happen. (SM)
                       --------------------------------
            2404 SW 22nd Street | Troutdale, OR 97060-1247 | U.S.A.
+ 1 503-667-4517 (voice) | + 1 503-667-8863 (fax) | rshepard@appl-ecosys.com

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Sun, May 28, 2000 at 11:17:51AM -0700, Rich Shepard wrote:

On Sun, 28 May 2000, Andreas Lange wrote:

> I think some programmers derived the return values from c stdio
> functions, which return EOF (defined as -1) on error and 0 on success.
> This is usual practice in c.

> The code of the libraries and modules mixes 0 (numerical zero) with NULL
> (the null pointer), which i personally find confusing too. Some modules
> use 0 (numerical zero) interchangebly with `\0` (string terminator),
> which is also confusing. Many modules use -1, but mean EOF. Although
> there are in most cases no compile or run-time errors with this, it is
> not a good practice and i think everyone writing new code should be
> encouraged to use this consistently. Yes, and there are many many
> problematic typecasts or missing typecasts, so that gcc or a linter
> complains about incompatible pointer types.

  This seems like a good time to switch to a consistent system. Zero could
represent success, -1 represent failure (for whatever reason), and other
return codes could be tested in context. That is, if a file handle is to be
returned, then that's what the int represents. If you are trying to open a
file, then only 0 and -1 are possible return options.

You cannot really establish a general rule, as there will always be
functions for which the return value is within -1 0 1 and others were
you really need -1 and 0 as vaild numbers.

This depends on the type of the function, of course.
It just needs to be documented.

  If this is made the programming standard, it should be simple (but time
consuming) to fix one module at a time. Change the one, see what breaks, fix
the breaks, repeat.

I advise against this type of fix. As both types of functions exist, we
should document them very well. You need to read the docs anyway before
you can use a GRASS library function.

As Andreas pointed out there a quite a bunch of weaknesses in the code.
Grown out of several assumptions which do not generallx hold true today
anymore. (Like the equivalent of integer and a pointer.)

Some of them need to be fixed of course.
Just switching the sematics of the return values for some functions
around does not fall into the category that needs a fix.

  Perhaps I'm out of line here, but sometimes -- quite often, in fact --
it's worth taking extra time to fix what was poorly done way back when
rather than trying to maintain the mess. Is this reasonable? After all,
there has been discussion of making other changes and cleaning up the system
in other areas. This should pay off handsomely in future revisions.

--
Professional Service around Free Software (intevation.net)
The FreeGIS Project (freegis.org)
Association for a Free Informational Infrastructure (ffii.org)

Hi Rich,

Rich Shepard wrote:

  This seems like a good time to switch to a consistent system. Zero could
represent success, -1 represent failure (for whatever reason), and other
return codes could be tested in context. That is, if a file handle is to be
returned, then that's what the int represents. If you are trying to open a
file, then only 0 and -1 are possible return options.

I think there will be no overall consistent system. The return values
used now are consistent within the system used. There are functions
which use an int retval only for error handling (returning 0 on error, 1
on success), others use int retval to return an index or filedescriptor
(returning neg. val. on error, pos. fd/index on succes), and still
others use the described system from stdin. You can not simply change
the semantics of these functions without a complete re-design of the
library.

As Bernhard said, this should simply be documented. The only functions
that could be changed with reasonable effort are those that return 0 on
success and 1 on error. I do not know if such functions exist.

  If this is made the programming standard, it should be simple (but time
consuming) to fix one module at a time. Change the one, see what breaks, fix
the breaks, repeat.

This could evolve into an herculean effort. With ~ 300 Modules this
try-and-error approach seems to me very dangerous. There are other
methods to automate this.

  Perhaps I'm out of line here, but sometimes -- quite often, in fact --
it's worth taking extra time to fix what was poorly done way back when
rather than trying to maintain the mess. Is this reasonable? After all,
there has been discussion of making other changes and cleaning up the system
in other areas. This should pay off handsomely in future revisions.

The GRASS code evolved partly from K&R (pre-ANSI-) c code. This is not a
matter of poor done coding, but of changing habits, changing culture,
changing compilers etc. , and i do not care if _working_ modules contain
not-so-clean code. I think that the clean-up should be done first on the
libraries and with second priority on the modules if someone works on
the code (for other reasons than cleaning).
Everything else is not realistic.

My main idea is to encourage everyone to stick to a consistent coding
style and to use a linter and gcc -Wall on the new code to prevent
future problems. Coding in an open software project has different
considerations than coding in an institution where the authors are
present all the time.

Now i will switch back to "cleaning up" the coordinate conversion
library,

cu,

Andreas

--
Andreas Lange, 65187 Wiesbaden, Germany, Tel. +49 611 807850
Andreas.Lange@Rhein-Main.de, A.C.Lange@GMX.net

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

Rich Shepard wrote:

On Sun, 28 May 2000, Andreas Lange wrote:

> I think some programmers derived the return values from c stdio
> functions, which return EOF (defined as -1) on error and 0 on success.
> This is usual practice in c.

Andreas,

  You are, of course, correct. It's been a couple of years (or more) since I
did any coding.

> The code of the libraries and modules mixes 0 (numerical zero) with NULL
> (the null pointer), which i personally find confusing too. Some modules
> use 0 (numerical zero) interchangebly with `\0` (string terminator),
> which is also confusing. Many modules use -1, but mean EOF. Although
> there are in most cases no compile or run-time errors with this, it is
> not a good practice and i think everyone writing new code should be
> encouraged to use this consistently. Yes, and there are many many
> problematic typecasts or missing typecasts, so that gcc or a linter
> complains about incompatible pointer types.

  This seems like a good time to switch to a consistent system. Zero could
represent success, -1 represent failure (for whatever reason), and other
return codes could be tested in context. That is, if a file handle is to be
returned, then that's what the int represents. If you are trying to open a
file, then only 0 and -1 are possible return options.

As a user programmer, I prefer clean definition and API.

  If this is made the programming standard, it should be simple (but time
consuming) to fix one module at a time. Change the one, see what breaks, fix
the breaks, repeat.

  Perhaps I'm out of line here, but sometimes -- quite often, in fact --
it's worth taking extra time to fix what was poorly done way back when
rather than trying to maintain the mess. Is this reasonable? After all,
there has been discussion of making other changes and cleaning up the system
in other areas. This should pay off handsomely in future revisions.

It is my feeling resulting from my experience.

Rich

Dr. Richard B. Shepard, President

                       Applied Ecosystem Services, Inc. (TM)
              Making environmentally-responsible mining happen. (SM)
                       --------------------------------
            2404 SW 22nd Street | Troutdale, OR 97060-1247 | U.S.A.
+ 1 503-667-4517 (voice) | + 1 503-667-8863 (fax) | rshepard@appl-ecosys.com

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

--
Robert Lagacé, professeur
Pavillon Comtois
Université Laval
Ste-Foy, Québec, G1K 7P4
tel : (418)-656-2131#2276
Fax : (418)-656-3723
E-mail : lagace@grr.ulaval.ca

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'

On Mon, May 29, 2000 at 05:33:04PM +0200, Andreas Lange wrote:

Hi Rich,

Rich Shepard wrote:

> This seems like a good time to switch to a consistent system. Zero could
> represent success, -1 represent failure (for whatever reason), and other
> return codes could be tested in context. That is, if a file handle is to be
> returned, then that's what the int represents. If you are trying to open a
> file, then only 0 and -1 are possible return options.
>

I think there will be no overall consistent system. The return values
used now are consistent within the system used. There are functions
which use an int retval only for error handling (returning 0 on error, 1
on success), others use int retval to return an index or filedescriptor
(returning neg. val. on error, pos. fd/index on succes), and still
others use the described system from stdin. You can not simply change
the semantics of these functions without a complete re-design of the
library.

Here I agree - we should be careful and keep running libraries
running.

As Bernhard said, this should simply be documented.

I will start next week to update further pages within the Prog. Manual.
While updating I will cross-check with the sources to keep
both into sync.

[...]

My main idea is to encourage everyone to stick to a consistent coding
style and to use a linter and gcc -Wall on the new code to prevent
future problems. Coding in an open software project has different
considerations than coding in an institution where the authors are
present all the time.

I would be happy to insert a small text on programming style to
put this into the Prog.-Manual.
Who is willing to write it? Maybe just start with a set of rules,
a text may evolve later.

Now i will switch back to "cleaning up" the coordinate conversion
library,

Thanks Andreas!

Best wishes

Markus

----------------------------------------
If you want to unsubscribe from GRASS Development Team mailing list write to:
minordomo@geog.uni-hannover.de with
subject 'unsubscribe grass5'