From: mhiroshi@tansei.cc.u-tokyo.ac.jp (H. Murakami)
Newsgroups: fj.lang.fortran
Subject: f90 system info: quote.
Date: 22 Aug 92 13:12:26 GMT
Distribution: fj
Organization: Hokkaido Univ. However I am subject to tansei for JUNET.

TO:  fj.lang.fortran

$BB?>/8E$$$,(J, Fortran 90 $B$N=hM}7OF~<j$J$I$N>pJs$,=P$F$$$^$9(J.
$B3'$5$s$O6qBNE*$K$I$N=hM}7O$r$I$s$J%^%7%s$N>e$G<B:]$K;H$C$F$$$k$N$G$7$g$&$+(J?

( Sony$B$N?M$bFI$s$G$M(J. << $B0UL#ITL@(J? )

-------------------------------------------------------------------------------
                         $BJbJbJbJbJbJbJbJbJb(J              $BB<>e(J	$B90(J
PPPPPPPP                   $B3Q(J          $BHt(J
RNBQKBNR                 $B9a7K6d6b6L6b6d7K9a(J   mhiroshi@tansei.cc.u-tokyo.ac.jp

------------ $B0zMQ3+;O(J ----------------
From appserv!khb Tue Jun 16 16:39:20 JST 1992
Article: 3366 of comp.lang.fortran
From: khb@chiba.Eng.Sun.COM (Keith Bierman fpgroup)
Newsgroups: comp.lang.fortran
Subject: Re: F90 Query
Date: 14 Apr 92 20:38:13 GMT
Organization: Sun MegaSystems
NNTP-Posting-Host: chiba


I don't know of a FAQ for this group.

Fortran is an ISO standard (90 is not part of the formal name; the
spelling is mixed case).

Information about the standards document follows.

The only publically announced and shipping full "compiler" is the NAG
product. Details also follow.

There is a partial implementation which uses f77 rather than c as the
intermediate language.

Lahey has been aggressively marketing a program for vendors to chip in
and fianance their development. There is a newsletter one can get and
etc. 

My *personal* prediction is that pure sw ISVs will lead; as it provides
them maximum competitive advantage. Hardware vendors have installed
base, performance and other concerns paramount. However, in the long
run the hw vendors (and their corporate sidekicks) will probably take
over in the long run. 

f90 will have a long life, so getting a slightly late start is
irratating but not fatal.

All personal opinons. 

From: julian@cernvax.cern.ch (julian bunn)
Newsgroups: comp.lang.fortran
Subject: Fortran 90 Standard
Keywords: standard
Date: 13 Aug 91 06:51:57 GMT
Organization: CERN, Geneva, Switzerland

 
   The new Fortran 90 standard has now been formally published and is
available from the ISO central secretariat or from the national member
bodies. The price is about $120. Some ordering details follow. I can
supply addresses in other countries not mentioned on request (to
METCALF@CERNVM).
 
    The document reference is ISO/IEC 1539 : 1991. There is no ISBN.
 
    ISO
    1, rue de Varembe
    Case postale 56
    1211 Geneva 20
    Switzerland
    Fax: +41 22 734 10 79
 
    ANSI
    1430 Broadway
    New York, NY 10018
 
    BSI
    2 Park Street
    London W1A 2BS
 
    DIN
    Burggrafenstrasse 6
    Postfach 1107
    D-1000 Berlin 30
 
    AFNOR
    Tour Europe
    Cedex 7
    92049 Paris La Defence
 
    SSC
    350 Sparks Street
    Suite 1200
    Ottowa, Ontario, K1P 6N7
 
 
 
                            Mike Metcalf
                            (metcalf@cernvm)

and from walt@netcom.com

For those of you who don't read comp.lang.fortran,
you might be interested to know that I just called
Global Engineering to see if the sell ISO 1539:1991.
They do; the price is $225.

And 

You can obtain copies through:
	Global Engineering Documents
	2805 McGaw Ave.
	Irvine, CA. 92714
	(714) 261-1455
	(800) 854-7179

The FORTRAN-90 standard will run you about $75 US.
-- 
Richard Gorton               rcg@lpi.liant.com  (508) 626-0006
Liant Software Corp.         Framingham, MA 01760 USA

From: Walt.Brainerd@Eng (Walt Brainerd)
Message-Id: <9106112107.AA10180@boise.Eng.Sun.COM>
To: x3j3@ncsa.uiuc.edu
Subject: NAG F90 announcement

This is the day the NAG announcement is official, I believe,
so I am sending you what was in this issue of the _Fortran Journal_.
Sorry for the troff source--

.Title "The First Fortran 90 Implementation"
.\" Confidential until June 10 1991
The approval of Fortran 90 as an international standard was
reported in the
.r "Fortran Journal"
in just the last issue.
Now we are pleased to learn of the world's first Fortran 90
implementation, available soon from Numerical Algorithms Group, Ltd.
This article presents some information about this software
and other NAG activities of interest to the Fortran programmer.
.pp
NAG has the first announced compiler that implements all of Fortran 90.
The output language is Kernighan and Ritchie C,
chosen to make it portable to many architectures and operating systems.
It has been tested extensively.
.sub.head "Design Goals"
The design goals of the development were:
.in.level bu
.ip
to produce a true compiler, not just a translator
.ip
to provide good speed of compilation and reasonable efficiency of execution
.ip
to provide good error checking with comprehensible error messages
.ip
to produce a full standard-conforming compiler, with all
constraints identified
.ip
to provide \f2no\fP language extensions
.ip
to produce a modular system that can be modified easily
and used to build other software tools and compilers
.out.level
NAG has been able to produce this compiler in such a timely manner
because they started early and maintained commitment to the development.
Experiments in Fortran 90 compiler
construction started at NAG as long ago as 1987.
The current system is the result
of nearly 18 months development by Malcolm Cohen and others at the NAG
offices in Oxford, UK.
.pp
The NAG f90 compiler is not a
.q "stretched"
Fortran\ 77 system, enhanced beyond its original design.
NAG has continuously tracked the discussions, debates, and draft standards
proposed for Fortran 90 since the Fortran 8X saga began
and has incorporated the changes as agreed into the compiler design.
It is a true compiler in that it utilizes global information
to generate the resulting C code.
.pp
Testing of the NAGWare f90 Compiler has gone on continuously during development.
NAG has encouraged the early development of an extensive
Fortran 90 test suite by Brian Smith,
a leading member of the standardization activity;
this test suite has been used at all stages
to ensure conformance of the activity.
Additionally, NAG's commitment to Fortran 90 and the development
of Fortran 90 based facilities has meant the compiler has received
extensive internal use.
.pp
The use of modular construction and tools such as \f2yacc\fP
mean that
the compiler is supportable and a separate maintenance
service is available.
Extensive error messages are given by the compiler,
both those required by the ISO standard and additional information.
The messages are informative rather than cryptic and often contain context
information to assist in identifying and rectifying the problem.
For this reason the compiler is particularly suited to teaching
and for programmers wishing to update their skills to the new language,
as well as those who want to develop Fortran 90 programs.
.sub.head "Implementation Methodology"
The compiler is written in Kernighan and Ritchie\ C.
The two independent lexers (one per source form) are hand coded.
The parser is generated using \f2yacc\fP with additional error recovery added.
.pp
The compiler has four passes, and the passes have been kept distinct to improve
maintainability and to allow re-use of the components in tools and
customized compilation systems.
The four passes are as follows:
.nr ip1.type 0
.in.level
.nr ip1.indent .8i
.nr ip1.hang .8i
.ip "Pass\ 1:"
Lexical and syntactic analysis is performed; the symbol table and abstract
syntax tree are built.
.ip "Pass\ 2:"
Semantic analysis is done; the parse tree is annotated;
the symbol table is filled in;
all major error and constraint detection takes place.
.ip "Pass\ 3:"
Code is generated form the parse tree transformation.
.ip "Pass\ 4:"
The code is output; declarations are generated;
the flattened parse tree is transformed to K&R C source code
(the system can be modified to produce other dialects).
.out.level
.nr ip1.type 1
.pp
Passes 1 and 2 have been undergoing beta test for many months.
Passes 3 and 4 are being completed at present and have recently
undergone internal alpha-test.
By the end of June, 1991, the complete system, including the
run-time library, will have been throughly beta tested.
.pp
The compiler will have the full range of intrinsic functions
described in the ISO standard.
Intrinsics are implemented using a combination of a run-time library and
in-line code (produced by the code generator), depending on
efficiency and implementation complexity.
.pp
The compiler will have a full implementation of the
input/output capabilities of the standard,
including list-directed, formatted and unformatted,
namelist, and nonadvancing input/output.
Input/output will be handled through a run-time library written in C.
.sub.head "Documentation"
Documentation of the system will be brief.
A note will describe the installation of the software
and a short document will be provided to describe its use
and any implementation specific information.
In addition, NAG intends to provide a copy of the book
.i "Fortran 90 Explained"
by Mike Metcalf and John Reid.
.pp
Because of the implementation language chosen (Kernighan and Ritchie\ C),
the compiler and its output code will be highly portable.
During porting, however, there may need to be modifications to ensure variable
storage is correctly aligned (i.e. byte aligned, short aligned or long
aligned).
The performance of the compiled Fortran 90 code will be directly
dependent upon the C system and run-time libraries employed.
.sub.head "Debugging"
In general the C code resulting from the compiler is legible.
It contains directives that set the file name and line number
so that run-time errors are reported with respect to the original
Fortran 90 source line.
These directives also allow the relationship between the Fortran 90 code
and the resulting C code to be more clearly understood.
The Fortran 90 variable names are maintained in the source code.
A semantics checking version of the compiler
(one without the third and fourth phases) is available
and this can dump a human readable form of the parse tree and
symbol table information.
.sub.head "Availability"
NAG will be launching the NAGWare f90 Compiler in June 1991.
The compiler will be available initially on some Unix workstations.
The system will be provided to the user in executable form only.
Later implementations will include non-Unix hosts.
The licensing of the system will be on a per-machine basis.
Costs will be scaled by machine power.
Annual maintenance will be available.
The user will require access to a C compiler and run-time system;
normally the one provided by the hardware or operating system
vendor will suffice.
.pp
In addition to selling the portable version of the compiler NAG is prepared
to sell or license the Fortran 90 compiler technology to interested parties.
The nature of the sales is open to discussion and negotiation.
For example, it is possible to use the
compiler front-end (passes 1 and 2) to link in with existing code
generation, optimization, and tool technologies.
In addition, NAG is willing
to discuss consultancy to assist in modifying the compiler to integrate it
into existing or planned systems, back-ends, and language extensions.
.last.line -28P
.sub.head "Other Fortran 90 Activities at NAG"
Much of the testing is being undertaken in association with the development
of a comprehensive Fortran 90 test suite.
NAG will be launching the test suite as a product aimed at compiler writers
during the second or third quarter of 1991.
NAG will also be announcing a Fortran 90 Compiler/Tool Validation Service.
A Fortran 90 tool suite containing polishing, transformation,
and analysis tools will be launched in the near future.
A Fortran 90 numerical library is undergoing development.
.sub.head "Fortran 77 Tools"
NAGWare f77 Tools will also be launched during June 1991.
They are a collection of tools for processing, analyzing,
and transforming Fortran 77 source code.
These programs include a
.q "pretty printer" ,
a declaration standardizer,
a tool to change from single to double precision or vice versa,
a restructuring tool,
and a program to provide a static analysis of a whole program,
producing a call graph,
and a portability verifier.
The tools can be used in a range of ways\(emquality assurance,
standardization, porting support or simply in
association with normal development.
Regular use of the tools will speed
development by helping to prevent and find errors and in making the source
code easier to read and understand.
Real benefits can be gained from the
use of the tools during maintenance of existing software as the checks help
to ensure that modifications are properly applied and that the style of the
code remains consistent.
.pp
For more information about the NAG Fortran 90 compiler
and other tools, contact:
.list.start i
In the UK:
NAG Ltd.
Wilkinson House
Jordan Hill Road
Oxford, OX2 8DR, UK
+44 865 511245  865 310139 (fax)
.sp .5
In the US:
NAG Inc.
1400 Opus Place, Suite 200
Downers Grove, IL 60515-5702 USA
+1 708/971-2337  971-2706 (fax)
.list.end

From:    roman@flea1.Parasoft.COM (Roman Salvador)
Subject: f90->f77 xlator

   We have the creature. I first attach the info that appeared in the
Fortran Journal:

--------------------------------------------------------------------
			Pf90: A Portable Fortran 90 Processor.

'Pf90' is a package that lets you run programs written in Fortran 90
on any machine that supports Fortran 77. The package consists of
a translator from Fortran 90 to Fortran 77, a library for the new
Fortran 90 intrinsics and a driver that will take care of calling
the translator and compiling and linking the resulting program using
the local Fortran 77 compiler and the Fortran 90 libraries.

The first release of the package will be in the summer of 91, and it
will incorporate the following Fortran 90 extensions:

- All array extensions: whole-array operations, array sections,
  vector-valued subscripts, user-defined array-valued functions,
  automatic arrays, assumed-size arrays, where statement, array
  constructors.
- All new array intrinsics.
- Interfaces.
- Optional and keyword arguments.
- New source forms (free and fixed).
- Symbolic relational operators.
- Include statement.
- Attribute specifiers in type declaratins.
- Implicit none.
- Forall statement.

>From the point of view of the user, the package works as a normal
compiler. For example to compile the program 'foo.f9' written in
Fortran 90 one only needs to do:

$ f90 -o foo foo.f9

The package is going to be initially available in machines supporting
Fortran 77 and under either the UNIX or MS-DOS operating systems.

For more information contact Roman Salvador at:

Email: roman@gaudi.caltech.edu

Phone: (818) 7929941.

Mail: ParaSoft Corporation
      2500 E. Foothill Blvd., # 205
      Pasadena, CA 91107
--------------------------------------------------------------------

To this info I can add that the first version is going to be
available in September and that it is also going to include modules
and the new control constructs. We have currently a beta-release for
SUN4s. Let me know if you need more info.

#to unbundle, /bin/sh this file
echo README 1>&2
cat >README <<'End of README'
   This directory contains 2 sources of information:


Info.ps: this is a postscrip file with a description of the product plus availa
bility
       and ordering information.

f90.1: this is the man-page for the product. It is in nroff format, to look at 
it
       do:

       - to see it on the workstation or terminal screen:

       $ nroff -man f90.1 | more 

       - to get a hard copy of it:

       $ troff -t -man f90.1 | lpr -t
End of README
echo Info.ps 1>&2
cat >Info.ps <<'End of Info.ps'
%!
%%BoundingBox: (atend)
%%Pages: (atend)
%%DocumentFonts: (atend)
%%EndComments
%
% FrameMaker PostScript Prolog 3.0, for use with FrameMaker 3.0
% Copyright (c) 1986,87,89,90,91 by Frame Technology Corporation.
% All rights reserved.
%
% Known Problems:
%	Due to bugs in Transcript, the 'PS-Adobe-' is omitted from line 1
/FMversion (3.0) def 
% Set up Color vs. Black-and-White
	/FMPrintInColor systemdict /colorimage known
		systemdict /currentcolortransfer known or def
% Uncomment this line to force b&w on color printer
%   /FMPrintInColor false def
/FrameDict 195 dict def 
systemdict /errordict known not {/errordict 10 dict def
		errordict /rangecheck {stop} put} if
% The readline in 23.0 doesn't recognize cr's as nl's on AppleTalk
FrameDict /tmprangecheck errordict /rangecheck get put 
errordict /rangecheck {FrameDict /bug true put} put 
FrameDict /bug false put 
mark 
% Some PS machines read past the CR, so keep the following 3 lines together!
currentfile 5 string readline
00
0000000000
cleartomark 
errordict /rangecheck FrameDict /tmprangecheck get put 
FrameDict /bug get { 
	/readline {
		/gstring exch def
		/gfile exch def
		/gindex 0 def
		{
			gfile read pop 
			dup 10 eq {exit} if 
			dup 13 eq {exit} if 
			gstring exch gindex exch put 
			/gindex gindex 1 add def 
		} loop
		pop 
		gstring 0 gindex getinterval true 
		} def
	} if
/FMVERSION {
	FMversion ne {
		/Times-Roman findfont 18 scalefont setfont
		100 100 moveto
		(FrameMaker version does not match postscript_prolog!)
		dup =
		show showpage
		} if
	} def 
/FMLOCAL {
	FrameDict begin
	0 def 
	end 
	} def 
	/gstring FMLOCAL
	/gfile FMLOCAL
	/gindex FMLOCAL
	/orgxfer FMLOCAL
	/orgproc FMLOCAL
	/organgle FMLOCAL
	/orgfreq FMLOCAL
	/yscale FMLOCAL
	/xscale FMLOCAL
	/manualfeed FMLOCAL
	/paperheight FMLOCAL
	/paperwidth FMLOCAL
/FMDOCUMENT { 
	array /FMfonts exch def 
	/#copies exch def
	FrameDict begin
	0 ne dup {setmanualfeed} if
	/manualfeed exch def
	/paperheight exch def
	/paperwidth exch def
	/yscale exch def
	/xscale exch def
	currenttransfer cvlit /orgxfer exch def
	currentscreen cvlit /orgproc exch def
	/organgle exch def /orgfreq exch def
	setpapername 
	manualfeed {true} {papersize} ifelse 
	{manualpapersize} {false} ifelse 
	{desperatepapersize} if
	end 
	} def 
	/pagesave FMLOCAL
	/orgmatrix FMLOCAL
	/landscape FMLOCAL
/FMBEGINPAGE { 
	FrameDict begin 
	/pagesave save def
	3.86 setmiterlimit
	/landscape exch 0 ne def
	landscape { 
		90 rotate 0 exch neg translate pop 
		}
		{pop pop}
		ifelse
	xscale yscale scale
	/orgmatrix matrix def
	gsave 
	} def 
/FMENDPAGE {
	grestore 
	pagesave restore
	end 
	showpage
	} def 
/FMFONTDEFINE { 
	FrameDict begin
	findfont 
	ReEncode 
	1 index exch 
	definefont 
	FMfonts 3 1 roll 
	put
	end 
	} def 
/FMFILLS {
	FrameDict begin
	array /fillvals exch def
	end 
	} def 
/FMFILL {
	FrameDict begin
	 fillvals 3 1 roll put
	end 
	} def 
/FMNORMALIZEGRAPHICS { 
	newpath
	0.0 0.0 moveto
	1 setlinewidth
	0 setlinecap
	0 0 0 sethsbcolor
	0 setgray 
	} bind def
	/fx FMLOCAL
	/fy FMLOCAL
	/fh FMLOCAL
	/fw FMLOCAL
	/llx FMLOCAL
	/lly FMLOCAL
	/urx FMLOCAL
	/ury FMLOCAL
/FMBEGINEPSF { 
	end 
	/FMEPSF save def 
	/showpage {} def 
	FMNORMALIZEGRAPHICS 
	[/fy /fx /fh /fw /ury /urx /lly /llx] {exch def} forall 
	fx fy translate 
	rotate
	fw urx llx sub div fh ury lly sub div scale 
	llx neg lly neg translate 
	} bind def
/FMENDEPSF {
	FMEPSF restore
	FrameDict begin 
	} bind def
FrameDict begin 
/setmanualfeed {
%%BeginFeature *ManualFeed True
	 statusdict /manualfeed true put
%%EndFeature
	} def
/max {2 copy lt {exch} if pop} bind def
/min {2 copy gt {exch} if pop} bind def
/inch {72 mul} def
/pagedimen { 
	paperheight sub abs 16 lt exch 
	paperwidth sub abs 16 lt and
	{/papername exch def} {pop} ifelse
	} def
	/papersizedict FMLOCAL
/setpapername { 
	/papersizedict 14 dict def 
	papersizedict begin
	/papername /unknown def 
		/Letter 8.5 inch 11.0 inch pagedimen
		/LetterSmall 7.68 inch 10.16 inch pagedimen
		/Tabloid 11.0 inch 17.0 inch pagedimen
		/Ledger 17.0 inch 11.0 inch pagedimen
		/Legal 8.5 inch 14.0 inch pagedimen
		/Statement 5.5 inch 8.5 inch pagedimen
		/Executive 7.5 inch 10.0 inch pagedimen
		/A3 11.69 inch 16.5 inch pagedimen
		/A4 8.26 inch 11.69 inch pagedimen
		/A4Small 7.47 inch 10.85 inch pagedimen
		/B4 10.125 inch 14.33 inch pagedimen
		/B5 7.16 inch 10.125 inch pagedimen
	end
	} def
/papersize {
	papersizedict begin
		/Letter {lettertray letter} def
		/LetterSmall {lettertray lettersmall} def
		/Tabloid {11x17tray 11x17} def
		/Ledger {ledgertray ledger} def
		/Legal {legaltray legal} def
		/Statement {statementtray statement} def
		/Executive {executivetray executive} def
		/A3 {a3tray a3} def
		/A4 {a4tray a4} def
		/A4Small {a4tray a4small} def
		/B4 {b4tray b4} def
		/B5 {b5tray b5} def
		/unknown {unknown} def
	papersizedict dup papername known {papername} {/unknown} ifelse get
	end
	/FMdicttop countdictstack 1 add def 
	statusdict begin stopped end 
	countdictstack -1 FMdicttop {pop end} for 
	} def
/manualpapersize {
	papersizedict begin
		/Letter {letter} def
		/LetterSmall {lettersmall} def
		/Tabloid {11x17} def
		/Ledger {ledger} def
		/Legal {legal} def
		/Statement {statement} def
		/Executive {executive} def
		/A3 {a3} def
		/A4 {a4} def
		/A4Small {a4small} def
		/B4 {b4} def
		/B5 {b5} def
		/unknown {unknown} def
	papersizedict dup papername known {papername} {/unknown} ifelse get
	end
	stopped 
	} def
/desperatepapersize {
	statusdict /setpageparams known
		{
		paperwidth paperheight 0 1 
		statusdict begin
		{setpageparams} stopped pop 
		end
		} if
	} def
/savematrix {
	orgmatrix currentmatrix pop
	} bind def
/restorematrix {
	orgmatrix setmatrix
	} bind def
/dmatrix matrix def
/dpi    72 0 dmatrix defaultmatrix dtransform
    dup mul exch   dup mul add   sqrt def
/freq dpi 18.75 div 8 div round dup 0 eq {pop 1} if 8 mul dpi exch div def
/sangle 1 0 dmatrix defaultmatrix dtransform exch atan def
/DiacriticEncoding [
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/.notdef /.notdef /.notdef /.notdef /space /exclam /quotedbl
/numbersign /dollar /percent /ampersand /quotesingle /parenleft
/parenright /asterisk /plus /comma /hyphen /period /slash /zero /one
/two /three /four /five /six /seven /eight /nine /colon /semicolon
/less /equal /greater /question /at /A /B /C /D /E /F /G /H /I /J /K
/L /M /N /O /P /Q /R /S /T /U /V /W /X /Y /Z /bracketleft /backslash
/bracketright /asciicircum /underscore /grave /a /b /c /d /e /f /g /h
/i /j /k /l /m /n /o /p /q /r /s /t /u /v /w /x /y /z /braceleft /bar
/braceright /asciitilde /.notdef /Adieresis /Aring /Ccedilla /Eacute
/Ntilde /Odieresis /Udieresis /aacute /agrave /acircumflex /adieresis
/atilde /aring /ccedilla /eacute /egrave /ecircumflex /edieresis
/iacute /igrave /icircumflex /idieresis /ntilde /oacute /ograve
/ocircumflex /odieresis /otilde /uacute /ugrave /ucircumflex
/udieresis /dagger /.notdef /cent /sterling /section /bullet
/paragraph /germandbls /registered /copyright /trademark /acute
/dieresis /.notdef /AE /Oslash /.notdef /.notdef /.notdef /.notdef
/yen /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/ordfeminine /ordmasculine /.notdef /ae /oslash /questiondown
/exclamdown /logicalnot /.notdef /florin /.notdef /.notdef
/guillemotleft /guillemotright /ellipsis /.notdef /Agrave /Atilde
/Otilde /OE /oe /endash /emdash /quotedblleft /quotedblright
/quoteleft /quoteright /.notdef /.notdef /ydieresis /Ydieresis
/fraction /currency /guilsinglleft /guilsinglright /fi /fl /daggerdbl
/periodcentered /quotesinglbase /quotedblbase /perthousand
/Acircumflex /Ecircumflex /Aacute /Edieresis /Egrave /Iacute
/Icircumflex /Idieresis /Igrave /Oacute /Ocircumflex /.notdef /Ograve
/Uacute /Ucircumflex /Ugrave /dotlessi /circumflex /tilde /macron
/breve /dotaccent /ring /cedilla /hungarumlaut /ogonek /caron
] def
/ReEncode { 
	dup 
	length 
	dict begin 
	{
	1 index /FID ne 
		{def} 
		{pop pop} ifelse 
	} forall 
	0 eq {/Encoding DiacriticEncoding def} if 
	currentdict 
	end 
	} bind def
/graymode true def
	/bwidth FMLOCAL
	/bpside FMLOCAL
	/bstring FMLOCAL
	/onbits FMLOCAL
	/offbits FMLOCAL
	/xindex FMLOCAL
	/yindex FMLOCAL
	/x FMLOCAL
	/y FMLOCAL
/setpattern {
	 /bwidth  exch def
	 /bpside  exch def
	 /bstring exch def
	 /onbits 0 def  /offbits 0 def
	 freq sangle landscape {90 add} if 
		{/y exch def
		 /x exch def
		 /xindex x 1 add 2 div bpside mul cvi def
		 /yindex y 1 add 2 div bpside mul cvi def
		 bstring yindex bwidth mul xindex 8 idiv add get
		 1 7 xindex 8 mod sub bitshift and 0 ne
		 {/onbits  onbits  1 add def 1}
		 {/offbits offbits 1 add def 0}
		 ifelse
		}
		setscreen
	 {} settransfer
	 offbits offbits onbits add div FMsetgray
	/graymode false def
	} bind def
/grayness {
	FMsetgray
	graymode not {
		/graymode true def
		orgxfer cvx settransfer
		orgfreq organgle orgproc cvx setscreen
		} if
	} bind def
	/HUE FMLOCAL
	/SAT FMLOCAL
	/BRIGHT FMLOCAL
	/Colors FMLOCAL
FMPrintInColor 
	
	{
	/HUE 0 def
	/SAT 0 def
	/BRIGHT 0 def
	% array of arrays Hue and Sat values for the separations [HUE BRIGHT]
	/Colors   
	[[0    0  ]    % black
	 [0    0  ]    % white
	 [0.00 1.0]    % red
	 [0.37 1.0]    % green
	 [0.60 1.0]    % blue
	 [0.50 1.0]    % cyan
	 [0.83 1.0]    % magenta
	 [0.16 1.0]    % comment / yellow
	 ] def
      
	/BEGINBITMAPCOLOR { 
		BITMAPCOLOR} def
	/BEGINBITMAPCOLORc { 
		BITMAPCOLORc} def
	/BEGINBITMAPTRUECOLOR { 
		BITMAPTRUECOLOR } def
	/BEGINBITMAPTRUECOLORc { 
		BITMAPTRUECOLORc } def
	/K { 
		Colors exch get dup
		0 get /HUE exch store 
		1 get /BRIGHT exch store
		  HUE 0 eq BRIGHT 0 eq and
			{1.0 SAT sub setgray}
			{HUE SAT BRIGHT sethsbcolor} 
		  ifelse
		} def
	/FMsetgray { 
		/SAT exch 1.0 exch sub store 
		  HUE 0 eq BRIGHT 0 eq and
			{1.0 SAT sub setgray}
			{HUE SAT BRIGHT sethsbcolor} 
		  ifelse
		} bind def
	}
	
	{
	/BEGINBITMAPCOLOR { 
		BITMAPGRAY} def
	/BEGINBITMAPCOLORc { 
		BITMAPGRAYc} def
	/BEGINBITMAPTRUECOLOR { 
		BITMAPTRUEGRAY } def
	/BEGINBITMAPTRUECOLORc { 
		BITMAPTRUEGRAYc } def
	/FMsetgray {setgray} bind def
	/K { 
		pop
		} def
	}
ifelse
/normalize {
	transform round exch round exch itransform
	} bind def
/dnormalize {
	dtransform round exch round exch idtransform
	} bind def
/lnormalize { 
	0 dtransform exch cvi 2 idiv 2 mul 1 add exch idtransform pop
	} bind def
/H { 
	lnormalize setlinewidth
	} bind def
/Z {
	setlinecap
	} bind def
	/fillvals FMLOCAL
/X { 
	fillvals exch get
	dup type /stringtype eq
	{8 1 setpattern} 
	{grayness}
	ifelse
	} bind def
/V { 
	gsave eofill grestore
	} bind def
/N { 
	stroke
	} bind def
/M {newpath moveto} bind def
/E {lineto} bind def
/D {curveto} bind def
/O {closepath} bind def
	/n FMLOCAL
/L { 
 	/n exch def
	newpath
	normalize
	moveto 
	2 1 n {pop normalize lineto} for
	} bind def
/Y { 
	L 
	closepath
	} bind def
	/x1 FMLOCAL
	/x2 FMLOCAL
	/y1 FMLOCAL
	/y2 FMLOCAL
	/rad FMLOCAL
/R { 
	/y2 exch def
	/x2 exch def
	/y1 exch def
	/x1 exch def
	x1 y1
	x2 y1
	x2 y2
	x1 y2
	4 Y 
	} bind def
/RR { 
	/rad exch def
	normalize
	/y2 exch def
	/x2 exch def
	normalize
	/y1 exch def
	/x1 exch def
	newpath
	x1 y1 rad add moveto
	x1 y2 x2 y2 rad arcto
	x2 y2 x2 y1 rad arcto
	x2 y1 x1 y1 rad arcto
	x1 y1 x1 y2 rad arcto
	closepath
	16 {pop} repeat
	} bind def
/C { 
	grestore
	gsave
	R 
	clip
	} bind def
	/FMpointsize FMLOCAL
/F { 
	FMfonts exch get
	FMpointsize scalefont
	setfont
	} bind def
/Q { 
	/FMpointsize exch def
	F 
	} bind def
/T { 
	moveto show
	} bind def
/RF { 
	rotate
	0 ne {-1 1 scale} if
	} bind def
/TF { 
	gsave
	moveto 
	RF
	show
	grestore
	} bind def
/P { 
	moveto
	0 32 3 2 roll widthshow
	} bind def
/PF { 
	gsave
	moveto 
	RF
	0 32 3 2 roll widthshow
	grestore
	} bind def
/S { 
	moveto
	0 exch ashow
	} bind def
/SF { 
	gsave
	moveto
	RF
	0 exch ashow
	grestore
	} bind def
/B { 
	moveto
	0 32 4 2 roll 0 exch awidthshow
	} bind def
/BF { 
	gsave
	moveto
	RF
	0 32 4 2 roll 0 exch awidthshow
	grestore
	} bind def
/G { 
	gsave
	newpath
	normalize translate 0.0 0.0 moveto 
	dnormalize scale 
	0.0 0.0 1.0 5 3 roll arc 
	closepath fill
	grestore
	} bind def
/A { 
	gsave
	savematrix
	newpath
	2 index 2 div add exch 3 index 2 div sub exch 
	normalize 2 index 2 div sub exch 3 index 2 div add exch 
	translate 
	scale 
	0.0 0.0 1.0 5 3 roll arc 
	restorematrix
	stroke
	grestore
	} bind def
	/x FMLOCAL
	/y FMLOCAL
	/w FMLOCAL
	/h FMLOCAL
	/xx FMLOCAL
	/yy FMLOCAL
	/ww FMLOCAL
	/hh FMLOCAL
	/FMsaveobject FMLOCAL
	/FMoptop FMLOCAL
	/FMdicttop FMLOCAL
/BEGINPRINTCODE { 
	/FMdicttop countdictstack 1 add def 
	/FMoptop count 4 sub def 
	/FMsaveobject save def
	userdict begin 
	/showpage {} def 
	FMNORMALIZEGRAPHICS 
	3 index neg 3 index neg translate
	} bind def
/ENDPRINTCODE {
	count -1 FMoptop {pop pop} for 
	countdictstack -1 FMdicttop {pop end} for 
	FMsaveobject restore 
	} bind def
/gn { 
	0 
	{	46 mul 
		cf read pop 
		32 sub 
		dup 46 lt {exit} if 
		46 sub add 
		} loop
	add 
	} bind def
	/str FMLOCAL
/cfs { 
	/str sl string def 
	0 1 sl 1 sub {str exch val put} for 
	str def 
	} bind def
/ic [ 
	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
	0
	{0 hx} {1 hx} {2 hx} {3 hx} {4 hx} {5 hx} {6 hx} {7 hx} {8 hx} {9 hx}
	{10 hx} {11 hx} {12 hx} {13 hx} {14 hx} {15 hx} {16 hx} {17 hx} {18 hx}
	{19 hx} {gn hx} {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12}
	{13} {14} {15} {16} {17} {18} {19} {gn} {0 wh} {1 wh} {2 wh} {3 wh}
	{4 wh} {5 wh} {6 wh} {7 wh} {8 wh} {9 wh} {10 wh} {11 wh} {12 wh}
	{13 wh} {14 wh} {gn wh} {0 bl} {1 bl} {2 bl} {3 bl} {4 bl} {5 bl} {6 bl
}
	{7 bl} {8 bl} {9 bl} {10 bl} {11 bl} {12 bl} {13 bl} {14 bl} {gn bl}
	{0 fl} {1 fl} {2 fl} {3 fl} {4 fl} {5 fl} {6 fl} {7 fl} {8 fl} {9 fl}
	{10 fl} {11 fl} {12 fl} {13 fl} {14 fl} {gn fl}
	] def
	/sl FMLOCAL
	/val FMLOCAL
	/ws FMLOCAL
	/im FMLOCAL
	/bs FMLOCAL
	/cs FMLOCAL
	/len FMLOCAL
	/pos FMLOCAL
/ms { 
	/sl exch def 
	/val 255 def 
	/ws cfs 
	/im cfs 
	/val 0 def 
	/bs cfs 
	/cs cfs 
	} bind def
400 ms 
/ip { 
	is 
	0 
	cf cs readline pop 
	{	ic exch get exec 
		add 
		} forall 
	pop 
	
	} bind def
/wh { 
	/len exch def 
	/pos exch def 
	ws 0 len getinterval im pos len getinterval copy pop
	pos len 
	} bind def
/bl { 
	/len exch def 
	/pos exch def 
	bs 0 len getinterval im pos len getinterval copy pop
	pos len 
	} bind def
/s1 1 string def
/fl { 
	/len exch def 
	/pos exch def 
	/val cf s1 readhexstring pop 0 get def
	pos 1 pos len add 1 sub {im exch val put} for
	pos len 
	} bind def
/hx { 
	3 copy getinterval 
	cf exch readhexstring pop pop 
	} bind def
	/h FMLOCAL
	/w FMLOCAL
	/d FMLOCAL
	/lb FMLOCAL
	/bitmapsave FMLOCAL
	/is FMLOCAL
	/cf FMLOCAL
/wbytes { 
	dup 
	8 eq {pop} {1 eq {7 add 8 idiv} {3 add 4 idiv} ifelse} ifelse
	} bind def
/BEGINBITMAPBWc { 
	1 {} COMMONBITMAPc
	} bind def
/BEGINBITMAPGRAYc { 
	8 {} COMMONBITMAPc
	} bind def
/BEGINBITMAP2BITc { 
	2 {} COMMONBITMAPc
	} bind def
/COMMONBITMAPc { 
	/r exch def
	/d exch def
	gsave
	translate rotate scale /h exch def /w exch def
	/lb w d wbytes def 
	sl lb lt {lb ms} if 
	/bitmapsave save def 
	r                    
	/is im 0 lb getinterval def 
	ws 0 lb getinterval is copy pop 
	/cf currentfile def 
	w h d [w 0 0 h neg 0 h] 
	{ip} image 
	bitmapsave restore 
	grestore
	} bind def
/BEGINBITMAPBW { 
	1 {} COMMONBITMAP
	} bind def
/BEGINBITMAPGRAY { 
	8 {} COMMONBITMAP
	} bind def
/BEGINBITMAP2BIT { 
	2 {} COMMONBITMAP
	} bind def
/COMMONBITMAP { 
	/r exch def
	/d exch def
	gsave
	translate rotate scale /h exch def /w exch def
	/bitmapsave save def 
	r                    
	/is w d wbytes string def
	/cf currentfile def 
	w h d [w 0 0 h neg 0 h] 
	{cf is readhexstring pop} image
	bitmapsave restore 
	grestore
	} bind def
	/proc1 FMLOCAL
	/proc2 FMLOCAL
	/newproc FMLOCAL
/Fmcc {
    /proc2 exch cvlit def
    /proc1 exch cvlit def
    /newproc proc1 length proc2 length add array def
    newproc 0 proc1 putinterval
    newproc proc1 length proc2 putinterval
    newproc cvx
} bind def
/ngrayt 256 array def
/nredt 256 array def
/nbluet 256 array def
/ngreent 256 array def
	/gryt FMLOCAL
	/blut FMLOCAL
	/grnt FMLOCAL
	/redt FMLOCAL
	/indx FMLOCAL
	/cynu FMLOCAL
	/magu FMLOCAL
	/yelu FMLOCAL
	/k FMLOCAL
	/u FMLOCAL
/colorsetup {
	currentcolortransfer
	/gryt exch def
	/blut exch def
	/grnt exch def
	/redt exch def
	0 1 255 {
		/indx exch def
		/cynu 1 red indx get 255 div sub def
		/magu 1 green indx get 255 div sub def
		/yelu 1 blue indx get 255 div sub def
		/k cynu magu min yelu min def
		/u k currentundercolorremoval exec def
		nredt indx 1 0 cynu u sub max sub redt exec put
		ngreent indx 1 0 magu u sub max sub grnt exec put
		nbluet indx 1 0 yelu u sub max sub blut exec put
		ngrayt indx 1 k currentblackgeneration exec sub gryt exec put
	} for
	{255 mul cvi nredt exch get}
	{255 mul cvi ngreent exch get}
	{255 mul cvi nbluet exch get}
	{255 mul cvi ngrayt exch get}
	setcolortransfer
	{pop 0} setundercolorremoval
	{} setblackgeneration
	} bind def
	/tran FMLOCAL
/fakecolorsetup {
	/tran 256 string def
	0 1 255 {/indx exch def 
		tran indx
		red indx get 77 mul
		green indx get 151 mul
		blue indx get 28 mul
		add add 256 idiv put} for
	currenttransfer
	{255 mul cvi tran exch get 255.0 div}
	exch Fmcc settransfer
} bind def
/BITMAPCOLOR { 
	/d 8 def
	gsave
	translate rotate scale /h exch def /w exch def
	/bitmapsave save def 
	colorsetup
	/is w d wbytes string def
	/cf currentfile def 
	w h d [w 0 0 h neg 0 h] 
	{cf is readhexstring pop} {is} {is} true 3 colorimage 
	bitmapsave restore 
	grestore
	} bind def
/BITMAPCOLORc { 
	/d 8 def
	gsave
	translate rotate scale /h exch def /w exch def
	/lb w d wbytes def 
	sl lb lt {lb ms} if 
	/bitmapsave save def 
	colorsetup
	/is im 0 lb getinterval def 
	ws 0 lb getinterval is copy pop 
	/cf currentfile def 
	w h d [w 0 0 h neg 0 h] 
	{ip} {is} {is} true 3 colorimage
	bitmapsave restore 
	grestore
	} bind def
/BITMAPTRUECOLORc { 
        gsave
        translate rotate scale /h exch def /w exch def
        /bitmapsave save def 
        
        /is w string def
        
        ws 0 w getinterval is copy pop 
        /cf currentfile def 
        w h 8 [w 0 0 h neg 0 h] 
        {ip} {gip} {bip} true 3 colorimage
        bitmapsave restore 
        grestore
        } bind def
/BITMAPTRUECOLOR { 
        gsave
        translate rotate scale /h exch def /w exch def
        /bitmapsave save def 
        /is w string def
        /gis w string def
        /bis w string def
        /cf currentfile def 
        w h 8 [w 0 0 h neg 0 h] 
        { cf is readhexstring pop } 
        { cf gis readhexstring pop } 
        { cf bis readhexstring pop } 
        true 3 colorimage 
        bitmapsave restore 
        grestore
        } bind def
/BITMAPTRUEGRAYc { 
        gsave
        translate rotate scale /h exch def /w exch def
        /bitmapsave save def 
        
        /is w string def
        
        ws 0 w getinterval is copy pop 
        /cf currentfile def 
        w h 8 [w 0 0 h neg 0 h] 
        {ip gip bip w gray} image
        bitmapsave restore 
        grestore
        } bind def
/ww FMLOCAL
/r FMLOCAL
/g FMLOCAL
/b FMLOCAL
/i FMLOCAL
/gray { 
        /ww exch def
        /b exch def
        /g exch def
        /r exch def
        0 1 ww 1 sub { /i exch def r i get .299 mul g i get .587 mul
			b i get .114 mul add add r i 3 -1 roll floor cvi put } 
for
        r
        } bind def
/BITMAPTRUEGRAY { 
        gsave
        translate rotate scale /h exch def /w exch def
        /bitmapsave save def 
        /is w string def
        /gis w string def
        /bis w string def
        /cf currentfile def 
        w h 8 [w 0 0 h neg 0 h] 
        { cf is readhexstring pop 
          cf gis readhexstring pop 
          cf bis readhexstring pop w gray}  image
        bitmapsave restore 
        grestore
        } bind def
/BITMAPGRAY { 
	8 {fakecolorsetup} COMMONBITMAP
	} bind def
/BITMAPGRAYc { 
	8 {fakecolorsetup} COMMONBITMAPc
	} bind def
/ENDBITMAP {
	} bind def
end 
	/ALDsave FMLOCAL
	/ALDmatrix matrix def ALDmatrix currentmatrix pop
/StartALD {
	/ALDsave save def
	 savematrix
	 ALDmatrix setmatrix
	} bind def
/InALD {
	 restorematrix
	} bind def
/DoneALD {
	 ALDsave restore
	} bind def
%%EndProlog
%%BeginSetup
(3.0) FMVERSION
1 1 612 792 0 1 22 FMDOCUMENT
0 0 /Helvetica-Bold FMFONTDEFINE
1 0 /Helvetica-BoldOblique FMFONTDEFINE
2 0 /Helvetica-Oblique FMFONTDEFINE
3 0 /Helvetica FMFONTDEFINE
4 0 /Times-Bold FMFONTDEFINE
5 0 /Times-Roman FMFONTDEFINE
6 0 /Courier FMFONTDEFINE
7 0 /Times-BoldItalic FMFONTDEFINE
8 0 /Times-Italic FMFONTDEFINE
32 FMFILLS
0 0 FMFILL
1 0.1 FMFILL
2 0.3 FMFILL
3 0.5 FMFILL
4 0.7 FMFILL
5 0.9 FMFILL
6 0.97 FMFILL
7 1 FMFILL
8 <0f1e3c78f0e1c387> FMFILL
9 <0f87c3e1f0783c1e> FMFILL
10 <cccccccccccccccc> FMFILL
11 <ffff0000ffff0000> FMFILL
12 <8142241818244281> FMFILL
13 <03060c183060c081> FMFILL
14 <8040201008040201> FMFILL
16 1 FMFILL
17 0.9 FMFILL
18 0.7 FMFILL
19 0.5 FMFILL
20 0.3 FMFILL
21 0.1 FMFILL
22 0.03 FMFILL
23 0 FMFILL
24 <f0e1c3870f1e3c78> FMFILL
25 <f0783c1e0f87c3e1> FMFILL
26 <3333333333333333> FMFILL
27 <0000ffff0000ffff> FMFILL
28 <7ebddbe7e7dbbd7e> FMFILL
29 <fcf9f3e7cf9f3f7e> FMFILL
30 <7fbfdfeff7fbfdfe> FMFILL
%%EndSetup
%%Page: "1" 1
%%BeginPaperSize: Letter
%%EndPaperSize
612 792 0 FMBEGINPAGE
72 72 540 720 R
7 X
0 K
V
0 24 Q
0 X
(PF90: Portable Fortran 90) 160.04 549 T
72 72 540 126 R
7 X
V
1 14 Q
0 X
(Para) 72 116.67 T
2 F
(Soft) 102.33 116.67 T
3 F
(Corporation) 131.12 116.67 T
3 10 Q
(Phone \050818\051 792-9941) 439.99 116.67 T
(2500 E.Foothill Blvd.) 72 101.33 T
(F) 450 101.33 T
(AX \050818\051 792-0819) 455.56 101.33 T
(Pasadena, CA 91) 72 89.33 T
(107) 149.6 89.33 T
(E-mail: f90-info@parasoft.com) 404.88 89.33 T
292.5 490.5 301.5 513 2 L
0.5 H
2 Z
N
328.5 490.5 306 499.5 2 L
N
328.5 526.5 319.5 504 2 L
N
292.5 526.5 315 517.5 2 L
N
301.5 513 315 517.5 319.5 504 306 499.5 4 Y
N
292.5 490.5 328.5 526.5 R
N
288 522 297 531 R
3 X
V
0 X
N
288 486 297 495 R
3 X
V
0 X
N
324 486 333 495 R
3 X
V
0 X
N
324 522 333 531 R
3 X
V
0 X
N
311.4 513.9 318.6 521.1 R
4 X
V
0 X
N
315.9 500.4 323.1 507.6 R
4 X
V
0 X
N
302.4 495.9 309.6 503.1 R
4 X
V
0 X
N
297.9 509.4 305.1 516.6 R
4 X
V
0 X
N
FMENDPAGE
%%EndPage: "1" 2
%%Page: "2" 2
612 792 0 FMBEGINPAGE
81 72 531 720 R
7 X
0 K
V
4 14 Q
0 X
(Introduction) 267.91 710.67 T
5 12 Q
0.21 ('Pf90' is a package that allows programs written in Fortran 90 to execute
 on any machine that) 81 664 P
1.46 (supports Fortran 77. The package consists of a translator from Fortran 90
 to Fortran 77, a) 81 650 P
-0.27 (library for the new Fortran 90 intrinsics and a driver which facilitates
 calling the translator and) 81 636 P
-0.74 (compiling and linking the resulting program using the local Fortran 77 c
ompiler and the Fortran) 81 622 P
(90 libraries.) 81 608 T
(The first release will incorporate the following Fortran 90 extensions:) 81 58
0 T
(\245) 99 552 T
-0.64 (All array extensions: whole-array operations, array sections,   vector-v
alued subscripts,) 117 552 P
(user-defined array-valued functions,   automatic arrays, assumed-size arrays,)
 117 538 T
6 F
(WHERE) 488.02 538 T
5 F
(statement, array constructors, ....) 117 524 T
(\245) 99 496 T
(All new array intrinsics.) 117 496 T
(\245) 99 468 T
(Interfaces.) 117 468 T
(\245) 99 440 T
(New control constructs.) 117 440 T
(\245) 99 412 T
(Optional and keyword arguments.) 117 412 T
(\245) 99 384 T
(New source forms \050free and fixed\051.) 117 384 T
(\245) 99 356 T
(Symbolic relational operators.) 117 356 T
(\245) 99 328 T
(Include statement.) 117 328 T
(\245) 99 300 T
(Attribute specifiers in type declarations.) 117 300 T
(\245) 99 272 T
(Implicit none.) 117 272 T
(\245) 99 244 T
6 F
(FORALL) 117 244 T
5 F
( statement.) 160.18 244 T
5 14 Q
(\245) 99 200.67 T
(Also supports all Connection Machine Fortran extensions.) 117 200.67 T
5 12 Q
-0.63 (From the point of view of the user, the package works as a conventional 
compiler. For example) 81 172 P
(to compile the program 'foo.f9' written in Fortran 90 the command is:) 81 158 
T
6 F
(f90 -o foo foo.f9) 244.83 130 T
FMENDPAGE
%%EndPage: "2" 3
%%Page: "3" 3
612 792 0 FMBEGINPAGE
72 72 540 720 R
7 X
0 K
V
0 14 Q
0 X
(Questions and Answers About Fortran 90) 167.99 710.67 T
4 12 Q
(Question:) 72 683.33 T
7 10 Q
(How is the translator invoked?) 162 683.33 T
4 12 Q
(Answer:) 72 663.33 T
5 10 Q
-0.35 (The translator is invoked through a driver called 'f90'. The driver will
 first translate the program) 162 663.33 P
0.14 (then compile and link it with the FORTRAN 77 compiler and the Fortran 90 
support libraries.) 162 651.33 P
(For example to compile 'file.f9' into the executable \325a.out\325, the comman
d is:) 162 639.33 T
6 F
(f90 file.f9) 216 615.33 T
4 12 Q
(Question:) 72 591.33 T
7 10 Q
(Which Fortran 77 compiler is used?) 162 591.33 T
4 12 Q
(Answer:) 72 571.33 T
5 10 Q
0.6 (The native FORTRAN 77 compiler of the host machine is used. For example,  
SUNs 'f77' is) 162 571.33 P
(used, on IBM RS6000 workstations 'xlf' is used, on IBM 3090s 'fvs' is used.) 1
62 559.33 T
4 12 Q
(Question:) 72 530.33 T
7 10 Q
(Can the compilation step be skipped, while generating only Fortran 77 code?) 1
62 530.33 T
4 12 Q
(Answer:) 72 510.33 T
5 10 Q
(Yes, the command:) 162 510.33 T
6 F
(f90 -t file.f9) 216 486.33 T
5 F
0.05 (will translate the code and place the FORTRAN 77 source in a file called 
\325file.f\325. There is also) 162 462.33 P
1.25 (a flag that causes the translator to leave the original Fortran 90 source
 as comments in the) 162 450.33 P
(translated FORTRAN 77 file. For example:) 162 438.33 T
6 F
(f90 -t -source file.f9) 216 414.33 T
5 F
(The FORTRAN 77 file can later on be used by the driver. For example:) 162 390.
33 T
6 F
(f90 file.f9) 216 366.33 T
5 F
(is equivalent to:) 162 342.33 T
6 F
(f90 -t file.f9) 216 318.33 T
(f90 file.f) 216 306.33 T
4 12 Q
(Question:) 72 280.33 T
7 10 Q
(Which code is debugged Fortran 77 or Fortran 90?) 162 280.33 T
4 12 Q
(Answer:) 72 260.33 T
5 10 Q
-0.54 (The FORTRAN 77 code is debugged using the native debugger for the FORTRA
N 77 compiler.) 162 260.33 P
-0.15 (The names of the local and external variables in the Fortran 90 source a
re left unchanged in the) 162 248.33 P
1.21 (FORTRAN 77 source. It is advised to use the) 162 236.33 P
6 F
2.89 (-source) 357.18 236.33 P
5 F
1.21 ( flag to leave the original code as) 399.16 236.33 P
0.17 (comments. For example to debug 'file.f9' in a machine whose debugger for 
the FORTRAN 77) 162 224.33 P
(compiler is ') 162 212.33 T
6 F
(dbx) 210.99 212.33 T
5 F
(' use:) 228.98 212.33 T
6 F
(f90 -g -source -f file.f9) 216 188.33 T
(dbx a.out) 216 176.33 T
5 F
0.83 (the option) 162 152.33 P
6 F
1.99 (-f) 206.41 152.33 P
5 F
0.83 ( causes the translated code to remain in 'file.f'. If the flag was not us
ed 'file.f\325') 218.4 152.33 P
(would be deleted at the end of the compilation.) 162 140.33 T
4 12 Q
(Question:) 72 116.33 T
7 10 Q
(Can one translate on one machine and run on another?) 162 116.33 T
4 12 Q
(Answer:) 72 92.33 T
5 10 Q
(No.) 162 92.33 T
FMENDPAGE
%%EndPage: "3" 4
%%Page: "4" 4
612 792 0 FMBEGINPAGE
72 72 540 720 R
7 X
0 K
V
4 12 Q
0 X
(Question:) 72 713.33 T
7 10 Q
(What documentation is included?) 162 713.33 T
4 12 Q
(Answer:) 72 693.33 T
5 10 Q
-0.37 (Included with the package is a Unix style manual-page, a copy of the boo
k) 162 693.33 P
8 F
-0.37 (Programmers Guide) 457.93 693.33 P
-0.44 (to Fortran 90) 162 681.33 P
5 F
-0.44 (, by W. Brainerd et al, and  an on-line version of the approved Fortran 
90 standard.) 215.55 681.33 P
4 12 Q
(Question:) 72 652.33 T
7 10 Q
(What about the future?) 162 652.33 T
4 12 Q
(Answer:) 72 632.33 T
5 10 Q
2.66 (ParaSoft is constantly adding additional Fortran 90 features to the trans
lator and a full) 162 632.33 P
(implementation should be available in the first quarter, 1992.) 162 620.33 T
4 12 Q
(Question:) 72 594.33 T
7 10 Q
-0.12 (What is I want to run under a machine or operating system that it is not
 in the list you have?) 162 594.33 P
4 12 Q
(Answer:) 72 574.33 T
5 10 Q
(Please contact us and we will port the package.) 162 574.33 T
FMENDPAGE
%%EndPage: "4" 5
%%Page: "5" 5
612 792 0 FMBEGINPAGE
72 72 540 720 R
7 X
0 K
V
72 72 540 720 C
72 93 540 708 C
72 99 540 702 R
7 X
0 K
V
1 24 Q
0 X
(Fortran 90) 202.39 654 T
4 F
( Pricelist) 319.68 654 T
8 18 Q
(Effective October 1, 1991) 213.57 614 T
5 F
(US Prices Only) 250.03 592 T
4 12 Q
(Part No) 114.94 517 T
(Description) 270.66 517 T
(Price) 437.17 517 T
(Notes) 489.46 517 T
5 10 Q
(PS-F90-SUN) 93.49 474.33 T
(Fortran 90 for Sun SP) 188.69 474.33 T
(ARC W) 275.5 474.33 T
(orkstations) 307.19 474.33 T
($2,000) 449.56 474.33 T
(i,ii) 489.04 474.33 T
(PS-F90-RIOS) 93.49 434.33 T
(Fortran 90 for IBM RS/6000 W) 188.69 434.33 T
(orkstation) 314.76 434.33 T
($2,000) 449.56 434.33 T
(i,ii) 489.04 434.33 T
(PS-F90-SGI) 93.49 394.33 T
(Fortran 90 for Silicon Graphics W) 188.69 394.33 T
(orkstations) 325.3 394.33 T
($2,000) 449.56 394.33 T
(i,ii) 489.04 394.33 T
(PS-F90-DEC) 93.49 354.33 T
(Fortran 90 for DEC DecStation \050Ultrix\051) 188.69 354.33 T
($2,000) 449.56 354.33 T
(i,ii) 489.04 354.33 T
(PS-F90-CONVEX) 93.49 314.33 T
(Fortran 90 for Convex System) 188.69 314.33 T
($5,000) 449.56 314.33 T
(i,ii) 489.04 314.33 T
(PS-F90-ALLIANT) 93.49 274.33 T
(Fortran 90 for Alliant FX/2800 System) 188.69 274.33 T
($5,000) 449.56 274.33 T
(i,ii) 489.04 274.33 T
(PS-F90-3090) 93.49 234.33 T
(Fortran 90 for IBM 3090/AIX System) 188.69 234.33 T
($10,000) 444.56 234.33 T
(i,ii) 489.04 234.33 T
(PS-F90-CRA) 93.49 194.33 T
(Y) 146.44 194.33 T
(Fortran 90 for Cray XMP) 188.69 194.33 T
(,YMP/UniCOS) 289.74 194.33 T
($10,000) 444.56 194.33 T
(i,ii) 489.04 194.33 T
87.49 541.75 87.49 176.25 2 L
V
0.5 H
0 Z
N
182.69 542.25 182.69 175.75 2 L
V
N
417.93 542.25 417.93 175.75 2 L
V
N
483.04 542.25 483.04 175.75 2 L
V
N
524.52 541.75 524.52 176.25 2 L
V
N
87.24 542 524.77 542 2 L
V
N
87.74 497.25 524.27 497.25 2 L
V
N
87.74 494.75 524.27 494.75 2 L
V
N
87.24 456 524.77 456 2 L
V
N
87.24 416 524.77 416 2 L
V
N
87.24 376 524.77 376 2 L
V
N
87.24 336 524.77 336 2 L
V
N
87.24 296 524.77 296 2 L
V
N
87.24 256 524.77 256 2 L
V
N
87.24 216 524.77 216 2 L
V
N
87.24 176 524.77 176 2 L
V
N
72 72 540 720 C
0 0 612 792 C
FMENDPAGE
%%EndPage: "5" 6
%%Page: "6" 6
612 792 0 FMBEGINPAGE
72 72 540 720 R
7 X
0 K
V
72 72 540 720 C
72 95 540 710 C
72 101 540 704 R
7 X
0 K
V
4 14 Q
0 X
(NOTES) 282.28 694.67 T
5 12 Q
(i\051) 90 673 T
1.35 (Not included in the package is the native Fortran 77 compiler) 117 673 P
1.35 (. The native Fortran 77) 424.33 673 P
(compiler is necessary) 117 659 T
(.) 219.47 659 T
(ii\051) 90 642 T
(The license is for use on 1 machine, with an unlimited number of users.) 117 6
42 T
4 F
(TERMS) 284.68 477 T
5 10 Q
(i\051) 90 461.33 T
0.23 (Prices are in U.S. dollars, FOB,) 117 461.33 P
8 F
0.23 (ParaSoft) 247.18 461.33 P
5 F
0.23 ( Inc., Pasadena, CA 91) 282.72 461.33 P
0.23 (107. Prices are subject to change without) 374.58 461.33 P
(notice. This list supersedes all previous lists.) 117 449.33 T
(ii\051) 90 434.33 T
(Prices shown apply in the United States only) 117 434.33 T
(. Overseas customers add 30%.) 295.41 434.33 T
(iii\051) 90 419.33 T
0.56 (Payment net 15 days from date of invoice upon approved credit and receipt
 of purchase order) 117 419.33 P
0.56 (. Any past) 498.08 419.33 P
-0.19 (due balance is subject to a late char) 117 407.33 P
-0.19 (ge of 1.5% per month. A $25 char) 256.73 407.33 P
-0.19 (ge will be assessed on all late checks.) 391.47 407.33 P
(iv\051) 90 392.33 T
-0.11 (30 days free support is included with the system. Support for additional
 periods can be arranged as a sepa-) 117 392.33 P
(rate maintenance contract - see below) 117 380.33 T
(.) 267.05 380.33 T
4 12 Q
(MAINTENANCE) 260.03 353 T
5 10 Q
-0.2 (Yearly maintenance can be purchased with all systems at an annual rate of
 20% of the original purchase price. Includ-) 72 338.33 P
(ed are regular updates and documentation.) 72 326.33 T
72 101 540 704 C
75.73 489 536.27 625 C
299.18 508 533.18 616 R
7 X
0 K
V
4 10 Q
0 X
(Additional Items) 380.22 608 T
4 8 Q
(Part No) 316.86 579.67 T
(Description) 403.68 579.67 T
(Price) 500.45 579.67 T
5 F
(PS-F90-TEXT) 306.08 559.67 T
(Programmers Guide to Fortran 90,) 366.51 559.67 T
(by Brainerd et al, published by) 366.51 549.67 T
(Intertext Publications) 366.51 539.67 T
($30) 514.29 559.67 T
300.08 591.75 300.08 532.25 2 L
V
0.5 H
0 Z
N
360.51 592.25 360.51 531.75 2 L
V
N
486.38 592.25 486.38 531.75 2 L
V
N
532.28 591.75 532.28 532.25 2 L
V
N
299.83 592 532.53 592 2 L
V
N
300.33 571.25 532.03 571.25 2 L
V
N
300.33 568.75 532.03 568.75 2 L
V
N
299.83 532 532.53 532 2 L
V
N
80.73 508 264.73 616 R
7 X
V
4 10 Q
0 X
(Shipping/Handling) 132.17 608 T
4 8 Q
(Carrier) 133.41 579.67 T
(Price) 218.29 579.67 T
5 F
(UPS ground, within U.S. \0505 days\051) 86.73 559.67 T
($35) 237.9 559.67 T
-0.07 (Federal Express, within U.S. \0502 days\051) 86.73 541.67 P
($55) 237.9 541.67 T
(Overseas \050Federal Express\051) 86.73 523.67 T
($145) 233.9 523.67 T
80.73 591.75 80.73 516.25 2 L
V
N
212.29 592.25 212.29 515.75 2 L
V
N
255.9 591.75 255.9 516.25 2 L
V
N
80.48 592 256.15 592 2 L
V
N
80.98 571.25 255.65 571.25 2 L
V
N
80.98 568.75 255.65 568.75 2 L
V
N
80.48 552 256.15 552 2 L
V
N
80.48 534 256.15 534 2 L
V
N
80.48 516 256.15 516 2 L
V
N
72 101 540 704 C
72 95 540 710 C
72 72 540 720 C
0 0 612 792 C
FMENDPAGE
%%EndPage: "6" 7
%%Trailer
%%BoundingBox: 0 0 612 792
%%Pages: 6 1
%%DocumentFonts: Helvetica-Bold
%%+ Helvetica-BoldOblique
%%+ Helvetica-Oblique
%%+ Helvetica
%%+ Times-Bold
%%+ Times-Roman
%%+ Courier
%%+ Times-BoldItalic
%%+ Times-Italic
End of Info.ps
echo f90.1 1>&2
cat >f90.1 <<'End of f90.1'
.\" @(#)f90.1 1.0 91/09/01 SMI; 
.TH F90 1 "1 September 1991"
.SH NAME
f90 \- ParaSoft Corporation Fortran 90 and CM Fortran processor
.SH SYNOPSIS
\fBf90\fP 
[ \fB\-90\fR ]
[ \fB\-dryrun\fR ]
[ \fB\-e\fR ]
[ \fB\-f\fR ]
[ \fB\-fixed\fR ]
[ \fB\-free\fR ]
[ \fB\-help\fR ]
[ \fB\-I\fIpathname\fR ] 
[ \fB\-obsolescent\fR ]
[ \fB\-pass \fIstring\fR ] 
[ \fB\-t\fR ]
.if t .ti +.5i
[ \fB\-V\fR ]
[ \fB\-v\fR ]
[ \fB\-version\fR ]
[ \fB\-w\fR ]
[ \fIflags accepted by FORTRAN 77 driver\fR ]
.if n .ti +5
\0\0\fIsourcefile\fR .\|.\|.
.SH DESCRIPTION
.LP
.B f90
is a package that allows execution of programs written in a subset of
Fortran 90 and in Connection Machine Fortran (CM Fortran). The package
consists of a translator from Fortran 90 to
.SM FORTRAN
77, libraries for support and for
the Fortran 90 array intrinsics, and a driver. The package should only
be accessed through
.BR f90 ,
the driver.
The driver calls the translator and the native
.SM FORTRAN
77 compiler of the host machine.
.LP
.B f90
is used in a manner similar to that of a standard compiler.
For example to compile the program 
.B test.f9
and produce an executable called
.B test
use
.B 'f90 -o test test.f9'.
.LP
.B f90
scans the command line looking for flags and files. 
Files with names ending in 
.B .f9
are taken to be Fortran 90 source files and are translated
to
.SM FORTRAN
77.
Files with names ending in
.B .fcm
are taken to be CM Fortran source files and are translated
following the CM Fortran conventions.
When all
.B .f9
and
.B .fcm
files are translated, the local
.SM FORTRAN
77 compiler is
invoked with the flags not recognized by
.BR f90 ,
the translated files, the files with suffixes other than
.B .f9
and
.B .fcm
and with the Fortran 90 support libraries.
.LP
.SH OPTIONS
See the man page for the
.SM FORTRAN
77 compiler for compile-time options.
.TP 1i
.B \-90
Identify extensions to Fortran 90.
.TP
.B \-dryrun
Show but do not execute the commands invoked by the driver.
.TP
.B \-e
In fixed form accept lines up to 132 characters long.
.TP
.B \-f
Keep intermediate
.SM FORTRAN
77 source.
.TP
.B \-fixed
Fortran 90 source in is \fBfixed\fR format. This is the default.
.TP
.B \-free
Fortran 90 source in is \fBfree\fR format.
.TP
.B \-help
Displays the list of options.
.TP
.BI \-I pathname
Add 
.I pathname
to the list of directories in which to search for
.B include 
files with relative filenames (not beginning with 
.BR  / ).
The preprocessor first searches for 
.B include 
files in the directory containing
.I sourcefile,
and then in directories named with
.B \-I
options (if any).
.TP
.B \-obsolescent
Flag obsolescent features.
.TP
.BI \-pass " string"
Add
.I string
to the list of arguments passed to the 
.SM FORTRAN
77 compiler.
.TP
.B \-source
Put original Fortran 90 source lines as comments in the
translated
.SM FORTRAN
77 file.
.TP
.B \-t
Translate to
.SM FORTRAN
77 only. Puts translated source in a file with the
same name and with the suffix used for
.SM FORTRAN
77 files.
.TP
.B \-V
Report programs invoked by the driver.
.TP
.B \-v
Report programs invoked by the driver. Propagate flag to the
.SM FORTRAN
77 compiler.
.TP
.B \-version.
Print version information.
.TP
.B \-w
Do not pring warning messages.
.LP
Other arguments are taken to be either 
.B f77 option
arguments, or
.BR f77
-compatible
source programs.
.SH FILES
.PD 0
.TP 1.25i
.IB file .f9
Fortran 90 source file.
.TP
.IB file .fcm
CM Fortran source file.
.TP
.IB file .f
Translated
.SM FORTRAN
77 program.
.TP
.B ./bin/f90
driver
.TP
.B ./bin/f9t
translator
.TP
.B ./demo
directory with demo programs.
.TP
.B ./lib/intrin.itf
support interface file for Fortran 90 source.
.TP
.B ./lib/intrincm.itf
support interface file for CM Fortran source.
.TP
.B ./lib/intern.a
support library.
.TP
.B ./lib/intrin.a
library for the Fortran 90 array intrinsics.
.PD
.SH SUPPORT
Please send any inquiries, questions, comments or bug-reports to:
.B support-f90@parasoft.com.
.SH IMPLEMENTED FEATURES
.LP
The current release of the system supports all of
.SM FORTRAN
77 plus
the following Fortran 90 extensions:
.LP
- All array extensions: whole-array operations, array sections,
vector-valued subscripts, user-defined array-valued functions,
automatic arrays, assumed-size arrays, where statement, array
constructors.
.LP
- All new array intrinsics.
.LP
- Interfaces.
.LP
- Optional and keywords arguments.
.LP
- New control constructs.
.LP
- New source forms (free and fixed).
.LP
- Symbolic relational operators.
.LP
- Include statement.
.LP
- Attribute specifiers in type declarations.
.LP
- Implicit none.
.LP
In addition it also supports common extensions to Fortran 90
like the FORALL statement and extensions in CM Fortran.

.LP

Fortran 90 features not supported in this release are:
.LP
- Recursive and internal procedures.
.LP
- Pointers.
.LP
- User-defined data types and operators.
.LP
- Modules.
.LP
- Kind type parameter.
.LP
- Non-array new array intrinsics.

.LP

The data types supported are:
.LP
- INTEGER (4 bytes).
.LP
- REAL (4 bytes), DOUBLE PRECISION (8 bytes). 
.LP
- COMPLEX (8 bytes), DOUBLE COMPLEX (16 bytes).
.LP
- LOGICAL (4 bytes).
.LP
- CHARACTER (1 byte).
.LP
The notation TYPE *
.I number_of_bytes
can also be used. For example REAL
is synonym of REAL*4 and DOUBLE PRECISION is synonym of REAL*8. 
.LP
.SH NOTES
Files with names ending in
.B .f9,
.B .fcm
and the suffix for the
.SM FORTRAN
77 source files
can be freely combined. Source files from
languages other than
.SM FORTRAN
may be combined using the same procedure to combine them
with 
.SM FORTRAN
77 files.
.LP
Programs can be debugged using the
.SM FORTRAN
77 debugger. To do that
keep the translated
.SM FORTRAN
77 program using the 
.B -f
flag, and use also the
.B -source
flag to leave the original Fortran 90 source as comments.
.LP
Note that the translator always produces and intermediate
.SM FORTRAN
77 file
with the same prefix as the Fortran 90 file. This will delete any
.SM FORTRAN
77 file with the same name.
.LP
.SH EXAMPLES
.LP
To compile a Fortran 90 program called
.B test.f9
and produce executable
.B test
as output use:
.LP
.B f90 -o test test.f9

To compile a CM Fortran program called
.B test.fcm
and produce executable
.B test
as output use:
.LP
.B f90 -o test test.fcm

To compile programs
.BR test1.f9 ,
.B test2.fcm
and
.B test3.c
and produce executable
.B test
as output use:
.LP
.B f90 -o test test1.f9 test2.fcm test3.c

To translate program
.B test.f9
leaving the output in
.B test.f
with the original Fortran 90 source
as comments use:
.LP
.B f90 -t -source test.f9
.PD
.SH "SEE ALSO"
.LP
.SM FORTRAN
77 compiler man page and documents.
.LP
.LP
W. Brainerd, C. Goldberg and J. Adams,
.IR "Programmer's Guide to Fortran 90",
McGraw-Hill Book Company, 1990.
ISBN 0-07-000248-7.
.LP
M. Metcalf and J. Reid,
.IR "Fortran 90 Explained",
Oxford University Press, 1990.
ISBN 0-19-853772-7.
.LP
.LP
Fortran 90 standard, copies can be obtained from either:
.LP
ANSI, 1430 Broadway, New York, NY 10018. Reference: ANSI X3.198-1991.
.LP
ISO, 1, rue de Varembe, Case postale 56, 1211 Geneva 20, Switzerland.
Reference: ISO/IEC 1539:1991.
.LP
An electronic version of the standard is available from:
Unicomp, Inc., 235 Mt. Hamilton Avenue, Los Altos, CA 94022.
FAX: (415) 949-4058.
.LP
.LP
The reference for Connection Machine Fortran is:
Thinking Machines Corporation, CM Fortran Reference Manual.
.LP
.SH DIAGNOSTICS
.LP
The diagnostics produced by 
.B f90
are intended to be
self-explanatory. No messages should be produced by the
.SM FORTRAN
77 compiler.
End of f90.1
--
----------------------------------------------------------------
Keith H. Bierman    keith.bierman@Sun.COM| khb@chiba.Eng.Sun.COM
SunPro 2550 Garcia MTV 12-33             | (415 336 2648)   
Mountain View, CA 94043  <speaking for myself, not Sun*> Copyright 1992


From khb Tue Jun 16 16:42:46 JST 1992
Article: 3448 of comp.lang.fortran
From: khb@chiba.Eng.Sun.COM (Keith Bierman fpgroup)
Newsgroups: comp.lang.fortran
Subject: f90 translator
Date: 23 Apr 92 02:49:20 GMT
Organization: Sun MegaSystems


A week or two back, in responding to a query about f90 tools, I
pointed to the NAG implementation and the Parasoft partial
implementation. 

It has since come to my attention that Parasoft has a new release,
details follow.

Disclosure: I have no financial stake in Parasoft. I do, however, have
	    an interest in speedy development of f90 tools/implementations.

------
               Announcing PF90 Version 2.0

The portable Fortran 90 package from ParaSoft Corporation allows
the compilation and execution of Fortran 90 programs on most UNIX
machines.

The package consists of:

- A Fortran 90 to FORTRAN 77 translator.
- Run-time library for the new intrinsics and memory allocation.
- Compiler like driver.
- Example programs in Fortran 90.
- On line manual page.
- Introductory book on Fortran 90.
- Phone, FAX and Electronic Mail support.


FEATURES:

- Complete Fortran 90 language support.

- Support of Connection Machine Fortran and of most common non
  Fortran 90 extensions currently found in FORTRAN 77 compilers.

- Intermediate FORTRAN 77 source allowing:

    * Full use of all the power of the FORTRAN 77 compiler.
      Notably optimization/vectorization.

    * Source-level debugging on the intermediate FORTRAN 77 file.

    * Mixing of Fortran 90 and FORTRAN 77 programs at the source
      and I/O levels.

    * Access to the extensions of the FORTRAN 77 compiler.

- Compiler like interface that is invoked like a conventional
  compiler. An example invocation is:

                   $ f90 -O -o test test.f9 

- The package is available on most current machines, and provides
  a uniform user interface across all supported platforms.

- Precise error messages, both at compile-time and at run-time.


PRICES:

        ----------------------------------------
        |    SYSTEM      | standard | academic |
        ========================================
        | Workstations   |  $1,750  |  $1,137  |
        ----------------------------------------
        | Convex/Alliant |  $5,000  |  $3,250  |
        ----------------------------------------
        | Cray/IBM3090   | $10,000  |  $7,500  |
        ----------------------------------------


1) Workstation versions include: SUN-3/4/sparc (SUN OS), IBM-RS6000
  (AIX), HP-9000 (HP-UX), DecStation (Ultrix) and SGI (Irix).

2) Prices are for a license for one machine, with an unlimited
   number of users. Please, contact us regarding site-licenses.

3) 30 day free support is included with the system. A yearly
   maintenance agreement can be purchased with all systems at
   an annual rate of 20% the original purchase price.

4) The system comes with a 30-day money back guarantee. If you
   are not satisfied with the system you can return it at any 
   time during the first 30 days for a full refund.

5) PROMOTIONAL OFFER: there is a discount of 25% on all orders
                      received before June 1.



CONTACT:

FAX: (818) 792-0819
Phone: (818) 792-9941
E-mail: f90-info@parasoft.com

Mail:  ParaSoft Corporation
       2500 E. Foothill Blvd
       Pasadena, CA 91107

--
----------------------------------------------------------------
Keith H. Bierman    keith.bierman@Sun.COM| khb@chiba.Eng.Sun.COM
SunPro 2550 Garcia MTV 12-33             | (415 336 2648)   
Mountain View, CA 94043  <speaking for myself, not Sun*> Copyright 1992