ftp.xmission.com/2014.06.ftp.xmission.com.tar/ftp.xmission.com/pub/lists/fractdev/archive/v01.n022

Internet Message Format | 1999-05-02 | 41KB

From: [e-mail] (fractdev-digest)
To: [e-mail]
Subject: fractdev-digest V1 #22
Reply-To: fractdev-digest
Sender: [e-mail]
Errors-To: [e-mail]
Precedence: bulk


fractdev-digest          Monday, May 3 1999          Volume 01 : Number 022




----------------------------------------------------------------------

Date: Fri, 30 Apr 1999 12:35:54 -0400 (EDT)
From: [e-mail] (Kragen Sitaker)
Subject: Re: (fractdev) everything

Fill wrote:
> The path separator thing becomes painful under unix.  Fractint uses
> '/' to separate the parameter name from a parameter file, for
> isntance.  It happens to look for a '/', and if it sees one, it
> assumes that the argument is ``@parfile/entry'', but if one naively
> specified a full-path of a parfile under xfractint, you'd have a '/'
> as part of the parfile name and xfractint will become confused.  A
> workaround is to always have parfiles specified in this manner in the
> current directory.  Either fractint's syntax will have to be adjusted
> slightly, or some quoting mechanism must be installed to allow a full
> pathname for a unix file to be specified in these instances.

Everything can work with no user-visible changes.

In the general case @a/b/c/d/e, a/b/c/d must be either be a file or a
directory -- it can't be both, right?  (No "parfile paths", right?  I
haven't used fractint in a while.)  If it's a file, @a/b/c/d/e means
the entry e in the file a/b/c/d; if it's a directory, @a/b/c/d/e means
the file a/b/c/d/e.

>         void * != int
>
> Lots of places in the code there are implicit assumptions about
> sizeof(int) == sizeof(void *).  This isn't good for portability in
> general, and in the L-system code I think it actually causes a crash
> in xfractint that shouldn't be there.

It's true that it's not good for portability in general, but it's true
afaik on all 32-bit Intel platforms, the Sparc, and 32-bit MIPS
machines.  I don't know if it's true on various Alpha platforms,
various UltraSparc platforms, various 64-bit MIPS platforms (OK I mean
IRIX) etc.  I know it's not true on some memory models of 16-bit Intel
chips and the AS/400.

What I wanted to know is, what platform are you running xfractint on
that this crash occurs?

> I think fractint should adopt gmp, but this will mean a fair bit of work.

I think everyone doing arbitrary-precision math should adopt GMP.
However, you should be aware that adopting GMP will mean that Fractint
has to be released under the GNU General Public License, which allows
anyone to sell copies of Fractint.  IMHO this would be a good thing
(e.g. it could be included with Red Hat Linux and Debian GNU/Linux).
Some other people may not think so, and Fractint's current license
forbids this.

Also, who holds the copyright on Fractint?  Remember that copyright
inheres in a copyrightable work as soon as it is created, and cannot be
transferred implicitly.  (You can give an implicit license, but you
can't implicitly give away your copyright rights.)  For the Stone Soup
Group to legitimately hold copyright to all of Fractint, everyone who
has contributed a chunk of code big enough to be copyrightable needs to
have signed legal papers to transfer their copyright ownership to the
Stone Soup Group.  That probably doesn't mean everybody in the credits,
but certainly a significant number of them.

The reason I ask is that only the holder of a copyright can license the
copyrighted work.  If Jonathan decides he wants to license the Fractint
code he wrote under the GPL, that's fine, but if Tim doesn't like it,
Jonathan can't license Tim's code under the GPL.  If it turns out that
50 different people own the copyrights to various parts of Fractint,
you'll need all 50 of their signatures or the signatures of their heirs
(or you'll need to discard the code they wrote) in order to release
Fractint under the GPL.

Linux uses the same technique to make it impossible to release Linux
under a non-GPL license.  I understand environmental activists have
used a similar technique -- selling individual square feet of land to
many different people -- to slow down condemnation proceedings.

These same problems do not attend releasing a fractint including
autoconf scripts for building or built with gcc and GNU libc, because
of licensing or linking differences.  They *may* attend releasing a
fractint linked against the DJGPP libraries or Allegro -- are these
licensed under the GPL?

Summary: using gmp (and possibly djgpp or allegro) may be extremely
difficult for legal reasons.  I am not a lawyer, and this is not legal
advice.  Hit the books and make your own decisions.

> If it were up to me, I'd take
> the complex and trig support impemented in fractint, port that onto
> the gmp library and contribute it back as GPL'ed source to the gmp
> maintainers.

Bruno Haible's CLN (see clisp.cons.org) is a GPLed library built on gmp
that provides (among other things) complex support, and I think trig
too.  It's written in C++ though.

> Just an observation... fractint already embodies the concept of
> "generic programming with template classes" as closely as C can deal
> with it.

Generally this is done in C with #define macros or m4.  (The latter can
produce code that works better with most debuggers.)

> Ah, but here you're using the inheritence/OOness of C++ to exploit
> reuse.  The generic programming/template model, as embodied by the STL
> for example, is really quite a different kind of reuse than that
> provided by class hierarchies.

Mechanically it's implemented differently.  Conceptually it's the same
thing.  More advanced OO environments (like Self, notably) dynamically
pick and mix specialization (generating multiple copies of the same
code to deal with different data types) and dynamic dispatch
(generating a single copy of the code which calls different code
depending on the types of the data it's handling) to dynamically
balance speed and code size/compile time.

> Despite all the different programming languages and circumstances in
> which I've exercised my skill, the concepts embodied by the STL really
> changed the way I looked at certain programming problems.

Me too.  (Although I can't really talk much about exercising my skill.  ;)

>  STL is written in C++, but it isn't "object oriented".  There is a
> minor use of class inheritance to exhibit some reuse, but this is rare
> and only in places where it makes sense for the problem.  STL has some
> aspects of "functional" programming languages, especially adaptors,
> binders, unary_function, binary_function, and so-on.

Well, like I said, it's a different way to implement the same thing.
(STL implements several things that would be extremely slow if they
were implemented with dynamic dispatch instead of specialization, and
since "int" is not a class in C++, also very inconvenient to use.)

It's not very functional; the whole programming model is deeply based
on mutation.

Looks like, by "binder", STL means something like "a curried function".

Humberto Rossetti Baptista wrote:
>         Yesssss. And also I think gmp is C++ isnt' it?

No, C.

Fill wrote:
>     "allegro"
>         Uses Allegro library under DJGPP to enumerate video formats
>         and provide video/mouse/sound support.

Could also work under X.

> But of all the open source software I use, I
> couldn't think of one that embodies the stone soup tradition of mutual
> cooperation more than fractint.

I think I agree.  But be careful -- Fractint is not now, and never has
been, Open Source (tm) software, because people are not free to sell
it.

- --
<[e-mail]>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
TurboLinux is outselling NT in Japan's retail software market 10 to 1,
so I hear.
- -- http://www.performancecomputing.com/opinions/unixriot/981218.shtml


- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 12:55:28 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) everything

In article <[e-mail]>,
    [e-mail] (Kragen Sitaker)  writes:

> Everything can work with no user-visible changes.

Yeah, but the code has to change, which was my real point.

> >         void * != int
> >
> > Lots of places in the code there are implicit assumptions about
> > sizeof(int) == sizeof(void *).  This isn't good for portability in
> > general, and in the L-system code I think it actually causes a crash
> > in xfractint that shouldn't be there.
>
> It's true that it's not good for portability in general, but it's true
> afaik on all 32-bit Intel platforms, the Sparc, and 32-bit MIPS
> machines.

Nope, its not true on sparc, or MIPS.  Why?  Because a pointer has
alignment restrictions that constrain its valid value and an integer
does not.  In other words, the following is most certainly going to
cause a crash on a sparc or mips platform:

    int i = 3;
    void *p = (void *) i;
    *p = 1;

On the x86, you can address 16/32/etc. sized quantities at any memory
location.  The CPU does the necessary word twiddling to get the
operand of the appropriate type.  Misaligning data on an x86 affects
performance but doesn't crash.  On a non-x86 it almost certainly
causes a crash or exception.

> What I wanted to know is, what platform are you running xfractint on
> that this crash occurs?

I found a crash in L-systems on a sparc running solaris 2.7.  When I
looked at it in the debugger, a quick 6-minute analysis figured the
problem to be related to pointer casting due to the attempt to
conserve memory in the medium model.  If the memory had just simply
been malloc'ed instead, then it works fine.

> [long worry about the GPL and its implications]

This sounds like the typical misunderstanding of what the GPL really
says.  I'd get a clarification from the FSF on that before I worried
about it, but I personally believe it to be a non-issue.

> Bruno Haible's CLN (see clisp.cons.org) is a GPLed library built on gmp
> that provides (among other things) complex support, and I think trig
> too.  It's written in C++ though.

That URL just talks about a common lisp implementation, no mention of
CLN or anything for C++.

> Mechanically it's implemented differently.  Conceptually it's the same
> thing.

I disagree.  Generic programming is conceptually and syntactically
different from OO programming in C++.  The only thing they have in
common is a desire for reuse.

> It's not very functional; the whole programming model is deeply based
> on mutation.

Adaptors, binders, etc., are all very much in the style of functional
programming.  Its where they get their inspiration from.

> Looks like, by "binder", STL means something like "a curried function".

Yes.

> [Allegro]
>
> Could also work under X.

Yeah, but using allegro for fractint's X interface wouldn't be the
right way to do it, I think.  Seriously folks, fracint's existing UI
needs are not elaborate!  That's because fractint built everything
itself on top of the basic functionality of being able to read/write
single pixels into a memory-mapped VGA display.  The whole idea of
modern UI needs is foreign to fractint.

> I think I agree.  But be careful -- Fractint is not now, and never has
> been, Open Source (tm) software, because people are not free to sell
> it.

We already went through this once before.  If someone is going to sue
my ass becuase I consider fractint to be "open source", I wish they'd
just get off their lazy butts and do it.  Otherwise, if you care to
have a debate about the meaning of the GPL or the legal phrase "open
source", then it'll be a one-sided debate since I consider engaging in
such a debate to be a waste of time that only distracts me from the
real issues facing fractint right now.
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 16:51:16 -0400 (EDT)
From: [e-mail] (Kragen Sitaker)
Subject: Re: (fractdev) everything

Legalize Adulthood writes:
> > Everything can work with no user-visible changes.
>
> Yeah, but the code has to change, which was my real point.

Of course you are correct.

> > > Lots of places in the code there are implicit assumptions about
> > > sizeof(int) == sizeof(void *).  This isn't good for portability in
> > > general, and in the L-system code I think it actually causes a crash
> > > in xfractint that shouldn't be there.
> >
> > It's true that it's not good for portability in general, but it's true
> > afaik on all 32-bit Intel platforms, the Sparc, and 32-bit MIPS
> > machines.
>
> Nope, its not true on sparc, or MIPS. [because of alignment]

When I said "it's true", I just meant the sizes were the same, not the
alignment constraints, because that's what you said in the text I
responded to.  Of course you are correct that arbitrary integers can't
be used as pointers on most machines.  Often, however, this is a
dangerous practice even on Intel hardware, because arbitrary integers
are not likely to point at anything useful.  ;)

> > [long worry about the GPL and its implications]
>
> This sounds like the typical misunderstanding of what the GPL really
> says.

It's not.

> I'd get a clarification from the FSF on that before I worried
> about it, but I personally believe it to be a non-issue.

I've sent them an email, saying,
    Someone's proposing replacing Fractint's arbitrary-precision
    math routines with routines from the GMP library.  My
    understanding is that this would require Fractint to be
    licensed under the GPL, which would lift the restriction
    against commercial sale of Fractint in Fractint's current
    license.  Is this correct?  Is it possible to link Fractint
    with GMP and continue to distribute Fractint executables under
    the current Fractint license?

I will forward the response to this list.

> > Bruno Haible's CLN (see clisp.cons.org) is a GPLed library built on gmp
> > that provides (among other things) complex support, and I think trig
> > too.  It's written in C++ though.
>
> That URL just talks about a common lisp implementation, no mention of
> CLN or anything for C++.

The Common Lisp implementation in question is implemented in C++ and
uses CLN for its numeric processing.  I can't seem to find links to CLN
from the home page, but CLN's home page is at
http://clisp.cons.org/~haible/packages-cln.html.

> > Mechanically it's implemented differently.  Conceptually it's the same
> > thing.
>
> I disagree.  Generic programming is conceptually and syntactically
> different from OO programming in C++.  The only thing they have in
> common is a desire for reuse.

Unarguably, C++ syntax for template-based polymorphism is different
from C++ syntax for dynamic-method-dispatch-based polymorphism.  And
underneath the hood, they are unarguably different things.  But they
are two ways of doing the same thing: specifying what you want to do
to an object and letting the object decide what the most appropriate
way of doing that thing is, and allowing different objects to do the
same thing differently without any change in the calling code.

> We already went through this once before.  If someone is going to sue
> my ass becuase I consider fractint to be "open source",

I thought I forwarded you the response I got from OSI.  They said they
couldn't do anything about posts on private mailing lists.  So noone
will sue your ass.  :)

> I consider engaging in such a debate to be a waste of time that only
> distracts me from the real issues facing fractint right now.

Bravo, concentrate on the real issues, then.  The work you're doing is
certainly important.  Have fun.

- --
<[e-mail]>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
TurboLinux is outselling NT in Japan's retail software market 10 to 1,
so I hear.
- -- http://www.performancecomputing.com/opinions/unixriot/981218.shtml


- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 18:01:55 -0400 (EDT)
From: [e-mail] (Kragen Sitaker)
Subject: (fractdev) GPL clarification

The response to my email to [e-mail]:

If GMP is under the GPL, then Fractint would have to be
GPLed to use GMP code.  Under the GPL you can have
commercial sale, although license fees are illegal of
course.

- --
                                   Brian Youmans
                                   FSF Office Staff

- --
<[e-mail]>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
TurboLinux is outselling NT in Japan's retail software market 10 to 1,
so I hear.
- -- http://www.performancecomputing.com/opinions/unixriot/981218.shtml


- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 17:15:46 -0600
From: "Tim Wegner" <[e-mail]>
Subject: Re: (fractdev) portability thoughts

Phil said:

> Some low-level stuff is written in assembly, see bigflta.asm and
> bignuma.asm.  Poking around a little more, it looks like bigfltc.c
> implements C versions of the assembly routines.

Fractint's arbitrary precision is already portable, as far as we know.
I will say that it is optimized for little endian and probably is less
efficient on big endian.

The main reason for not going to another arbitrary precision library
is that Wes has implemented a slew of transcendental functions.

Tim


- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 22:25:55 -0300 (EST)
From: Humberto Rossetti Baptista <[e-mail]>
Subject: Re: (fractdev) GPL clarification

On Fri, 30 Apr 1999, Kragen Sitaker wrote:
[Brian quote:]
> If GMP is under the GPL, then Fractint would have to be
> GPLed to use GMP code.  Under the GPL you can have
> commercial sale, although license fees are illegal of
> course.

    Brian is being lazy in his response since gmp is a "recommended"free
program on the fsf site.

    It is not on GPL (what would indeed require fractint to become GPL), but
it is LGPL (http://www.fsf.org/manual/gmp/html_chapter/gmp_1.html#SEC1 and the
definition of LGPL is in http://www.fsf.org/copyleft/lgpl.html).

    The LGPL is the Library Gnu Policy License and it provide mechanisms to
link agains a free library a non-GPL program, such as Fractint.

    In the spirit of freedom I agree with "Phil" when he says that fractint
is free software, bu I guess our licence is more radical than GNU :-))))

    In short: we an link agains GMP w/ no problems.

    []'s

    Humberto R. Baptista
    [e-mail]

- ---------------------------------------------------------------------------
Insite - Solucoes Internet                         http://www.insite.com.br

- -----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GB/C/CA/CM/CS/CC/ED/FA/H/IT/L/M/MU/P/S d?>dpu s:- a->!@ C++++$ USL+++$ P+++@
L+++@ !E W++@ N++(+)@ o+>++++$ K? w>---$ O-@$ M--@ V-- PS@ PE@ Y+>+++$ PGP+@
t+++ 5+@ X+ R>+++$ tv@ b+>++++$ DI++$ D++>++++$ G e+++>++++ h(---)>*$ r+++
y+++*
- ------END GEEK CODE BLOCK------



- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 20:16:56 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) everything

In article <[e-mail]>,
    [e-mail] (Kragen Sitaker)  writes:

> > I'd get a clarification from the FSF on that before I worried
> > about it, but I personally believe it to be a non-issue.
>
> I've sent them an email, saying [...]

Actually you needn't even bother.  All you have to do is read the
license in the gmp-2.0.2 distribution.  It says quite clearly that
linking against the library doesn't mean your program is bound by the
GPL.  Like I said, it sounds like you have a misconception about the
GPL covering gmp-2.0.2.

> [generic programming and oo programming]
> are two ways of doing the same thing: specifying what you want to do
> to an object and letting the object decide what the most appropriate
> way of doing that thing is, and allowing different objects to do the
> same thing differently without any change in the calling code.

It sounds like we don't have a common accepted definition of "generic
programming".  At any rate, its not relevant to anything
fractdev-related.

> > We already went through this once before.  If someone is going to sue
> > my ass becuase I consider fractint to be "open source",
>
> I thought I forwarded you the response I got from OSI. [...]

Yes, so why did you bring it up again?  There's no point in rehashing
this stuff every time I happen to type the phrase "open source".

You know, the kind of feedback I wanted was about specific things in
the fractint code that I should be paying attention to now, so as not
to avoid some problem that occurs to another mind familiar with the
source.  I'm afraid your response just wasn't helpful, only time
consuming.
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 20:19:00 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) GPL clarification

Like I said, please read the COPYING file in the gmp-2.0.2
distribution.  It states quite clearly that you can link against the
library without having to adopt the GPL in your code.

Thanks for reporting me to the FSF police.
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 20:24:01 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) portability thoughts

In article <[e-mail]>,
    "Tim Wegner" <[e-mail]>  writes:

> Fractint's arbitrary precision is already portable, as far as we know.

As I guessed after a little browsing.

> I will say that it is optimized for little endian and probably is less
> efficient on big endian.

And no assembly support is provided for anything other than 16bit x86.
GMP's main advantage is its wide support for assembly on different
CPUs.

> The main reason for not going to another arbitrary precision library
> is that Wes has implemented a slew of transcendental functions.

Yep, which is why my note in my "thoughts" file also contained wording
to the effect that in the true stone soup tradition, fractint's
contribution to gmp could be adding the complex and transcendental
function support back to gmp.  Then fractint would just link against
gmp like any other gmp client.

Naturally the authors of that code would have to agree to this before
their code could be used directly in such an effort.  However, I don't
see the "stone soup tradition" and the FSF's goals to be at
cross-purposes, more like cousins in the same family.  At any rate, I
have no idea why this has become the hot potato issue from all the stuff
I wrote when its like item #682 on the agenda.
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 22:36:27 -0400 (EDT)
From: [e-mail] (Kragen Sitaker)
Subject: Re: (fractdev) everything

You wrote:
> At any rate, I have no idea why this has become the hot potato issue
> from all the stuff I wrote when its like item #682 on the agenda.

Yeah, it puzzled me a bit, too.  I didn't mean for it to be, and I
certainly didn't mean to waste your time.

I'm not sure why I thought gmp was GPLed -- I think it might have been
several years ago.  I'll let you know (in private so as not to use up
more list bits) when I find out.

- --
<[e-mail]>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
TurboLinux is outselling NT in Japan's retail software market 10 to 1,
so I hear.
- -- http://www.performancecomputing.com/opinions/unixriot/981218.shtml


- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Fri, 30 Apr 1999 20:39:13 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) everything

In article <[e-mail]>,
    [e-mail] (Kragen Sitaker)  writes:
> I'm not sure why I thought gmp was GPLed -- I think it might have been
> several years ago.  I'll let you know (in private so as not to use up
> more list bits) when I find out.

Please don't bother.  I'm not really interested.
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Sat, 1 May 1999 10:31:21 -0600
From: "Tim Wegner" <[e-mail]>
Subject: Re: (fractdev) GPL clarification

Kragen wrote:

> The response to my email to [e-mail]:
>
> If GMP is under the GPL, then Fractint would have to be
> GPLed to use GMP code.  Under the GPL you can have
> commercial sale, although license fees are illegal of
> course.
>
> --
>                                    Brian Youmans
>                                    FSF Office Staff


Folks if you want to kill the idea of Fractint's using somebody's
code, quote some bureaucrat who uses unintelligible  acronyms
who is trying to tell us what to do.

As Rich said, arbitrary precision is very low on our list of priorities.
We have working portable code written by ourselves. At some
future time we might rework it.

FWIW, Fractint has the policy of not using any libraries that we
can't provide in source form. We do have a need to redo our license
agreement, which is very badly written. However this interchange
has not warmed me up to  FSF (Free Software Foundation???).

Tim Wegner




- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Sun, 02 May 1999 19:26:30 -0600
From: Phil McRevis <[e-mail]>
Subject: Re: (fractdev) GPL clarification

Don't worry about what Brian Youmans said.  He hasn't read the license
file that comes with GMP.  That file really is the last word on this
subject.  <ftp://mirrors.xmission.com/gnu/gmp/gmp-2.0.2.tar.gz>
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
[e-mail]    <http://www.eden.com/~thewho>

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

Date: Mon, 03 May 1999 08:08:40 -0600
From: Phil McRevis <[e-mail]>
Subject: (fractdev) device extraction -- 2nd try

- ------- =_aaaaaaaaaa0
Content-Type: text/plain; charset="us-ascii"
Content-ID: <[e-mail]>

Looks like my first try was too long again, here we go...

Well I've made the first pass through the code and ripped out the
XFRACT specific parts and separated the code into two and a half
drivers: "disk", "x11", and "fractint".  Its only two and a half
drivers because the "fractint" driver hasn't had its guts (i.e. the
existing video drivers written in assembly) ported to a 32bit DPMI
environment, which is the target of this effort.

"disk" uses curses for text I/O, uses a piece of memory as a
framebuffer for graphical output and uses the diskvideo code already in
fractint.

"x11" has the X11 graphical output code, but none of the curses text
I/O code.  Next for X11 will be to have its text I/O implemented with
X text.

"fractint" won't work completely in this flat-memory model port (i.e.
djgpp) until the assembly code is ported for the video drivers.  Where
there was a routine that was only partially #ifdef'ed on XFRACT, the
non-XFACT version of the routine went into the fractint driver.  This
code has not been compiled, but would serve a useful scaffold to
whoever wanted to port the assembly. ;-)

I've only gone so far as to make the edits to the code (quite a lot)
and verify that everything compiles like it should.  I ran the curses
version and it came up like it should, although it didn't save a proper
GIF correctly when I typed 's'.

FYI Attachments: driver header file
- --
<http://www.xmission.com/~legalize/>    Legalize Adulthood!
    ``Ain't it funny that they all fire the pistol,
      at the wrong end of the race?''--PDBT
          <http://www.eden.com/~thewho>

- ------- =_aaaaaaaaaa0
Content-Type: text/plain; name="drivers.h"; charset="us-ascii"
Content-ID: <[e-mail]>

#if !defined(DRIVERS_H)
#define DRIVERS_H

/*------------------------------------------------------------
 * Driver Methods:
 *
 * init
 * Initialize the driver and return non-zero on success.
 *
 * terminate
 * flush
 * schedule_alarm
 * start_video
 * end_video

 * window
 * Do whatever is necessary to open up a window after the screen size
 * has been set.  In a windowed environment, the window may provide
 * scroll bars to pan a cropped view across the screen.
 *
 * resize
 * redraw
 * read_palette, write_palette
 * read_pixel, write_pixel
 * read_span, write_span
 * set_line_mode
 * draw_line
 * get_key
 * shell
 * set_video_mode
 * put_string
 * set_for_text, set_for_graphics, set_clear
 * find_font
 * move_cursor
 * hide_text_cursor
 * set_attr
 * scroll_up
 * stack_screen, unstack_screen, discard_screen
 */
struct tagDriver {
  const char *name;            /* name of driver */
  int (*init)(int *argc, char **argv);  /* init the driver */
  void (*terminate)(void);        /* shutdown the driver */
  void (*flush)(void);            /* flush pending updates */
  void (*schedule_alarm)(int secs);    /* refresh alarm */

  int (*start_video)(void);
  int (*end_video)(void);

  void (*window)(void);            /* creates a window */
  int (*resize)(void);            /* handles window resize.  */
  void (*redraw)(void);            /* redraws the screen */

  int (*read_palette)(void);        /* reads palette into dacbox */
  int (*write_palette)(void);        /* writes dacbox into palette */

  int (*read_pixel)(int x, int y);
  void (*write_pixel)(int x, int y, int color);
                    /* reads a line of pixels */
  void (*read_span)(int y, int x, int lastx, BYTE *pixels);
                    /* writes a line of pixels */
  void (*write_span)(int y, int x, int lastx, BYTE *pixels);

  void (*set_line_mode)(int mode);    /* set copy/xor line */
  void (*draw_line)(int x1, int y1, int x2, int y2); /* draw line */

  int (*get_key)(int block);        /* poll or block for a key */
  void (*shell)(void);            /* invoke a command shell */
  void (*set_video_mode)(int ax, int bx, int cx, int dx);
  void (*put_string)(int row, int col, int attr, const char *msg);

  void (*set_for_text)(void);        /* set for text mode & save gfx */
  void (*set_for_graphics)(void);    /* restores graphics and data */
  void (*set_clear)(void);        /* clears text screen */

  BYTE *(*find_font)(int parm);        /* for palette editor */

  /* text screen functions */
  void (*move_cursor)(int row, int col);
  void (*hide_text_cursor)(void);
  void (*set_attr)(int row, int col, int attr, int count);
  void (*scroll_up)(int top, int bot);
  void (*stack_screen)(void);
  void (*unstack_screen)(void);
  void (*discard_screen)(void);

  /* sound routines */
  int (*init_fm)(void);
  void (*buzzer)(int kind);
  void (*sound_on)(int frequency);
  void (*sound_off)(void);

};
typedef struct tagDriver Driver;

#define STD_DRIVER_STRUCT(name_) \
  { \
    "##name_##", \
    name_##_init, \
    name_##_terminate, \
    name_##_flush, \
    name_##_schedule_alarm, \
    name_##_start_video, \
    name_##_end_video, \
    name_##_window, \
    name_##_resize, \
    name_##_redraw, \
    name_##_read_palette, \
    name_##_write_palette, \
    name_##_read_pixel, \
    name_##_write_pixel, \
    name_##_read_span, \
    name_##_write_span, \
    name_##_set_line_mode, \
    name_##_draw_line, \
    name_##_get_key, \
    name_##_shell, \
    name_##_set_video_mode, \
    name_##_put_string, \
    name_##_set_for_text, \
    name_##_set_for_graphics, \
    name_##_set_clear, \
    name_##_find_font, \
    name_##_move_cursor, \
    name_##_hide_text_cursor, \
    name_##_set_attr, \
    name_##_scroll_up, \
    name_##_stack_screen, \
    name_##_unstack_screen, \
    name_##_discard_screen, \
    name_##_init_fm, \
    name_##_buzzer, \
    name_##_sound_on, \
    name_##_sound_off \
  }

#define HAVE_X11_DRIVER 1
#define HAVE_DISK_DRIVER 1

extern int init_drivers(int *argc, char **argv);
extern void close_drivers(void);

#define USE_DRIVER_FUNCTIONS 1

#if defined(USE_DRIVER_FUNCTIONS)

extern void driver_terminate(void);
extern void driver_flush(void);
extern void driver_schedule_alarm(int secs);
extern int driver_start_video(void);
extern int driver_end_video(void);
extern void driver_window(void);
extern int driver_resize(void);
extern void driver_redraw(void);
extern int driver_read_palette(void);
extern int driver_write_palette(void);
extern int driver_read_pixel(int x, int y);
extern void driver_write_pixel(int x, int y, int color);
extern void driver_read_span(int y, int x, int lastx, BYTE *pixels);
extern void driver_write_span(int y, int x, int lastx, BYTE *pixels);
extern void driver_set_line_mode(int mode);
extern void driver_draw_line(int x1, int y1, int x2, int y2);
extern int driver_get_key(int block);
extern void driver_shell(void);
extern void driver_set_video_mode(int ax, int bx, int cx, int dx);
extern void driver_put_string(int row, int col, int attr, const char *msg);
extern void driver_set_for_text(void);
extern void driver_set_for_graphics(void);
extern void driver_set_clear(void);
extern BYTE *driver_find_font(int parm);
extern void driver_move_cursor(int row, int col);
extern void driver_hide_text_cursor(void);
extern void driver_set_attr(int row, int col, int attr, int count);
extern void driver_scroll_up(int top, int bot);
extern void driver_stack_screen(void);
extern void driver_unstack_screen(void);
extern void driver_discard_screen(void);
extern int driver_init_fm(void);
extern void driver_buzzer(int kind);
extern void driver_sound_on(int frequency);
extern void driver_sound_off(void);

#else

extern Driver *display;
#define driver_terminate()        (*display->terminate)()
#define driver_flush()            (*display->flush)()
#define void driver_schedule_alarm(_secs) \
    (*display->schedule_alarm)(_secs)
#define driver_start_video()        (*display->start_video)()
#define driver_end_video()        (*display->end_video)()
#define driver_window()            (*display->window)()
#define driver_resize()            (*display->resize)()
#define driver_redraw()            (*display->redraw)()
#define driver_read_palette()        (*display->read_palette)()
#define driver_write_palette()        (*display->write_palette)()
#define driver_read_pixel(_x, _y)    (*display->read_pixel)(_x, _y)
#define driver_write_pixel(_x, _y, _color) \
    (*display->write_pixel)(_x, _y, _color)
#define driver_read_span(_y, _x, _lastx, _pixels) \
    (*display->read_span(_y, _x, _lastx, _pixels)
#define driver_write_span(_y, _x, _lastx, _pixels) \
    (*display->write_span)(_y, _x, _lastx, _pixels)
#define driver_set_line_mode(_m)    (*display->set_line_mode)(_m)
#define driver_draw_line(x1_, y1_, x2_, y2_) \
    (*display->draw_line)(x1_, y1_, x1_, y2_)
#define driver_get_key(_block)        (*display->get_key)(_block)
#define driver_shell()            (*display->shell)()
#define driver_set_video_mode(_ax, _bx, _cx, _dx) \
    (*display->set_video_mode)(_ax, _bx, _cx, _dx)
#define driver_put_string(_row, _col, _attr, _msg) \
    (*display->put_string)(_row, _col, _attr, _msg)
#define driver_set_for_text()        (*display->set_for_text)()
#define driver_set_for_graphics()    (*display->set_for_graphics)()
#define driver_set_clear()        (*display->set_clear)()
#define driver_find_font(_parm)        (*display->find_font)(_parm)
#define driver_move_cursor(_row, _col)    (*display->move_cursor)(_row, _col)
#define driver_hide_text_cursor()    (*display->hide_text_cursor)()
#define driver_set_attr(_row, _col, _attr, _count) \
    (*display->set_attr)(_row, _col, _attr, _count)
#define driver_scroll_up(_top, _bot) \
    (*display->scroll_up)(_top, _bot)
#define driver_stack_screen()        (*display->stack_screen)()
#define driver_unstack_screen()        (*display->unstack_screen)()
#define driver_discard_screen()        (*display->discard_screen)()
#define driver_init_fm()        (*display->init_fm)()
#define driver_buzzer(_kind)        (*display->buzzer)(_kind)()
#define driver_sound_on(_freq)        (*display->sound)(_freq)
#define driver_sound_off()        (*display->sound_off)()

#endif

#endif /* DRIVERS_H */

- ------- =_aaaaaaaaaa0--

- --------------------------------------------------------------
Thanks for using Fractdev, The Fractint Developer's Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractdev"

------------------------------

End of fractdev-digest V1 #22
*****************************