use 'in' keyword to test dictionary membership

1 files changed, 290 insertions, 116 deletions

diff --git a/numpy/f2py/auxfuncs.py b/numpy/f2py/auxfuncs.py
index b9f8233f2..e033e5630 100644
--- a/numpy/f2py/auxfuncs.py
+++ b/numpy/f2py/auxfuncs.py
@@ -38,111 +38,200 @@ def outmess(t):
     if options.get('verbose',1):
         sys.stdout.write(t)
 
-def debugcapi(var): return 'capi' in debugoptions
+def debugcapi(var):
+    return 'capi' in debugoptions
+
 def _isstring(var):
-    return var.has_key('typespec') and var['typespec']=='character' and (not isexternal(var))
+    return 'typespec' in var and var['typespec']=='character' and (not isexternal(var))
+
 def isstring(var):
     return _isstring(var) and not isarray(var)
+
 def ischaracter(var):
-    return isstring(var) and not (var.has_key('charselector'))
+    return isstring(var) and 'charselector' not in var
+
 def isstringarray(var):
     return isarray(var) and _isstring(var)
+
 def isarrayofstrings(var):
     # leaving out '*' for now so that
     # `character*(*) a(m)` and `character a(m,*)`
     # are treated differently. Luckily `character**` is illegal.
     return isstringarray(var) and var['dimension'][-1]=='(*)'
-def isarray(var): return var.has_key('dimension') and (not isexternal(var))
-def isscalar(var): return not (isarray(var) or isstring(var) or isexternal(var))
+
+def isarray(var):
+    return 'dimension' in var and (not isexternal(var))
+
+def isscalar(var):
+    return not (isarray(var) or isstring(var) or isexternal(var))
+
 def iscomplex(var):
     return isscalar(var) and var.get('typespec') in ['complex','double complex']
+
 def islogical(var):
     return isscalar(var) and var.get('typespec')=='logical'
+
 def isinteger(var):
     return isscalar(var) and var.get('typespec')=='integer'
+
 def isreal(var):
     return isscalar(var) and var.get('typespec')=='real'
+
 def get_kind(var):
-    try: return var['kindselector']['*']
+    try:
+        return var['kindselector']['*']
     except KeyError:
-        try: return var['kindselector']['kind']
-        except KeyError: pass
+        try:
+            return var['kindselector']['kind']
+        except KeyError:
+            pass
+
 def islong_long(var):
-    if not isscalar(var): return 0
-    if var.get('typespec') not in ['integer','logical']: return 0
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') not in ['integer','logical']:
+        return 0
     return get_kind(var)=='8'
+
 def isunsigned_char(var):
-    if not isscalar(var): return 0
-    if var.get('typespec') != 'integer': return 0
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
     return get_kind(var)=='-1'
+
 def isunsigned_short(var):
-    if not isscalar(var): return 0
-    if var.get('typespec') != 'integer': return 0
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
     return get_kind(var)=='-2'
+
 def isunsigned(var):
-    if not isscalar(var): return 0
-    if var.get('typespec') != 'integer': return 0
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
     return get_kind(var)=='-4'
+
 def isunsigned_long_long(var):
-    if not isscalar(var): return 0
-    if var.get('typespec') != 'integer': return 0
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
     return get_kind(var)=='-8'
+
 def isdouble(var):
-    if not isscalar(var): return 0
-    if not var.get('typespec')=='real': return 0
+    if not isscalar(var):
+        return 0
+    if not var.get('typespec')=='real':
+        return 0
     return get_kind(var)=='8'
+
 def islong_double(var):
-    if not isscalar(var): return 0
-    if not var.get('typespec')=='real': return 0
+    if not isscalar(var):
+        return 0
+    if not var.get('typespec')=='real':
+        return 0
     return get_kind(var)=='16'
+
 def islong_complex(var):
-    if not iscomplex(var): return 0
+    if not iscomplex(var):
+        return 0
     return get_kind(var)=='32'
 
-def iscomplexarray(var): return isarray(var) and var.get('typespec') in ['complex','double complex']
-def isint1array(var): return isarray(var) and var.get('typespec')=='integer' \
+def iscomplexarray(var):
+    return isarray(var) and var.get('typespec') in ['complex','double complex']
+
+def isint1array(var):
+    return isarray(var) and var.get('typespec')=='integer' \
     and get_kind(var)=='1'
-def isunsigned_chararray(var): return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-1'
-def isunsigned_shortarray(var): return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-2'
-def isunsignedarray(var): return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-4'
-def isunsigned_long_longarray(var): return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-8'
+
+def isunsigned_chararray(var):
+    return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-1'
+
+def isunsigned_shortarray(var):
+    return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-2'
+
+def isunsignedarray(var):
+    return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-4'
+
+def isunsigned_long_longarray(var):
+    return isarray(var) and var.get('typespec')=='integer' and get_kind(var)=='-8'
+
 def isallocatable(var):
-    return var.has_key('attrspec') and 'allocatable' in var['attrspec']
-def ismutable(var): return not (not var.has_key('dimension') or isstring(var))
-def ismoduleroutine(rout): return rout.has_key('modulename')
-def ismodule(rout): return (rout.has_key('block') and 'module'==rout['block'])
-def isfunction(rout): return (rout.has_key('block') and 'function'==rout['block'])
+    return 'attrspec' in var and 'allocatable' in var['attrspec']
+
+def ismutable(var):
+    return not (not 'dimension' in var or isstring(var))
+
+def ismoduleroutine(rout):
+    return 'modulename' in rout
+
+def ismodule(rout):
+    return ('block' in rout and 'module'==rout['block'])
+
+def isfunction(rout):
+    return ('block' in rout and 'function'==rout['block'])
+
 #def isfunction_wrap(rout):
 #    return wrapfuncs and (iscomplexfunction(rout) or isstringfunction(rout)) and (not isexternal(rout))
+
 def isfunction_wrap(rout):
-    if isintent_c(rout): return 0
+    if isintent_c(rout):
+        return 0
     return wrapfuncs and isfunction(rout) and (not isexternal(rout))
-def issubroutine(rout): return (rout.has_key('block') and 'subroutine'==rout['block'])
-def isroutine(rout): return isfunction(rout) or issubroutine(rout)
+
+def issubroutine(rout):
+    return ('block' in rout and 'subroutine'==rout['block'])
+
+def isroutine(rout):
+    return isfunction(rout) or issubroutine(rout)
+
 def islogicalfunction(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return islogical(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return islogical(rout['vars'][a])
     return 0
+
 def islong_longfunction(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return islong_long(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return islong_long(rout['vars'][a])
     return 0
+
 def islong_doublefunction(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return islong_double(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return islong_double(rout['vars'][a])
     return 0
+
 def iscomplexfunction(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return iscomplex(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return iscomplex(rout['vars'][a])
     return 0
+
 def iscomplexfunction_warn(rout):
     if iscomplexfunction(rout):
         outmess("""\
@@ -155,46 +244,86 @@ def iscomplexfunction_warn(rout):
     **************************************************************\n""")
         return 1
     return 0
+
 def isstringfunction(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return isstring(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return isstring(rout['vars'][a])
     return 0
-def hasexternals(rout): return rout.has_key('externals') and rout['externals']
-def isthreadsafe(rout): return rout.has_key('f2pyenhancements') and rout['f2pyenhancements'].has_key('threadsafe')
-def hasvariables(rout): return rout.has_key('vars') and rout['vars']
-def isoptional(var): return (var.has_key('attrspec') and 'optional' in var['attrspec'] and 'required' not in var['attrspec']) and isintent_nothide(var)
-def isexternal(var): return (var.has_key('attrspec') and 'external' in var['attrspec'])
-def isrequired(var): return not isoptional(var) and isintent_nothide(var)
+
+def hasexternals(rout):
+    return 'externals' in rout and rout['externals']
+
+def isthreadsafe(rout):
+    return 'f2pyenhancements' in rout and 'threadsafe' in rout['f2pyenhancements']
+
+def hasvariables(rout):
+    return 'vars' in rout and rout['vars']
+
+def isoptional(var):
+    return ('attrspec' in var and 'optional' in var['attrspec'] and 'required' not in var['attrspec']) and isintent_nothide(var)
+
+def isexternal(var):
+    return ('attrspec' in var and 'external' in var['attrspec'])
+
+def isrequired(var):
+    return not isoptional(var) and isintent_nothide(var)
+
 def isintent_in(var):
-    if not var.has_key('intent'): return 1
-    if 'hide' in var['intent']: return 0
-    if 'inplace' in var['intent']: return 0
-    if 'in' in var['intent']: return 1
-    if 'out' in var['intent']: return 0
-    if 'inout' in var['intent']: return 0
-    if 'outin' in var['intent']: return 0
+    if 'intent' not in var:
+        return 1
+    if 'hide' in var['intent']:
+        return 0
+    if 'inplace' in var['intent']:
+        return 0
+    if 'in' in var['intent']:
+        return 1
+    if 'out' in var['intent']:
+        return 0
+    if 'inout' in var['intent']:
+        return 0
+    if 'outin' in var['intent']:
+        return 0
     return 1
-def isintent_inout(var): return var.has_key('intent') and ('inout' in var['intent'] or 'outin' in var['intent']) and 'in' not in var['intent'] and 'hide' not in var['intent'] and 'inplace' not in var['intent']
+
+def isintent_inout(var):
+    return 'intent' in var and ('inout' in var['intent'] or 'outin' in var['intent']) and 'in' not in var['intent'] and 'hide' not in var['intent'] and 'inplace' not in var['intent']
+
 def isintent_out(var):
     return 'out' in var.get('intent',[])
-def isintent_hide(var): return (var.has_key('intent') and ('hide' in var['intent'] or ('out' in var['intent'] and 'in' not in var['intent'] and (not l_or(isintent_inout,isintent_inplace)(var)))))
-def isintent_nothide(var): return not isintent_hide(var)
+
+def isintent_hide(var):
+    return ('intent' in var and ('hide' in var['intent'] or ('out' in var['intent'] and 'in' not in var['intent'] and (not l_or(isintent_inout,isintent_inplace)(var)))))
+
+def isintent_nothide(var):
+    return not isintent_hide(var)
+
 def isintent_c(var):
     return 'c' in var.get('intent',[])
+
 # def isintent_f(var):
 #     return not isintent_c(var)
+
 def isintent_cache(var):
     return 'cache' in var.get('intent',[])
+
 def isintent_copy(var):
     return 'copy' in var.get('intent',[])
+
 def isintent_overwrite(var):
     return 'overwrite' in var.get('intent',[])
+
 def isintent_callback(var):
     return 'callback' in var.get('intent',[])
+
 def isintent_inplace(var):
     return 'inplace' in var.get('intent',[])
+
 def isintent_aux(var):
     return 'aux' in var.get('intent',[])
 
@@ -206,41 +335,63 @@ isintent_dict = {isintent_in:'INTENT_IN',isintent_inout:'INTENT_INOUT',
                  }
 
 def isprivate(var):
-    return var.has_key('attrspec') and 'private' in var['attrspec']
+    return 'attrspec' in var and 'private' in var['attrspec']
+
+def hasinitvalue(var):
+    return '=' in var
 
-def hasinitvalue(var): return var.has_key('=')
 def hasinitvalueasstring(var):
-    if not hasinitvalue(var): return 0
+    if not hasinitvalue(var):
+        return 0
     return var['='][0] in ['"',"'"]
+
 def hasnote(var):
-    return var.has_key('note')
+    return 'note' in var
+
 def hasresultnote(rout):
-    if not isfunction(rout): return 0
-    if rout.has_key('result'): a=rout['result']
-    else: a=rout['name']
-    if rout['vars'].has_key(a): return hasnote(rout['vars'][a])
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a=rout['result']
+    else:
+        a=rout['name']
+    if a in rout['vars']:
+        return hasnote(rout['vars'][a])
     return 0
+
 def hascommon(rout):
-    return rout.has_key('common')
+    return 'common' in rout
+
 def containscommon(rout):
-    if hascommon(rout): return 1
+    if hascommon(rout):
+        return 1
     if hasbody(rout):
         for b in rout['body']:
-            if containscommon(b): return 1
+            if containscommon(b):
+                return 1
     return 0
+
 def containsmodule(block):
-    if ismodule(block): return 1
-    if not hasbody(block): return 0
+    if ismodule(block):
+        return 1
+    if not hasbody(block):
+        return 0
     for b in block['body']:
-        if containsmodule(b): return 1
+        if containsmodule(b):
+            return 1
     return 0
+
 def hasbody(rout):
-    return rout.has_key('body')
+    return 'body' in rout
+
 def hascallstatement(rout):
     return getcallstatement(rout) is not None
 
-def istrue(var): return 1
-def isfalse(var): return 0
+def istrue(var):
+    return 1
+
+def isfalse(var):
+    return 0
 
 class F2PYError(Exception):
     pass
@@ -258,12 +409,14 @@ def l_and(*f):
         l='%s,f%d=f[%d]'%(l,i,i)
         l2.append('f%d(v)'%(i))
     return eval('%s:%s'%(l,' and '.join(l2)))
+
 def l_or(*f):
     l,l2='lambda v',[]
     for i in range(len(f)):
         l='%s,f%d=f[%d]'%(l,i,i)
         l2.append('f%d(v)'%(i))
     return eval('%s:%s'%(l,' or '.join(l2)))
+
 def l_not(f):
     return eval('lambda v,f=f:not f(v)')
 
@@ -328,7 +481,7 @@ def getcallprotoargument(rout,cb_map={}):
         var = rout['vars'][n]
         if isintent_callback(var):
             continue
-        if cb_map.has_key(n):
+        if n in cb_map:
             ctype = cb_map[n]+'_typedef'
         else:
             ctype = getctype(var)
@@ -351,6 +504,7 @@ def getcallprotoargument(rout,cb_map={}):
 
 def getusercode(rout):
     return getmultilineblock(rout,'usercode')
+
 def getusercode1(rout):
     return getmultilineblock(rout,'usercode',counter=1)
 
@@ -359,9 +513,9 @@ def getpymethoddef(rout):
 
 def getargs(rout):
     sortargs,args=[],[]
-    if rout.has_key('args'):
+    if 'args' in rout:
         args=rout['args']
-        if rout.has_key('sortvars'):
+        if 'sortvars' in rout:
             for a in rout['sortvars']:
                 if a in args: sortargs.append(a)
             for a in args:
@@ -375,7 +529,7 @@ def getargs2(rout):
     auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])\
                and a not in args]
     args = auxvars + args
-    if rout.has_key('sortvars'):
+    if 'sortvars' in rout:
         for a in rout['sortvars']:
             if a in args: sortargs.append(a)
         for a in args:
@@ -385,7 +539,7 @@ def getargs2(rout):
     return args,sortargs
 
 def getrestdoc(rout):
-    if not rout.has_key('f2pymultilines'):
+    if 'f2pymultilines' not in rout:
         return None
     k = None
     if rout['block']=='python module':
@@ -395,21 +549,25 @@ def getrestdoc(rout):
 def gentitle(name):
     l=(80-len(name)-6)/2
     return '/*%s %s %s*/'%(l*'*',name,l*'*')
+
 def flatlist(l):
     if type(l)==types.ListType:
         return reduce(lambda x,y,f=flatlist:x+f(y),l,[])
     return [l]
+
 def stripcomma(s):
     if s and s[-1]==',': return s[:-1]
     return s
+
 def replace(str,dict,defaultsep=''):
     if type(dict)==types.ListType:
         return map(lambda d,f=replace,sep=defaultsep,s=str:f(s,d,sep),dict)
     if type(str)==types.ListType:
         return map(lambda s,f=replace,sep=defaultsep,d=dict:f(s,d,sep),str)
     for k in 2*dict.keys():
-        if k=='separatorsfor': continue
-        if dict.has_key('separatorsfor') and dict['separatorsfor'].has_key(k):
+        if k=='separatorsfor':
+            continue
+        if 'separatorsfor' in dict and k in dict['separatorsfor']:
             sep=dict['separatorsfor'][k]
         else:
             sep=defaultsep
@@ -421,22 +579,30 @@ def replace(str,dict,defaultsep=''):
 
 def dictappend(rd,ar):
     if type(ar)==types.ListType:
-        for a in ar: rd=dictappend(rd,a)
+        for a in ar:
+            rd=dictappend(rd,a)
         return rd
     for k in ar.keys():
-        if k[0]=='_': continue
-        if rd.has_key(k):
-            if type(rd[k])==types.StringType: rd[k]=[rd[k]]
+        if k[0]=='_':
+            continue
+        if k in rd:
+            if type(rd[k])==types.StringType:
+                rd[k]=[rd[k]]
             if type(rd[k])==types.ListType:
-                if type(ar[k])==types.ListType: rd[k]=rd[k]+ar[k]
-                else: rd[k].append(ar[k])
+                if type(ar[k])==types.ListType:
+                    rd[k]=rd[k]+ar[k]
+                else:
+                    rd[k].append(ar[k])
             elif type(rd[k])==types.DictType:
                 if type(ar[k])==types.DictType:
                     if k=='separatorsfor':
                         for k1 in ar[k].keys():
-                            if not rd[k].has_key(k1): rd[k][k1]=ar[k][k1]
-                    else: rd[k]=dictappend(rd[k],ar[k])
-        else: rd[k]=ar[k]
+                            if k1 not in rd[k]:
+                                rd[k][k1]=ar[k][k1]
+                    else:
+                        rd[k]=dictappend(rd[k],ar[k])
+        else:
+            rd[k]=ar[k]
     return rd
 
 def applyrules(rules,dict,var={}):
@@ -445,23 +611,27 @@ def applyrules(rules,dict,var={}):
         for r in rules:
             rr=applyrules(r,dict,var)
             ret=dictappend(ret,rr)
-            if rr.has_key('_break'): break
+            if '_break' in rr:
+                break
+        return ret
+    if '_check' in rules and (not rules['_check'](var)):
         return ret
-    if rules.has_key('_check') and (not rules['_check'](var)): return ret
-    if rules.has_key('need'):
+    if 'need' in rules:
         res = applyrules({'needs':rules['need']},dict,var)
-        if res.has_key('needs'):
+        if 'needs' in res:
             cfuncs.append_needs(res['needs'])
 
     for k in rules.keys():
-        if k=='separatorsfor': ret[k]=rules[k]; continue
+        if k=='separatorsfor':
+            ret[k]=rules[k]; continue
         if type(rules[k])==types.StringType:
             ret[k]=replace(rules[k],dict)
         elif type(rules[k])==types.ListType:
             ret[k]=[]
             for i in rules[k]:
                 ar=applyrules({k:i},dict,var)
-                if ar.has_key(k): ret[k].append(ar[k])
+                if k in ar:
+                    ret[k].append(ar[k])
         elif k[0]=='_':
             continue
         elif type(rules[k])==types.DictType:
@@ -472,19 +642,23 @@ def applyrules(rules,dict,var={}):
                         for i in rules[k][k1]:
                             if type(i)==types.DictType:
                                 res=applyrules({'supertext':i},dict,var)
-                                if res.has_key('supertext'): i=res['supertext']
+                                if 'supertext' in res:
+                                    i=res['supertext']
                                 else: i=''
                             ret[k].append(replace(i,dict))
                     else:
                         i=rules[k][k1]
                         if type(i)==types.DictType:
                             res=applyrules({'supertext':i},dict)
-                            if res.has_key('supertext'): i=res['supertext']
+                            if 'supertext' in res:
+                                i=res['supertext']
                             else: i=''
                         ret[k].append(replace(i,dict))
         else:
             errmess('applyrules: ignoring rule %s.\n'%`rules[k]`)
         if type(ret[k])==types.ListType:
-            if len(ret[k])==1: ret[k]=ret[k][0]
-            if ret[k]==[]: del ret[k]
+            if len(ret[k])==1:
+                ret[k]=ret[k][0]
+            if ret[k]==[]:
+                del ret[k]
     return ret