8000 ENH: Support character string arrays · pearu/numpy@bc41ca9 · GitHub
[go: up one dir, main page]
Skip to content

Commit bc41ca9

Browse files
pearupearu
committed
ENH: Support character string arrays
TST: added test for issue numpy#18684 ENH: f2py opens files with correct encoding, fixes numpy#635 TST: added test for issue numpy#6308 TST: added test for issue numpy#4519 TST: added test for issue numpy#3425 ENH: Implement user-defined hooks support for post-processing f2py data structure. Implement character BC hook. ENH: Add support for detecting utf-16 and utf-32 encodings.
1 parent b3a66e8 commit bc41ca9

25 files changed

+1777
-370
lines changed

‎doc/source/f2py/advanced.rst

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,3 +95,53 @@ and the corresponding <C type>. <C type> can be one of the following::
9595
string
9696

9797
For more information, see F2Py source code ``numpy/f2py/capi_maps.py``.
98+
99+
.. _Character strings:
100+
101+
Character strings
102+
=================
103+
104+
Assumed length chararacter strings
105+
-----------------------------------
106+
107+
In Fortran, assumed length character string arguments are declared as
108+
``character*(*)`` or ``character(len=*)``, that is, the length of such
109+
arguments are determined by the actual string arguments at runtime.
110+
For ``intent(in)`` arguments, this lack of length information poses no
111+
problems for f2py to construct functional wrapper functions. However,
112+
for ``intent(out)`` arguments, the lack of length information is
113+
problematic for f2py generated wrappers because there is no size
114+
information available for creating memory buffers for such arguments
115+
and F2PY assumes the length is 0. Depending on how the length of
116+
assumed length character strings are specified, there exist ways to
117+
workaround this problem, as exemplified below.
118+
119+
If the length of the ``character*(*)`` output argument is determined
120+
by the state of other input arguments, the required connection can be
121+
established in a signature file or within a f2py-comment by adding an
122+
extra declaration for the corresponding argument that specifies the
123+
length in character selector part. For example, consider a Fortran
124+
file ``asterisk1.f90``:
125+
126+
.. include:: asterisk1.f90
127+
:literal:
128+
129+
Compile it with ``f2py -c asterisk1.f90 -m asterisk1`` and then in Python:
130+
131+
.. include:: asterisk1_session.dat
132+
:literal:
133+
134+
Notice that the extra declaration ``character(f2py_len=12) s`` is
135+
interpreted only by f2py and in the ``f2py_len=`` specification one
136+
can use C-expressions as a length value.
137+
138+
In the following example:
139+
140+
.. include:: asterisk2.f90
141+
:literal:
142+
143+
the lenght of output assumed length string depends on an input
144+
argument ``n``, after wrapping with F2PY, in Python:
145+
146+
.. include:: asterisk2_session.dat
147+
:literal:

‎doc/source/f2py/asterisk1.f90

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
subroutine foo1(s)
2+
character*(*), intent(out) :: s
3+
!f2py character(f2py_len=12) s
4+
s = "123456789A12"
5+
end subroutine foo1

‎doc/source/f2py/asterisk1_session.dat

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
>>> import asterisk1
2+
>>> asterisk1.foo1()
3+
b'123456789A12'

‎doc/source/f2py/asterisk2.f90

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
subroutine foo2(s, n)
2+
character(len=*), intent(out) :: s
3+
integer, intent(in) :: n
4+
!f2py character(f2py_len=n), depend(n) :: s
5+
s = "123456789A123456789B"(1:n)
6+
end subroutine foo2

‎doc/source/f2py/asterisk2_session.dat

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
>>> import asterisk
2+
>>> asterisk.foo2(2)
3+
b'12'
4+
>>> asterisk.foo2(12)
5+
b'123456789A12'
6+
>>>

‎doc/source/f2py/signature-file.rst

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -592,17 +592,20 @@ A C expression may contain:
592592
according to given dependence relations;
593593
* the following CPP macros:
594594

595-
``rank(<name>)``
595+
``f2py_rank(<name>)``
596596
Returns the rank of an array ``<name>``.
597-
``shape(<name>,<n>)``
597+
``f2py_shape(<name>, <n>)``
598598
Returns the ``<n>``-th dimension of an array ``<name>``.
599-
``len(<name>)``
599+
``f2py_len(<name>)``
600600
Returns the length of an array ``<name>``.
601-
``size(<name>)``
601+
``f2py_size(<name>)``
602602
Returns the size of an array ``<name>``.
603-
``slen(<name>)``
603+
``f2py_itemsize(<name>)``
604+
Returns the itemsize of an array ``<name>``.
605+
``f2py_slen(<name>)``
604606
Returns the length of a string ``<name>``.
605607

608+
606609
For initializing an array ``<array name>``, F2PY generates a loop over
607610
all indices and dimensions that executes the following
608611
pseudo-statement::
@@ -650,3 +653,14 @@ Currently, multiline blocks can be used in the following constructs:
650653
+ as a list of C arrays of the ``pymethoddef`` statement;
651654

652655
+ as documentation string.
656+
657+
Extended char-selector
658+
-----------------------
659+
660+
F2PY extends char-selector specification, usable within a signature
661+
file or a F2PY directive, as follows::
662+
663+
<extended-charselector> := <charselector>
664+
| (f2py_len= <len>)
665+
666+
See :ref:`Character Strings` for usage.

‎numpy/f2py/auxfuncs.py

Lines changed: 50 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -28,18 +28,21 @@
2828
'getfortranname', 'getpymethoddef', 'getrestdoc', 'getusercode',
2929
'getusercode1', 'hasbody', 'hascallstatement', 'hascommon',
3030
'hasexternals', 'hasinitvalue', 'hasnote', 'hasresultnote',
31-
'isallocatable', 'isarray', 'isarrayofstrings', 'iscomplex',
31+
'isallocatable', 'isarray', 'isarrayofstrings',
32+
'ischaracter', 'ischaracterarray', 'ischaracter_or_characterarray',
33+
'iscomplex',
3234
'iscomplexarray', 'iscomplexfunction', 'iscomplexfunction_warn',
3335
'isdouble', 'isdummyroutine', 'isexternal', 'isfunction',
34-
'isfunction_wrap', 'isint1array', 'isinteger', 'isintent_aux',
36+
'isfunction_wrap', 'isint1', 'isint1array', 'isinteger', 'isintent_aux',
3537
'isintent_c', 'isintent_callback', 'isintent_copy', 'isintent_dict',
3638
'isintent_hide', 'isintent_in', 'isintent_inout', 'isintent_inplace',
3739
'isintent_nothide', 'isintent_out', 'isintent_overwrite', 'islogical',
3840
'islogicalfunction', 'islong_complex', 'islong_double',
3941
'islong_doublefunction', 'islong_long', 'islong_longfunction',
4042
'ismodule', 'ismoduleroutine', 'isoptional', 'isprivate', 'isrequired',
4143
'isroutine', 'isscalar', 'issigned_long_longarray', 'isstring',
42-
'isstringarray', 'isstringfunction', 'issubroutine',
44+
'isstringarray', 'isstring_or_stringarray', 'isstringfunction',
45+
'issubroutine',
4346
'issubroutine_wrap', 'isthreadsafe', 'isunsigned', 'isunsigned_char',
4447
'isunsigned_chararray', 'isunsigned_long_long',
4548
'isunsigned_long_longarray', 'isunsigned_short',
@@ -68,24 +71,41 @@ def debugcapi(var):
6871
return 'capi' in debugoptions
6972

7073

74+
def _ischaracter(var):
75+
return 'typespec' in var and var['typespec'] == 'character' and \
76+
not isexternal(var)
77+
78+
7179
def _isstring(var):
7280
return 'typespec' in var and var['typespec'] == 'character' and \
7381
not isexternal(var)
7482

7583

76-
def isstring(var):
77-
return _isstring(var) and not isarray(var)
84+
def ischaracter_or_characterarray(var):
85+
return _ischaracter(var) and 'charselector' not in var
7886

7987

8088
def ischaracter(var):
81-
return isstring(var) and 'charselector' not in var
89+
return ischaracter_or_characterarray(var) and not isarray(var)
90+
91+
92+
def ischaracterarray(var):
93+
return ischaracter_or_characterarray(var) and isarray(var)
94+
95+
96+
def isstring_or_stringarray(var):
97+
return _ischaracter(var) and 'charselector' in var
98+
99+
100+
def isstring(var):
101+
return isstring_or_stringarray(var) and not isarray(var)
82102

83103

84104
def isstringarray(var):
85-
return isarray(var) and _isstring(var)
105+
return isstring_or_stringarray(var) and isarray(var)
86106

87107

88-
def isarrayofstrings(var):
108+
def isarrayofstrings(var): # obsolete?
89109
# leaving out '*' for now so that `character*(*) a(m)` and `character
90110
# a(m,*)` are treated differently. Luckily `character**` is illegal.
91111
return isstringarray(var) and var['dimension'][-1] == '(*)'
@@ -126,6 +146,11 @@ def get_kind(var):
126146
pass
127147

128148

149+
def isint1(var):
150+
return var.get('typespec') == 'integer' \
151+
and get_kind(var) == '1' and not isarray(var)
152+
153+
129154
def islong_long(var):
130155
if not isscalar(var):
131156
return 0
@@ -426,6 +451,7 @@ def isintent_hide(var):
426451
('out' in var['intent'] and 'in' not in var['intent'] and
427452
(not l_or(isintent_inout, isintent_inplace)(var)))))
428453

454+
429455
def isintent_nothide(var):
430456
return not isintent_hide(var)
431457

@@ -469,6 +495,7 @@ def isintent_aligned8(var):
469495
def isintent_aligned16(var):
470496
return 'aligned16' in var.get('intent', [])
471497

498+
472499
isintent_dict = {isintent_in: 'INTENT_IN', isintent_inout: 'INTENT_INOUT',
473500
isintent_out: 'INTENT_OUT', isintent_hide: 'INTENT_HIDE',
474501
isintent_cache: 'INTENT_CACHE',
@@ -566,19 +593,19 @@ def __call__(self, var):
566593

567594

568595
def l_and(*f):
569-
l, l2 = 'lambda v', []
596+
l1, l2 = 'lambda v', []
570597
for i in range(len(f)):
571-
l = '%s,f%d=f[%d]' % (l, i, i)
598+
l1 = '%s,f%d=f[%d]' % (l1, i, i)
572599
l2.append('f%d(v)' % (i))
573-
return eval('%s:%s' % (l, ' and '.join(l2)))
600+
return eval('%s:%s' % (l1, ' and '.join(l2)))
574601

575602

576603
def l_or(*f):
577-
l, l2 = 'lambda v', []
604+
l1, l2 = 'lambda v', []
578605
for i in range(len(f)):
579-
l = '%s,f%d=f[%d]' % (l, i, i)
606+
l1 = '%s,f%d=f[%d]' % (l1, i, i)
580607
l2.append('f%d(v)' % (i))
581-
return eval('%s:%s' % (l, ' or '.join(l2)))
608+
return eval('%s:%s' % (l1, ' or '.join(l2)))
582609

583610

584611
def l_not(f):
@@ -666,7 +693,9 @@ def getcallprotoargument(rout, cb_map={}):
666693
pass
667694
else:
668695
ctype = ctype + '*'
669-
if isstring(var) or isarrayofstrings(var):
696+
if ((isstring(var)
697+
or isarrayofstrings(var) # obsolete?
698+
or isstringarray(var))):
670699
arg_types2.append('size_t')
671700
arg_types.append(ctype)
672701

@@ -731,14 +760,14 @@ def getrestdoc(rout):
731760

732761

733762
def gentitle(name):
734-
l = (80 - len(name) - 6) // 2
735-
return '/*%s %s %s*/' % (l * '*', name, l * '*')
763+
ln = (80 - len(name) - 6) // 2
764+
return '/*%s %s %s*/' % (ln * '*', name, ln * '*')
736765

737766

738-
def flatlist(l):
739-
if isinstance(l, list):
740-
return reduce(lambda x, y, f=flatlist: x + f(y), l, [])
741-
return [l]
767+
def flatlist(lst):
768+
if isinstance(lst, list):
769+
return reduce(lambda x, y, f=flatlist: x + f(y), lst, [])
770+
return [lst]
742771

743772

744773
def stripcomma(s):

0 commit comments

Comments
 (0)
0