Hello,

On Sat, 8 Mar 2003 17:18:05 -0600, Alvaro Fernandez
<[log in to unmask]> wrote:

<snip>
>
>Subroutine Solve(Problem,OptAlg,Domain)
>
> Type(X),intent(in) :: Problem
>
> Type(Y),intent(in) :: OptAlg
>
> Type(Z),intent(in) :: Domain
>
>
>
>
>
>The Problem class I have outlined here is at the top of an inheritance
>hierarchy. Currently, "Solve" is "SolveDomain1D_PDS", and "X", "Y", and
>"Z" are all specific types coming from USE'd modules. The best thing
>would be to set what X, Y and Z are in a namelist and run the
>preprocessor. I do not at this point need to do dynamic binding and
>branch according to what "X" is, so I don't need a SELECT TYPE kind of
>functionality.

Would setting X, Y, Z in an include file suit the problem?

You could set X, Y, Z as text blocks in an include file,
and then copy the text block as needed.
>
>
>
>I have been looking at COCO and at f90ppr. Does either COCO or f90ppr
>allow me to do what I have outlined above? With COCO, what documentation
>I have found does not _seem_ to contemplate arbitrary types, just
>intrinsic. am I right about that?

coco has built-in definitions of the processor's supported intrinsic
types, if compiled with a standard_types module from the compiler
in question, but that doesn't mean it is intended in any way to be
hostile to derived types.

The text block and copy directives in my coco were added when I found
myself repeatedly copying, pasting, and then trivially substituting
when coding Fortran modules. You know, write the procedure for real
single, then copy and paste, then change single to double, then
paste, then change single to quad, etc. The text and copy directives
automate the cut and paste process. If defined with arguments,
the text and copy directives can make (small) edits, too.

The examples on my web site use intrinsic types to be simple
and easily understood.

I'm not certain I understand your question completely, but would
something like this help you?

?? text :: base
<definition of the type to be extended sans type/end type>
?? end text base

type :: base_t
?? copy :: base
end type base

type :: child_t
?? copy :: base
<more definitions>
end type child_t

If what you want is more along the lines of parameterized
derived types, the coco might help along these lines
(the integer substitution is an extension):

?? integer :: eg_size = 100

type :: my_type
... dimension( ?eg_size?) ...
end type my_type

?? integer :: new_size

?? new_size = eg_size * eg_size

type :: new_type
... dimension( ?new_size?) ...
end type new_type

I think, IIUYC, that combinations of text/copy, integer substitution,
and perhaps coco macros could be helpful. My coco will report
use of extensions if requested.

If you decide to use my coco, please advise of any experiences
you have, or of any features which would make your Fortran programming
easier. TIA

> With f90ppr, I have found little
>documentation, though I suppose it's similar to the C preprocessor (?).
>But, since I never used the C preprocessor, I am still at a loss. :-)
>

I'll let Michel Olagnon speak to f90ppr's abilities, I'm not sure
I know enough to do it justice. For those who may not have the links
handy, Moware may be found at

http://www.ifremer.fr//ditigo/molagnon/fortran90/contenu.html

and my stuff may be found at

http://users.erols.com/dnagle et seq.

<snip>

Putting everything together looks like this:

?? integer :: my_size = 100

?? text :: parent( kind)
real( kind= ?kind?_k), dimension( ?my_size?) :: thingos
?? end text parent

type :: parent_t
?? copy :: parent( double)
end type parent_t

?? my_size = 2 * my_size

type :: child_t
?? copy :: parent( double)
real( kind= double_k), dimension( ?my_size?) :: more_thingos
end type child_t

HTH

>Alvaro Fernandez

--
Cheers!

Dan Nagle
Purple Sage Computing Solutions, Inc.