HDTenEightyP/NetNews huggingface dataset:
From: jlg@cochiti.lanl.gov (J. Giles)
Subject: Re: extra 8 bytes
Organization: Los Alamos National Laboratory
Date: Tue, 17 Nov 1992 20:00:54 GMT

In article <1e8i03INNecd@corax.udac.uu.se>, l@chiron.astro.uu.se (Lars Kamel) writes:
|> I have had the same problem when programming on a VAX/VMS system. Based on
|> my expirence, I propose that you change your code to (if your compiler
|> allows it):
|>       open( 10, file=file1, form='unformatted', recordtype='fixed',
|>      +          access='direct', recl=1000)
|>       write( 10, rec=1) (real(i),i=1,1000)

Please not that the above conforms to the standard with two exceptions:

1) the `recordtype' specifier is not standard

2) technically, the standard only accepts upper case letters ;-)

On most implementations, you can use lower case. On most applications,
the record length information is not written to disk for direct access
files.  Few implementations hav the recordtype specifier.

Note that a standard conforming implementation is not *required* to
omit the record length marks for direct access files.  It's just that
most of them do.  If yours doesn't, you'll have to write a non-Fortran
filter to get rid of them after Fortran is done.

This subject *should* be covered in the FAQ for this newsgroup.  So
far I've not seen one consistently posted though.

-- 
J. Giles
Newsgroups: comp.lang.fortran
From: ercolessi@uimrl3.mrl.uiuc.edu (furio ercolessi)
Subject: Re: Jumping from nested subroutine to main directly?
Reply-To: ercolessi@uimrl3.mrl.uiuc.edu (furio ercolessi)
Organization: MRL - UIUC
Date: Sun, 22 Nov 1992 04:58:25 GMT

In article <1992Nov21.222705.20726@monu6.cc.monash.edu.au>, map@hal.maths.monash.edu.au (Michael
Page) writes:
|>>== John H. Chauvin <jchauvin@netcom.com> writes:
|>>>
|>>>  Is it possible to transfer control from a nested subroutine directly to the 
|>>>  main routine without have to execute multiple returns from all the 
|>>>  subroutines in between?  I would like a way of exiting directly to the main 
|>>>  routine when a error is detected six or seven subroutines down.
|>
|>One way to almost do what he wants is to use an ENTRY statement at the 
|>point he wants to return to in the main program.  However, I suspect he 
|>wants something a bit more `automatic' than that, but I don't think it 
|>exists in FORTRAN.  Does it exist in C, Pascal, ..?

Hmmmm ... so do you think it is really possible to do something like

	program main
1	continue
	...
	call level1(...)
	...
	stop
	entry backtomain
*	   pretend we can 'restart' program
	goto 1
	end

	subroutine level1(...)
	...
	call level2(...)
	...
	end

	subroutine level2(...)
	...
	if (troubles) call backtomain
	...
	end

and 'fall' in 'backtomain' from level2 as many times as we want? 
my guess is that this can be done but eats stack space because
no one ever returns. well actually it looks like a form of recursion,
where we do not need to retain data from previous calls, so
is this a form of pseudo-recursion allowed by Fortran?
--
Furio Ercolessi
Materials Research Laboratory           |   Intl School for Advanced Studies
Univ. of Illinois at Urbana-Champaign   |   Trieste, Italy
furio@uiuc.edu                          |   furio@sissa.it
Newsgroups: comp.lang.fortran
From: Dave Dodson <dodson@convex.COM>
Subject: Re: How does one return a logical value...???
Originator: dodson@bach.convex.com
Date: Thu, 19 Nov 1992 15:49:07 GMT
Reply-To: dodson@convex.COM (Dave Dodson)
Organization: Engineering, CONVEX Computer Corp., Richardson, Tx., USA
X-Disclaimer: This message was written by a user at CONVEX Computer
              Corp. The opinions expressed are those of the user and
              not necessarily those of CONVEX.

>In article <BxwrJC.GME@cs.uiuc.edu>, ctaylor@cs.uiuc.edu (Conrad W Taylor) writes:
>         IF (CheckActivity(previous, ROWS, COLS) .EQ.  .TRUE.) THEN
>           uncontrol = uncontrol + 1
>         ENDIF
> 
> My compiler says that I have mixed types when I use .TRUE. .  

The problem is that .EQ. does an arithmetic comparison.  If you
want to do a logical comparison, use .EQV.:

	 IF (CheckActivity(previous, ROWS, COLS) .EQV. .TRUE.) THEN

or, since CheckActivity (presumably) returns a logical value, just write

	 IF (CheckActivity(previous, ROWS, COLS)) THEN

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

Dave Dodson		                             dodson@convex.COM
Convex Computer Corporation      Richardson, Texas      (214) 497-4234
Newsgroups: comp.lang.fortran
Subject: Jumping from nested subroutine to main directly?
From: jchauvin@netcom.com (John H. Chauvin)
Date: Sat, 21 Nov 1992 01:50:26 GMT
Organization: Netcom - Online Communication Services  (408 241-9760 guest) 

Is it possible to transfer control from a nested subroutine directly to the 
main routine without have to execute multiple returns from all the 
subroutines in between?  I would like a way of exiting directly to the main 
routine when a error is detected six or seven subroutines down.


Thanks

jchauvin@netcom.com
Northrop Advanced Technology and Design Center
Pico Rivera, California

-- 
John H. Chauvin jchauvin@netcom.COM
Netcom - Online Communication Services San Jose, CA
Newsgroups: comp.lang.fortran
From: jchauvin@netcom.com (John H. Chauvin)
Subject: Multiple returns (was: Jumping from nested subs to main directly)
Organization: Netcom - Online Communication Services  (408 241-9760 guest) 
Date: Mon, 23 Nov 1992 02:10:53 GMT


I would like to thank everyone who responded to my 
original posting. Unfortunately, in my haste to post the 
original message, I neglected to fully explain my 
problem. My use of the word "Jumping" may have been 
misleading. I was looking for a simple way to simulate 
multiple returns back to the main routine without having 
to add the code to all the subroutines to force a return 
if an error is detected upon exiting a subroutine. The 
ENTRY solution proposed does not fit the bill because I 
have not RETURNed to main. What would be nice is a form 
of RETURN that would allow the programmer to return back 
more than one subroutine.For example, let say that I 
want to return from SUB3 to SUB1 directly. I would just 
execute a command like EXIT 2 or something like that.I 
do not believe this is currently possible? Any comments?



PROGRAM EXAMPLE
CALL SUB1
.
.
.
STOP
END
SUB1
CALL SUB2
A=A+1
END
SUB2
CALL SUB3
END
SUB3
 
EXIT 2 (Returned to statement A=A+1 in one call)

END

Thanks for the help

jchauvin@netcom.com
-- 
John H. Chauvin jchauvin@netcom.COM
Netcom - Online Communication Services San Jose, CA
Newsgroups: comp.lang.fortran
From: jchauvin@netcom.com (John H. Chauvin)
Subject: Data initialization: FORTRAN program called as SUBROUTINE
Organization: Netcom - Online Communication Services  (408 241-9760 guest) 
Date: Wed, 18 Nov 1992 02:59:12 GMT


I am currently working on a mix language program in which a C program 
calls a large FORTRAN program ( 15,000 lines , 100+ SUBROUTINES, 
and extensive use of COMMON blocks). I have converted the main routine 
from the FORTRAN into a SUBROUTINE and am calling the routine from 
the C code. I pass file information from the C program to the FORTRAN 
program using C data structures to FORTRAN common blocks. The 
general program flow is: C calls FORTRAN , waits, FORTRAN updates C, 
FORTRAN returns to C, C calls FORTRAN ,etc.. The C and FORTRAN 
routines are linked into one large binary program. All FORTRAN variables 
required SAVE status. The main advantage to the above approach is the 
ease to which I can exchange data between the C (graphics front end) and 
the FORTRAN (number crunchier).

Everything works great until I try and call the FORTRAN a second time. 
The variables and COMMON blocks still retain values from the first call. 
(Not surprisingly) How can I reinitialize all the COMMON blocks and 
variables to the state that existed at the beginning of the first call?  
Normally the FORTRAN would be executed as a stand alone program 
from the command line , loaded into memory and the variables initialized 
each time it is used. This is the behavior I want to achieve with each call to 
the FORTRAN. Initializing all the variables myself is out of the questions 
because of the size of the code and the fact that all the variables have 
been SAVEd. Is there a way to do this?  Any help or suggestions would be 
GREATLY appreciated.


Thanks

jchauvin@netcom.com

-------------------------- Configuration Information -------------------------------------
Workstation:           Silicon Graphics Crimson Elan with 64 mb RAM
Operating System      IRIX 4.0.5A (AT&T UNIX with Berkeley extensions)
Development Options.....v4.1
FORTRAN & C Compilers    v3.10
--------------------------------------------------------------------------------------------------
-- 
John H. Chauvin jchauvin@netcom.COM
Netcom - Online Communication Services San Jose, CA
From: ecronan@maths.tcd.ie (Eoin Cronan)
Newsgroups: comp.lang.fortran
Subject: f2c sources wanted
Date: 17 Nov 92 11:54:27 GMT
Organization: Dept. of Maths, Trinity College, Dublin, Ireland.

Is there a fortran to c converter somewhere in archives is some ftp site?
	It is necessary for me to get a hold of a converter.Could anyone mail
me a list of ftp sites that might house one?
		Thanks in advance
			Eoin
Newsgroups: comp.lang.fortran
From: KARGL@rzmain.rz.uni-ulm.de (ComRam)
Subject: VAX FORTRAN passing mech. for CHARACTER*1
Organization: Chaos Computer Club Ulm
Date: Mon, 23 Nov 1992 08:34:12 GMT
X-News-Reader: VMS NEWS 1.24

Just a short question :
How does VAX FORTRAN pass a CHARACTER*1 Variable to a subroutine ?
It seems to be neither Value nor Reference or F.-L. Descriptor or am I
wrong here ?

Please answer by E-Mail.


-------------------------------------------------------------------------------
 ComRam  (in real life : Frank Kargl)   Student Consultant for VMS-Programming
 Internet      : COMRAM@RZ.UNI-ULM.DE   University of Ulm          Germany
 DECnet(Belwue): 50186::KARGL           All statements posted above are
 Bitnet        : KARGL@DULRUU51.BITNET  my personal oppinion ONLY !
-------------------------------------------------------------------------------
  Use the SOURCE, Luke!             I feel a great disturbance in the SOURCE.
Newsgroups: comp.lang.fortran
From: rvenable@helix.nih.gov (Richard M. Venable)
Subject: Re: Fortran debugger on UNIX/ULTRIX..??????? 
Keywords: Fortran,Debugger
Reply-To: rvenable@helix.nih.gov (Richard M. Venable)
Organization: National Institutes of Health
Date: Fri, 20 Nov 1992 23:17:05 GMT

In article <1992Nov20.163928.15907@risky.ecs.umass.edu>,
katragad@risky.ecs.umass.edu (Prasanna B Katragadda) writes:
|> Can anybody give me info on FORTRAN debuggers on UNIX or ULTRIX....

The standard SysV Unix debugger is called 'dbx'; many vendors offer
something better, though.
From: dik@cwi.nl (Dik T. Winter)
Newsgroups: comp.lang.fortran
Subject: Re: Jumping from nested subroutine to main directly?
Date: 23 Nov 92 23:54:34 GMT
Organization: CWI, Amsterdam

In article <1992Nov21.015026.17820@netcom.com> jchauvin@netcom.com (John H. Chauvin) writes:
 > Is it possible to transfer control from a nested subroutine directly to the 
 > main routine without have to execute multiple returns from all the 
 > subroutines in between?  I would like a way of exiting directly to the main 
 > routine when a error is detected six or seven subroutines down.
 > 
There is a highly non-portable way that works on some systems:
	SUBROUTINE A()
	COMMON /JMPBCK/ ILAB
	ASSIGN 10 TO ILAB
	CALL B()
10	CONTINUE
	RETURN
	END
...
	SUBROUTINE Z()
	COMMON /JMPBCK/ ILAB
	GOTO ILAB
	END
but with systems that use a stack for Fortran programs (as most current
systems do) this will fail.

Should I add a smiley?
-- 
dik t. winter, cwi, kruislaan 413, 1098 sj  amsterdam, nederland
home: bovenover 215, 1025 jn  amsterdam, nederland; e-mail: dik@cwi.nl
From: silvert@biome.bio.ns.ca (Bill Silvert)
Subject: Re: The History of Fortran
Reply-To: silvert@biome.bio.dfo.ca (Bill Silvert)
Organization: Habitat Ecology Div., Bedford Inst. Oceanography
Date: Mon, 16 Nov 1992 22:37:38 GMT

In <1992Nov16.183236.26882@newshost.lanl.gov> jlg@cochiti.lanl.gov (J. Giles) writes:

>|> Hollerith predates Fortran by many years.  He was a US census official
>|> who came up with the idea of using punched cards to store census data.

>Actually, the idea he came up with was to automate the census by 
>using tabulating machines.  In fact, he invented the very *idea* of 
>tabulating machines themselves.  The use of cards was a matter of 
>convenience: there were already automated devices for manupulating 
>money - these bill sorters and other hardware could be directly
>incorporated into his new machinery.  The idea of representing
>the information as *holes* in the paper/cardboard "bills" was
>*not* Hollerith's (nor was it Jacquard's - whose loom Hollerith
>got the idea from - it came from the age-old use of holes-in-paper
>to mark the positioning of required pegs in automated musical
>instruments).

It is true that flat objects with holes in them were first used for
organ-like instruments and later adapted to weaving (Jacquard was only
one of many inventors to refine this idea).  I think that the key idea
of Hollerith was that one could sort (or tabulate) with them, although 
I am not familiar with bill sorters of the time.  My understanding was
that he was really the founder of data processing, but that might be
wrong.  However, I can guarantee that whatever we credit him with, 
there will be a posting that someone else did it first!

By the way, I don't know how authoritative it is, but James Burke does
a great job with this in Connections.
-- 
------------------------------------------------------------------------
William Silvert, Habitat Ecology Division, Bedford Inst. of Oceanography
P. O. Box 1006, Dartmouth, Nova Scotia, CANADA B2Y 4A2.  Tel. (902)426-1577
InterNet Address: silvert@biome.bio.dfo.ca
From: wjs@re3sc139h.gmr.com
Newsgroups: comp.lang.fortran
Subject: REQ: "lint" checker for Fortran.
Date: 16 Nov 92 15:55:58 GMT
Distribution: usa
Organization: GM / EDS

Is there a public domain lint or data type checker for Fortran 
source available ?   I looked for this info in a FAQ for this
group, but could not find the FAQ list.  Please respond by direct
email.

		Much thanks in advance !

		Walt Stuart   wjs@re3sc139h.gmr.com
		GM/EDS Research Labs
		Warren, Mi
Newsgroups: comp.lang.fortran
From: peppe@ipgaix.unipg.it (G. Vitillaro)
Subject: Fortran on 386 UNIX platforms
Summary: f77 on UNIX platforms
Keywords: Fortran, 386, 486, UNIX
Organization: Universita' di Perugia
Date: Sun, 22 Nov 1992 20:03:50 GMT

I'm reporting a question a person here in the local
University asked to me, for what I'm unable to give
an answer.

He would like to setup a 486 with 16Mb of RAM and 200/300Mb
of HD as a Scientific WS. He would like to use it both
as an X interface and to do some scientific Computation.

I'm aware of many commercial and PD UNIX platforms that
may be used to transform a 486 50Mhz in something similar
to an advanced WS, but I still lack one important info.

The person here wants to be able to efficiently compile,
under this system, Fortran 77 code and, if possible, have
BLAS 1,2,3 available. 

Anyone know some information on this topic? What I'm looking
for is a Fortran 77 compiler, with BLAS3 libraries, that
can produce efficient x87 floating point or Witek code
under a 386 UNIX platofrm.

Thank in advance for any help, if this will be a common
interest I may summarize the answers for the net,
Regards  G. Vitillaro
-- 
Giuseppe Vitillaro - IBM SEMEA      |  E-Mail : peppe@ipgaix.unipg.it 
University of Perugia Italy         |  06100 Perugia  Phone:+39.75.585-2200
---------------------------------------------------------------------------
All comments/opinions are mine and don't represent those of IBM
From: sandee@Think.COM (Daan Sandee)
Newsgroups: comp.lang.fortran
Subject: Re: How does one return a logical value...???
Date: 18 Nov 1992 12:19:36 GMT
Organization: TMC
Distribution: world
NNTP-Posting-Host: telecaster.think.com

In article <BxwrJC.GME@cs.uiuc.edu>, ctaylor@cs.uiuc.edu (Conrad W Taylor) writes:
|>         IF (CheckActivity(previous, ROWS, COLS) .EQ.  .TRUE.) THEN
|>           uncontrol = uncontrol + 1
|>         ENDIF
|> 
|> My compiler says that I have mixed types when I use .TRUE. .  

I don't know why it would object to .TRUE. Like that, (CAPITALS, dots
immediately adjoining the keyword (yes, I've known compilers to complain
about . TRUE .)) it is standard Fortran. However,

        IF (CheckActivity(previous, ROWS, COLS) )  THEN

also works. Your variable being a logical, you can test on it immediately.


Daan Sandee                                           sandee@think.com
Thinking Machines Corporation
Cambridge, Mass 02142                                 (617) 234-5044
Organization: Penn State University
Date: Wed, 18 Nov 1992 00:34:46 EST
From: <SXL17@psuvm.psu.edu>
Newsgroups: comp.lang.fortran
Subject: extended memory

Hi
Will anybody give me a tip about how to compile and run a huge program
at a pc using extended memory?
Thanks in advance.

Sunpyo Lee
Newsgroups: comp.lang.fortran
From: walt@netcom.com (Walt Brainerd)
Subject: Re: Understanding ENTRY and Recursion (was Re: ENTRY in main)
Summary: Recursion is standard Fortran 90
Organization: Netcom - Online Communication Services  (408 241-9760 guest) 
Date: Mon, 23 Nov 1992 22:12:37 GMT

> No, recursion is not legal in standard FORTRAN.  You can't make it so by
> duplicating subroutines and renaming one of them.

Recursion is legal in the current standard Fortran,
which is Fortran 90, adopted as the ISO standard in 1991,
adopted as an ANSI standard in 1992.
-- 
Walt Brainerd                walt@netcom.com
Unicomp, Inc.                +1-415-949-4052
235 Mt. Hamilton Ave.        +1-415-949-4058 (fax)
Los Altos, CA 94022 USA      "F90--Fortran for the '90s"
From: mdlcpgs@lhn.gns.cri.nz
Newsgroups: comp.lang.fortran
Subject: Re: Turning VAX FORTRAN IOSTAT returns into VMS status codes?
Date: Sun, 15 Nov 92 21:03:38 GMT  
Organization: Institute of Gelogical & Nuclear Sciences, New Zealand.

>From: lionel@quark.enet.dec.com (Steve Lionel)
>Subj: Re: Turning VAX FORTRAN IOSTAT returns into VMS status codes?

>|>Hi. I wonder if anyone can tell me how to turn a VAX FORTRAN
>|>IOSTAT status return value into a VMS status for signalling
>|>by LIB$SIGNAL?  I cant in this application use ERRSNS because
>|>the error of interest may not be the last io transaction on
>|>the file at the time when I want to signal.
>
>Here's a function that does it.  It's a bit wordier than I might have hacked
  [ excellent code removed. See original message ]

Thanks Lionel, precisely what I needed. Take the PG Scadden Award for being
a Scholar and a Gentleman.

Thanks also to others who posted or replied.
	Phil Scadden.
Newsgroups: comp.lang.fortran
From: fairfield@slacvx.slac.stanford.edu
Subject: Re: passing a string constant to a subroutine
Organization: Stanford Linear Accelerator Center
Date: Fri, 20 Nov 1992 03:28:55 GMT

In article <EJH.92Nov19160031@khonshu.colorado.edu>, ejh@khonshu.colorado.edu (Edward J. Hartnett) writes:
> When I want to pass a string constant to a subroutine, what size do I
> declare the character variable to be in the subprogram. For example
> I have a subroutine:
> 
>       subroutine ask_data_type(prog, typenum)
> 
> This is intended to be called from one of several programs, and the
> program name is to be passed in as the first parameter. Inside the
> subroutine I have:
>       character*20 prog

[description of incorrect execution, etc., deleted]

    Within your subroutine, declare PROG so:

	CHARACTER*(*) PROG

This is called a "passed-length character argument".  If ASK_DATA_TYPE 
needs to know the length of PROG, use LEN(PROG).  This is all standard 
Fortran 77.

 > But I'm just wondering if what I did was non-standard or what.

    Not non-standard, just a "programming error" ;-)  That is, you called
ASK_DATA_TYPE with an actual argument that didn't match the declaration 
of the dummy argument within ASK_DATA_TYPE.  The same kind of thing would
happen if the subroutine declared one of its dummy arguments to be
DOUBLE PRECISION but you called it with a REAL...

	Cheers, Ken
-- 
 Dr. Kenneth H. Fairfield    |  Internet: Fairfield@Slac.Stanford.Edu
 SLAC, P.O.Box 4349, MS 98   |  DECnet:   45537::FAIRFIELD (45537=SLACVX)
 Stanford, CA   94309        |  BITNET    Fairfield@Slacvx
 ----------------------------------------------------------------------------
 These opinions are mine, not SLAC's, Stanford's, nor the DOE's...
From: gerardo@ferris.cray.com (Gerardo Cisneros)
Newsgroups: comp.lang.fortran
Subject: Re: How does one return a logical value...???
Date: 18 Nov 92 14:56:18 GMT
Organization: Cray Research, Inc.
Originator: gerardo@ferris


In article <1edccoINNkab@early-bird.think.com>, sandee@Think.COM (Daan Sandee) writes:
> In article <BxwrJC.GME@cs.uiuc.edu>, ctaylor@cs.uiuc.edu (Conrad W Taylor) writes:
> |>         IF (CheckActivity(previous, ROWS, COLS) .EQ.  .TRUE.) THEN
> |>           uncontrol = uncontrol + 1
> |>         ENDIF
> |> 
> |> My compiler says that I have mixed types when I use .TRUE. .  
> 
> I don't know why it would object to .TRUE. Like that, (CAPITALS, dots
> immediately adjoining the keyword (yes, I've known compilers to complain
> about . TRUE .)) it is standard Fortran. [...]

It is not standard Fortran.  ANSI X3.9-1978 allows relational expressions
e1 relop e2 only for e1 and e2 both arithmetic expressions or both
character expressions.  If CheckActivity is really declared as a LOGICAL
FUNCTION, then there is no need (and no point) to compare it to .TRUE.
-- 
Gerardo Cisneros		|Cray Research de M'exico, S.A. de C.V.
gerardo.cisneros@cray.com	|Camino a Sta. Teresa 480-A #302
(+52+5)622-8584 		|14020 Tlalpan, D.F., MEXICO
 Anything I said sound like an opinion? Then it's no one's but my own.
Newsgroups: comp.lang.fortran
From: ejh@khonshu.colorado.edu (Edward J. Hartnett)
Subject: passing a string constant to a subroutine
Organization: CIRES, University of Colorado
Date: 19 Nov 92 16:00:31

When I want to pass a string constant to a subroutine, what size do I
declare the character variable to be in the subprogram. For example
I have a subroutine:

      subroutine ask_data_type(prog, typenum)

This is intended to be called from one of several programs, and the
program name is to be passed in as the first parameter. Inside the
subroutine I have:
      character*20 prog

And when I called if from program atob.f this is what the call looked
like:
	call ask_data_type('atob',typenum)

I assumed that it would put 'atob' in prog and blank fill the rest.
What it did instead was fill the rest with grabage, not blanks. I
avoid this problem now by doing this in the calling program:

      character*20 prog
      parameter (prog = 'atob')
c
      write(*,*) 'about to call ask_data_type'
      call ask_data_type(prog,typenum)

But I'm just wondering if what I did was non-standard or what.


--
Edward Hartnett			ejh@khonshu.colorado.edu
From: mstemper@ems.cdc.com (Michael Stemper)
Newsgroups: comp.lang.fortran
Subject: Re: passing a string constant to a subroutine
Date: 20 Nov 92 15:14:27 GMT
Reply-To: mstemper@ems.cdc.com
Organization: Empros Systems International, a division of Ceridian

In article <EJH.92Nov19160031@khonshu.colorado.edu>, ejh@khonshu.colorado.edu (Edward J. Hartnett) writes:
>When I want to pass a string constant to a subroutine, what size do I
>declare the character variable to be in the subprogram. For example
>I have a subroutine:
>
>      subroutine ask_data_type(prog, typenum)
>
>This is intended to be called from one of several programs, and the
>program name is to be passed in as the first parameter. Inside the
>subroutine I have:
>      character*20 prog

Replace that with:

       character*(*) prog

Then, every time ask_data_type gets called, prog will have the same
length as the variable passed to it.

-- 
#include <Standard_Disclaimer.h>
Michael F. Stemper
Power Systems Consultant
mstemper@ems.cdc.com