Commit 91f93078 authored by Raymond Toy's avatar Raymond Toy

More fixes for some bad markup

parent f274e125
...@@ -182,53 +182,56 @@ For a more detailed list of issues and notes, see src/NOTES. ...@@ -182,53 +182,56 @@ For a more detailed list of issues and notes, see src/NOTES.
We highlight just a few issues here. We highlight just a few issues here.
* Block data statements. * Block data statements.
In Fortran, block data statments are used to initialize common In Fortran, block data statments are used to initialize common
blocks. Since Fortran executables are loaded and run just once, blocks. Since Fortran executables are loaded and run just once,
this is not a problem. However, in Lisp, this might not be true, this is not a problem. However, in Lisp, this might not be true,
and you may want to run the main program many times. Thus, it is and you may want to run the main program many times. Thus, it is
up to you to run the block data initializer at the right time, as up to you to run the block data initializer at the right time, as
needed. f2cl cannot know when and where to call the initializer. needed. f2cl cannot know when and where to call the initializer.
* Common blocks. * Common blocks.
F2cl converts common blocks to structures. However, common blocks F2cl converts common blocks to structures. However, common blocks
may be referenced in several different files, so the user must may be referenced in several different files, so the user must
tell f2cl when to define the structure. Use the :declare-common tell f2cl when to define the structure. Use the :declare-common
parameter to tell f2cl to define the structure. This should be parameter to tell f2cl to define the structure. This should be
done exactly once for each common block that is defined. This done exactly once for each common block that is defined. This
should also be done for the first file that is compiled and should also be done for the first file that is compiled and
loaded, so that subsequent files know about the definition. loaded, so that subsequent files know about the definition.
In addition, there is another option, :common-as-array. This In addition, there is another option, :common-as-array. This
changes how f2cl handles common blocks. A rather common use of changes how f2cl handles common blocks. A rather common use of
common blocks has the same common block using different variable common blocks has the same common block using different variable
names. For example, one routine might have names. For example, one routine might have
``` ```
COMMON /foo/ a(10), b, i(4) COMMON /foo/ a(10), b, i(4)
``` ```
and another might say
and another might say
``` ```
COMMON /foo/ b(9), c, d, j(2), k(2) COMMON /foo/ b(9), c, d, j(2), k(2)
``` ```
In Fortran, this is perfectly acceptable. Normally, f2cl expects
all common blocks to use the same variable names, and then f2cl In Fortran, this is perfectly acceptable. Normally, f2cl expects
creates a structure for the common block using the variable names all common blocks to use the same variable names, and then f2cl
as the names of the slots. However, for a case like the above, creates a structure for the common block using the variable names
f2cl gets confused. Hence, :common-as-array. We treat the common as the names of the slots. However, for a case like the above,
block as an array of memory. So this gets converted into a f2cl gets confused. Hence, :common-as-array. We treat the common
structure somewhat like block as an array of memory. So this gets converted into a
structure somewhat like
``` ```
(defstruct foo (defstruct foo
(part-0 (make-array 11 :element-type 'real)) (part-0 (make-array 11 :element-type 'real))
(part-1 (make-array 4 :element-type 'integer4))) (part-1 (make-array 4 :element-type 'integer4)))
``` ```
(In a more general case, we group all contiguous variables of the (In a more general case, we group all contiguous variables of the
same type into one array. f2cl and Lisp cannot handle the case same type into one array. f2cl and Lisp cannot handle the case
where a real and integer value are allocated to the same piece of where a real and integer value are allocated to the same piece of
memory.) memory.)
Then in the individual routines, symbol-macrolets are used to Then in the individual routines, symbol-macrolets are used to
create accessors for the various definitions. Hence, for the create accessors for the various definitions. Hence, for the
second version, we would do something like second version, we would do something like
``` ```
(symbol-macrolet (symbol-macrolet
(b (make-array 9 :displaced-to (b (make-array 9 :displaced-to
...@@ -244,29 +247,29 @@ We highlight just a few issues here. ...@@ -244,29 +247,29 @@ We highlight just a few issues here.
:displaced-offset 2)) :displaced-offset 2))
...) ...)
``` ```
Thus, we access the right parts of the common block, independent Thus, we access the right parts of the common block, independent
of the name. Note that this has a performance impact since we of the name. Note that this has a performance impact since we
used displaced arrays. used displaced arrays.
* Conversion order. * Conversion order.
While not necessary, f2cl can do a significantly better job in While not necessary, f2cl can do a significantly better job in
generating code if the functions are compiled in the correct generating code if the functions are compiled in the correct
order. This means any function, F, that is called by another order. This means any function, F, that is called by another
function, G, should compiled first. In this way, f2cl can function, G, should compiled first. In this way, f2cl can
determine the calling conventions for F, and generate the determine the calling conventions for F, and generate the
appropriate call for F in G. This is important if F takes an appropriate call for F in G. This is important if F takes an
array argument and G passes a slice of an array to F, or array argument and G passes a slice of an array to F, or
conversely if F takes a simple variable, and G calls F with an conversely if F takes a simple variable, and G calls F with an
array reference. array reference.
If this is not done, the user may have to modify either the If this is not done, the user may have to modify either the
Fortran code or the resulting Lisp code to pass arguments Fortran code or the resulting Lisp code to pass arguments
correctly. correctly.
F2cl cannot always determine whether a slice of an array should be F2cl cannot always determine whether a slice of an array should be
used or just the single element. used or just the single element.
See also the file src/NOTES which contains a change log. But there See also the file src/NOTES which contains a change log. But there
are also various notes about about restrictions and enhancements on are also various notes about about restrictions and enhancements on
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment