From numpy-svn at scipy.org  Wed Nov  1 05:09:57 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed,  1 Nov 2006 04:09:57 -0600 (CST)
Subject: [Numpy-svn] r3423 - trunk/numpy/f2py/lib/parser
Message-ID: <20061101100957.09A063A0017@new.scipy.org>

Author: pearu
Date: 2006-11-01 04:09:49 -0600 (Wed, 01 Nov 2006)
New Revision: 3423

Added:
   trunk/numpy/f2py/lib/parser/test_Fortran2003.py
Modified:
   trunk/numpy/f2py/lib/parser/Fortran2003.py
   trunk/numpy/f2py/lib/parser/pattern_tools.py
Log:
F2PY G3: Cont impl F2003 parser; defined all syntax rules.

Modified: trunk/numpy/f2py/lib/parser/Fortran2003.py
===================================================================
--- trunk/numpy/f2py/lib/parser/Fortran2003.py	2006-10-31 14:58:19 UTC (rev 3422)
+++ trunk/numpy/f2py/lib/parser/Fortran2003.py	2006-11-01 10:09:49 UTC (rev 3423)
@@ -31,7 +31,9 @@
 
     def __new__(cls, string):
         #print '__new__:',cls.__name__,`string`
-        if isinstance(string, FortranReaderBase) and not issubclass(cls, BlockBase):
+        match = cls.__dict__.get('match', None)
+        if isinstance(string, FortranReaderBase) and not issubclass(cls, BlockBase) \
+               and match is not None:
             reader = string
             item = reader.get_item()
             if item is None: return
@@ -44,7 +46,6 @@
                 return
             obj._item = item
             return obj
-        match = cls.__dict__.get('match', None)
         if match is not None:
             result = cls.match(string)
         else:
@@ -109,6 +110,7 @@
                      [ <endcls> ]
     """
     def match(startcls, subclasses, endcls, reader):
+        assert isinstance(reader,FortranReaderBase),`reader`
         content = []
         if startcls is not None:
             try:
@@ -157,9 +159,12 @@
             start_stmt = content[0]
             end_stmt = content[-1]
             if isinstance(end_stmt, endcls) and hasattr(end_stmt, 'name'):
-                if end_stmt.name is not None and start_stmt.name != end_stmt.name:
-                    end_stmt._item.reader.error('expected <%s-name> is %s but got %s. Ignoring.'\
-                                                % (end_stmt.type.lower(), start_stmt.name, end_stmt.name))
+                if end_stmt.name is not None:
+                    if start_stmt.name != end_stmt.name:
+                        end_stmt._item.reader.error('expected <%s-name> is %s but got %s. Ignoring.'\
+                                                    % (end_stmt.type.lower(), start_stmt.name, end_stmt.name))
+                else:
+                    end_stmt.name = start_stmt.name
         return content,
     match = staticmethod(match)
 
@@ -432,13 +437,16 @@
 ############################### SECTION  2 ####################################
 ###############################################################################
 
-class Program(Base): # R201
+class Program(BlockBase): # R201
     """
     <program> = <program-unit>
                   [ <program-unit> ] ...
     """
     subclass_names = []
     use_names = ['Program_Unit']
+    def match(reader):
+        return BlockBase.match(Program_Unit, [Program_Unit], None, reader)
+    match = staticmethod(match)
 
 class Program_Unit(Base): # R202
     """
@@ -684,10 +692,17 @@
     subclass_names = ['Constant']
 
 #R310: <intrinsic-operator> = <power-op> | <mult-op> | <add-op> | <concat-op> | <rel-op> | <not-op> | <and-op> | <or-op> | <equiv-op>
-#R311: <defined-operator> = <defined--unary-op> | <defined-binary-op> | <extended-intrinsic-op>
+#R311: <defined-operator> = <defined-unary-op> | <defined-binary-op> | <extended-intrinsic-op>
 #R312: <extended-intrinsic-op> = <intrinsic-op>
-#R313: <label> = <digit> [ <digit> [ <digit> [ <digit> [ <digit> ] ] ] ]
 
+class Label(StringBase): # R313
+    """
+    <label> = <digit> [ <digit> [ <digit> [ <digit> [ <digit> ] ] ] ]
+    """
+    subclass_names = []
+    def match(string): return StringBase.match(pattern.abs_label, string)
+    match = staticmethod(match)
+
 ###############################################################################
 ############################### SECTION  4 ####################################
 ###############################################################################
@@ -2907,7 +2922,7 @@
     subclass_names = []
     use_names = ['Execution_Part_Construct']
 
-class If_Construct(Base):
+class If_Construct(Base): # R802
     """
     <if-construct> = <if-then-stmt>
                            <block>
@@ -2919,39 +2934,45 @@
                          ]
                          <end-if-stmt>
     """
+    subclass_names = []
     use_names = ['If_Then_Stmt', 'Block', 'Else_If_Stmt', 'Else_Stmt', 'End_If_Stmt']
 
-class If_Then_Stmt(Base):
+class If_Then_Stmt(Base): # R803
     """
     <if-then-stmt> = [ <if-construct-name> : ] IF ( <scalar-logical-expr> ) THEN
     """
+    subclass_names = []
     use_names = ['If_Construct_Name', 'Scalar_Logical_Expr']
 
-class Else_If_Stmt(Base):
+class Else_If_Stmt(Base): # R804
     """
     <else-if-stmt> = ELSE IF ( <scalar-logical-expr> ) THEN [ <if-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Scalar_Logical_Expr', 'If_Construct_Name']
 
-class Else_Stmt(Base):
+class Else_Stmt(Base): # R805
     """
     <else-stmt> = ELSE [ <if-construct-name> ]
     """
+    subclass_names = []
     use_names = ['If_Construct_Name']
 
-class End_If_Stmt(Base):
+class End_If_Stmt(Base): # R806
     """
     <end-if-stmt> = END IF [ <if-construct-name> ]
     """
+    subclass_names = []
     use_names = ['If_Construct_Name']
 
-class If_Stmt(Base):
+class If_Stmt(Base): # R807
     """
     <if-stmt> = IF ( <scalar-logical-expr> ) <action-stmt>
     """
+    subclass_names = []
     use_names = ['Scalar_Logical_Expr', 'Action_Stmt']
 
-class Case_Construct(Base):
+class Case_Construct(Base): # R808
     """
     <case-construct> = <select-case-stmt>
                            [ <case-stmt>
@@ -2959,42 +2980,48 @@
                            ]..
                            <end-select-stmt>
     """
+    subclass_names = []
     use_names = ['Select_Case_Stmt', 'Case_Stmt', 'End_Select_Stmt']
 
-class Select_Case_Stmt(Base):
+class Select_Case_Stmt(Base): # R809
     """
     <select-case-stmt> = [ <case-construct-name> : ] SELECT CASE ( <case-expr> )
     """
+    subclass_names = []
     use_names = ['Case_Construct_Name', 'Case_Expr']
 
-class Case_Stmt(Base):
+class Case_Stmt(Base): # R810
     """
     <case-stmt> = CASE <case-selector> [ <case-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Case_Selector', 'Case_Construct_Name']
 
-class End_Select_Stmt(Base):
+class End_Select_Stmt(Base): # R811
     """
     <end-select-stmt> = END SELECT [ <case-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Case_Construct_Name']
 
-class Case_Expr(Base):
+class Case_Expr(Base): # R812
     """
     <case-expr> = <scalar-int-expr>
                   | <scalar-char-expr>
                   | <scalar-logical-expr>
     """
+    subclass_names = []
     subclass_names = ['Scalar_Int_Expr', 'Scalar_Char_Expr', 'Scalar_Logical_Expr']
 
-class Case_Selector(Base):
+class Case_Selector(Base): # R813
     """
     <case-selector> = ( <case-value-range-list> )
                       | DEFAULT
     """
+    subclass_names = []
     use_names = ['Case_Value_Range_List']
 
-class Case_Value_Range(Base):
+class Case_Value_Range(Base): # R814
     """
     <case-value-range> = <case-value>
                          | <case-value> :
@@ -3012,40 +3039,44 @@
     subclass_names = ['Scalar_Int_Initialization_Expr', 'Scalar_Char_Initialization_Expr', 'Scalar_Logical_Initialization_Expr']
 
 
-class Associate_Construct(Base):
+class Associate_Construct(Base): # R816
     """
     <associate-construct> = <associate-stmt>
                                 <block>
                                 <end-associate-stmt>
     """
+    subclass_names = []
     use_names = ['Associate_Stmt', 'Block', 'End_Associate_Stmt']
 
-class Associate_Stmt(Base):
+class Associate_Stmt(Base): # R817
     """
     <associate-stmt> = [ <associate-construct-name> : ] ASSOCIATE ( <association-list> )
     """
-    use_names = ['Associate_Construct_Name', 'Associateion_List']
+    subclass_names = []
+    use_names = ['Associate_Construct_Name', 'Association_List']
 
-class Association(Base):
+class Association(Base): # R818
     """
     <association> = <associate-name> => <selector>
     """
+    subclass_names = []
     use_names = ['Associate_Name', 'Selector']
 
-class Selector(Base):
+class Selector(Base): # R819
     """
     <selector> = <expr>
                  | <variable>
     """
     subclass_names = ['Expr', 'Variable']
 
-class End_Associate_Stmt(Base):
+class End_Associate_Stmt(Base): # R820
     """
     <end-associate-stmt> = END ASSOCIATE [ <associate-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Associate_Construct_Name']
 
-class Select_Type_Construct(Base):
+class Select_Type_Construct(Base): # R821
     """
     <select-type-construct> = <select-type-stmt>
                                   [ <type-guard-stmt>
@@ -3053,96 +3084,225 @@
                                   ]...
                                   <end-select-type-stmt>
     """
+    subclass_names = []
     use_names = ['Select_Type_Stmt', 'Type_Guard_Stmt', 'Block', 'End_Select_Type_Stmt']
 
-class Select_Type_Stmt(Base):
+class Select_Type_Stmt(Base): # R822
     """
     <select-type-stmt> = [ <select-construct-name> : ] SELECT TYPE ( [ <associate-name> => ] <selector> )
     """
+    subclass_names = []
     use_names = ['Select_Construct_Name', 'Associate_Name', 'Selector']
 
-class Type_Guard_Stmt(Base):
+class Type_Guard_Stmt(Base): # R823
     """
     <type-guard-stmt> = TYPE IS ( <type-spec> ) [ <select-construct-name> ]
                         | CLASS IS ( <type-spec> ) [ <select-construct-name> ]
                         | CLASS DEFAULT [ <select-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Type_Spec', 'Select_Construct_Name']
 
-class End_Select_Type_Stmt(Base):
+class End_Select_Type_Stmt(Base): # R824
     """
     <end-select-type-stmt> = END SELECT [ <select-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Select_Construct_Name']
 
-class Do_Construct(Base):
+class Do_Construct(Base): # R825
     """
     <do-construct> = <block-do-construct>
                      | <nonblock-do-construct>
     """
     subclass_names = ['Block_Do_Construct', 'Nonblock_Do_Construct']
 
-class Block_Do_Construct(Base):
+class Block_Do_Construct(Base): # R826
     """
     <block-do-construct> = <do-stmt>
                                <do-block>
                                <end-do>
     """
+    subclass_names = []
     use_names = ['Do_Stmt', 'Do_Block', 'End_Do']
 
-class Do_Stmt(Base):
+class Do_Stmt(Base): # R827
     """
     <do-stmt> = <label-do-stmt>
                 | <nonlabel-do-stmt>
     """
     subclass_names = ['Label_Do_Stmt', 'Nonlabel_Do_Stmt']
 
-class Label_Do_Stmt(Base):
+class Label_Do_Stmt(Base): # R828
     """
     <label-do-stmt> = [ <do-construct-name> : ] DO <label> [ <loop-control> ]
     """
+    subclass_names = []
     use_names = ['Do_Construct_Name', 'Label', 'Loop_Control']
 
-class NonLabel_Do_Stmt(Base):
+class Nonlabel_Do_Stmt(Base): # R829
     """
     <nonlabel-do-stmt> = [ <do-construct-name> : ] DO [ <loop-control> ]
     """
+    subclass_names = []
     use_names = ['Do_Construct_Name', 'Loop_Control']
 
-class Loop_Control(Base):
+class Loop_Control(Base): # R830
     """
     <loop-control> = [ , ] <do-variable> = <scalar-int-expr> , <scalar-int-expr> [ , <scalar-int-expr> ]
                      | [ , ] WHILE ( <scalar-logical-expr> )
     """
+    subclass_names = []
     use_names = ['Do_Variable', 'Scalar_Int_Expr', 'Scalar_Logical_Expr']
 
-class Do_Variable(Base):
+class Do_Variable(Base): # R831
     """
     <do-variable> = <scalar-int-variable>
     """
     subclass_names = ['Scalar_Int_Variable']
 
-class Do_Block(Base):
+class Do_Block(Base): # R832
     """
     <do-block> = <block>
     """
     subclass_names = ['Block']
 
-class End_Do(Base):
+class End_Do(Base): # R833
     """
     <end-do> = <end-do-stmt>
                | <continue-stmt>
     """
     subclass_names = ['End_Do_Stmt', 'Continue_Stmt']
 
-class End_Do_Stmt(Base):
+class End_Do_Stmt(Base): # R834
     """
     <end-do-stmt> = END DO [ <do-construct-name> ]
     """
+    subclass_names = []
     use_names = ['Do_Construct_Name']
 
-#...
+class Nonblock_Do_Construct(Base): # R835
+    """
+    <nonblock-do-stmt> = <action-term-do-construct>
+                         | <outer-shared-do-construct>
+    """
+    subclass_names = ['Action_Term_Do_Construct', 'Outer_Shared_Do_Construct']
 
+class Action_Term_Do_Construct(Base): # R836
+    """
+    <action-term-do-construct> = <label-do-stmt>
+                                     <do-body>
+                                     <do-term-action-stmt>
+    """
+    subclass_names = []
+    use_names = ['Label_Do_Stmt', 'Do_Body', 'Do_Term_Action_Stmt']
+
+class Do_Body(Base): # R837
+    """
+    <do-body> = [ <execution-part-construct> ]...
+    """
+    subclass_names = []
+    use_names = ['Execution_Part_Construct']
+
+class Do_Term_Action_Stmt(Base): # R838
+    """
+    <do-term-action-stmt> = <action-stmt>
+    C824: <do-term-action-stmt> shall not be <continue-stmt>, <goto-stmt>, <return-stmt>, <stop-stmt>,
+                          <exit-stmt>, <cycle-stmt>, <end-function-stmt>, <end-subroutine-stmt>,
+                          <end-program-stmt>, <arithmetic-if-stmt>
+    """
+    subclass_names = ['Action_Stmt']
+
+class Outer_Shared_Do_Construct(Base): # R839
+    """
+    <outer-shared-do-construct> = <label-do-stmt>
+                                      <do-body>
+                                      <shared-term-do-construct>
+    """
+    subclass_names = []
+    use_names = ['Label_Do_Stmt', 'Do_Body', 'Shared_Term_Do_Construct']
+
+class Shared_Term_Do_Construct(Base): # R840
+    """
+    <shared-term-do-construct> = <outer-shared-do-construct>
+                                 | <inner-shared-do-construct>
+    """
+    subclass_names = ['Outer_Shared_Do_Construct', 'Inner_Shared_Do_Construct']
+
+class Inner_Shared_Do_Construct(Base): # R841
+    """
+    <inner-shared-do-construct> = <label-do-stmt>
+                                      <do-body>
+                                      <do-term-shared-stmt>
+    """
+    subclass_names = []
+    use_names = ['Label_Do_Stmt', 'Do_Body', 'Do_Term_Shared_Stmt']
+
+class Do_Term_Shared_Stmt(Base): # R842
+    """
+    <do-term-shared-stmt> = <action-stmt>
+    C826: see C824 above.
+    """
+    subclass_names = ['Action_Stmt']
+
+class Cycle_Stmt(Base): # R843
+    """
+    <cycle-stmt> = CYCLE [ <do-construct-name> ]
+    """
+    subclass_names = []
+    use_names = ['Do_Construct_Name']
+
+class Exit_Stmt(Base): # R844
+    """
+    <exit-stmt> = EXIT [ <do-construct-name> ]
+    """
+    subclass_names = []
+    use_names = ['Do_Construct_Name']
+
+class Goto_Stmt(Base): # R845
+    """
+    <goto-stmt> = GO TO <label>
+    """
+    subclass_names = []
+    use_names = ['Label']
+
+class Computed_Goto_Stmt(Base): # R846
+    """
+    <computed-goto-stmt> = GO TO ( <label-list> ) [ , ] <scalar-int-expr>
+    """
+    subclass_names = []
+    use_names = ['Label_List', 'Scalar_Int_Expr']
+
+class Arithmetic_If_Stmt(Base): # R847
+    """
+    <arithmetic-if-stmt> = IF ( <scalar-numeric-expr> ) <label> , <label> , <label>
+    """
+    subclass_names = []
+    use_names = ['Scalar_Numeric_Expr', 'Label']
+
+class Continue_Stmt(Base): # R848
+    """
+    <continue-stmt> = CONTINUE
+    """
+    subclass_names = []
+    
+class Stop_Stmt(Base): # R849
+    """
+    <stop-stmt> = STOP [ <stop-code> ]
+    """
+    subclass_names = []
+    use_names = ['Stop_Code']
+
+class Stop_Code(StringBase): # R850
+    """
+    <stop-code> = <scalar-char-constant>
+                  | <digit> [ <digit> [ <digit> [ <digit> [ <digit> ] ] ] ]
+    """
+    subclass_names = ['Scalar_Char_Constant']
+    def match(string): return StringBase.match(pattern.abs_label, string)
+    match = staticmethod(match)
+
+
 ###############################################################################
 ############################### SECTION  9 ####################################
 ###############################################################################
@@ -3155,6 +3315,309 @@
     """
     subclass_names = ['File_Unit_Number', 'Internal_File_Variable']
 
+class File_Unit_Number(Base): # R902
+    """
+    <file-unit-number> = <scalar-int-expr>
+    """
+    subclass_names = ['Scalar_Int_Expr']
+
+class Internal_File_Variable(Base): # R903
+    """
+    <internal-file-variable> = <char-variable>
+    C901: <char-variable> shall not be an array section with a vector subscript.
+    """
+    subclass_names = ['Char_Variable']
+
+class Open_Stmt(Base): # R904
+    """
+    <open-stmt> = OPEN ( <connect-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['Connect_Spec_List']
+
+class Connect_Spec(Base): # R905
+    """
+    <connect-spec> = [ UNIT = ] <file-unit-number>
+                     | ACCESS = <scalar-default-char-expr>
+                     | ACTION = <scalar-default-char-expr>
+                     | ASYNCHRONOUS = <scalar-default-char-expr>
+                     | BLANK = <scalar-default-char-expr>
+                     | DECIMAL = <scalar-default-char-expr>
+                     | DELIM = <scalar-default-char-expr>
+                     | ENCODING = <scalar-default-char-expr>
+                     | ERR = <label>
+                     | FILE = <file-name-expr>
+                     | FORM = <scalar-default-char-expr>
+                     | IOMSG = <iomsg-variable>
+                     | IOSTAT = <scalar-int-variable>
+                     | PAD = <scalar-default-char-expr>
+                     | POSITION = <scalar-default-char-expr>
+                     | RECL = <scalar-int-expr>
+                     | ROUND = <scalar-default-char-expr>
+                     | SIGN = <scalar-default-char-expr>
+                     | STATUS = <scalar-default-char-expr>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Scalar_Default_Char_Expr', 'Label', 'File_Name_Expr', 'Iomsg_Variable',
+                 'Scalar_Int_Expr', 'Scalar_Int_Variable']
+
+class File_Name_Expr(Base): # R906
+    """
+    <file-name-expr> = <scalar-default-char-expr>
+    """
+    subclass_names = ['Scalar_Default_Char_Expr']
+
+class Iomsg_Variable(Base): # R907
+    """
+    <iomsg-variable> = <scalar-default-char-variable>
+    """
+    subclass_names = ['Scalar_Default_Char_Variable']
+
+class Close_Stmt(Base): # R908
+    """
+    <close-stmt> = CLOSE ( <close-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['Close_Spec_List']
+
+class Close_Spec(Base): # R909
+    """
+    <close-spec> = [ UNIT = ] <file-unit-number>
+                   | IOSTAT = <scalar-int-variable>
+                   | IOMSG = <iomsg-variable>
+                   | ERR = <label>
+                   | STATUS = <scalar-default-char-expr>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Scalar_Default_Char_Expr', 'Label', 'Iomsg_Variable',
+                 'Scalar_Int_Variable']
+
+class Read_Stmt(Base): # R910
+    """
+    <read-stmt> = READ ( <io-control-spec-list> ) [ <input-item-list> ]
+                  | READ <format> [ , <input-item-list> ]
+    """
+    subclass_names = []
+    use_names = ['Io_Control_Spec_List', 'Input_Item_List', 'Format']
+
+class Write_Stmt(Base): # R911
+    """
+    <write-stmt> = WRITE ( <io-control-spec-list> ) [ <output-item-list> ]
+    """
+    subclass_names = []
+    use_names = ['Io_Control_Spec_List', 'Output_Item_List']
+
+class Print_Stmt(Base): # R912
+    """
+    <print-stmt> = PRINT <format> [ , <output-item-list> ]
+    """
+    subclass_names = []
+    use_names = ['Format', 'Output_Item_List']
+
+class Io_Control_Spec(Base): # R913
+    """
+    <io-control-spec> = [ UNIT = ] <io-unit>
+                        | [ FMT = ] <format>
+                        | [ NML = ] <namelist-group-name>
+                        | ADVANCE = <scalar-default-char-expr>
+                        | ASYNCHRONOUS = <scalar-char-initialization-expr>
+                        | BLANK = <scalar-default-char-expr>
+                        | DECIMAL = <scalar-default-char-expr>
+                        | DELIM = <scalar-default-char-expr>
+                        | END = <label>
+                        | EOR = <label>
+                        | ERR = <label>
+                        | ID = <scalar-int-variable>
+                        | IOMSG = <iomsg-variable>
+                        | IOSTAT = <scalar-int-variable>
+                        | PAD = <scalar-default-char-expr>
+                        | POS = <scalar-int-expr>
+                        | REC = <scalar-int-expr>
+                        | ROUND = <scalar-default-char-expr>
+                        | SIGN = <scalar-default-char-expr>
+                        | SIZE = <scalar-int-variable>
+    """
+    subclass_names = []
+    use_names = ['Io_Unit', 'Format', 'Namelist_Group_Name', 'Scalar_Default_Char_Expr',
+                 'Scalar_Char_Initialization_Expr', 'Label', 'Scalar_Int_Variable',
+                 'Iomsg_Variable', 'Scalar_Int_Expr']
+
+class Format(Base): # R914
+    """
+    <format> = <default-char-expr>
+               | <label>
+               | *
+    """
+    subclass_names = ['Default_Char_Expr', 'Label']
+
+class Input_Item(Base): # R915
+    """
+    <input-item> = <variable>
+                   | <io-implied-do>
+    """
+    subclass_names = ['Variable', 'Io_Implied_Do']
+
+class Output_Item(Base): # R916
+    """
+    <output-item> = <expr>
+                    | <io-implied-do>
+    """
+    subclass_names = ['Expr', 'Io_Implied_Do']
+
+class Io_Implied_Do(Base): # R917
+    """
+    <io-implied-do> = ( <io-implied-do-object-list> , <io-implied-do-control> )
+    """
+    subclass_names = []
+    use_names = ['Io_Implied_Do_Object_List', 'Io_Implied_Do_Control']
+
+class Io_Implied_Do_Object(Base): # R918
+    """
+    <io-implied-do-object> = <input-item>
+                             | <output-item>
+    """
+    subclass_names = ['Input_Item', 'Output_Item']
+
+class Io_Implied_Do_Control(Base): # R919
+    """
+    <io-implied-do-control> = <do-variable> = <scalar-int-expr> , <scalar-int-expr> [ , <scalar-int-expr> ]
+    """
+    subclass_names = []
+    use_names = ['Do_Variable', 'Scalar_Int_Expr']
+
+class Dtv_Type_Spec(Base): # R920
+    """
+    <dtv-type-spec> = TYPE ( <derived-type-spec> )
+                      | CLASS ( <derived-type-spec> )
+    """
+    subclass_names = []
+    use_names = ['Derived_Type_Spec']
+
+class Wait_Stmt(Base): # R921
+    """
+    <wait-stmt> = WAIT ( <wait-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['Wait_Spec_List']
+
+class Wait_Spec(Base): # R922
+    """
+    <wait-spec> = [ UNIT = ] <file-unit-number>
+                  | END = <label>
+                  | EOR = <label>
+                  | ERR = <label>
+                  | ID = <scalar-int-expr>
+                  | IOMSG = <iomsg-variable>
+                  | IOSTAT = <scalar-int-variable>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Label', 'Scalar_Int_Expr', 'Iomsg_Variable', 'Scalar_Int_Variable']
+
+class Backspace_Stmt(Base): # R923
+    """
+    <backspace-stmt> = BACKSPACE <file-unit-number>
+                       | BACKSPACE ( <position-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Position_Spec_List']
+
+class Endfile_Stmt(Base): # R924
+    """
+    <endfile-stmt> = ENDFILE <file-unit-number>
+                     | ENDFILE ( <position-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Position_Spec_List']
+
+class Rewind_Stmt(Base): # R925
+    """
+    <rewind-stmt> = REWIND <file-unit-number>
+                    | REWIND ( <position-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Position_Spec_List']
+
+class Position_Spec(Base): # R926
+    """
+    <position-spec> = [ UNIT = ] <file-unit-number>
+                      | IOMSG = <iomsg-variable>
+                      | IOSTAT = <scalar-int-variable>
+                      | ERR = <label>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Iomsg_Variable', 'Scalar_Int_Variable', 'Label']
+
+class Flush_Stmt(Base): # R927
+    """
+    <flush-stmt> = FLUSH <file-unit-number>
+                    | FLUSH ( <position-spec-list> )
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Position_Spec_List']
+
+class Flush_Spec(Base): # R928
+    """
+    <flush-spec> = [ UNIT = ] <file-unit-number>
+                   | IOMSG = <iomsg-variable>
+                   | IOSTAT = <scalar-int-variable>
+                   | ERR = <label>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'Iomsg_Variable', 'Scalar_Int_Variable', 'Label']
+
+class Inquire_Stmt(Base): # R929
+    """
+    <inquire-stmt> = INQUIRE ( <inquire-spec-list> )
+                     | INQUIRE ( IOLENGTH = <scalar-int-variable> ) <output-item-list>
+    """
+    subclass_names = []
+    use_names = ['Inquire_Spec_List', 'Scalar_Int_Variable', 'Output_Item_List']
+
+class Inquire_Spec(Base): # R930
+    """
+    <inquire-spec> = [ UNIT = ] <file-unit-number>
+                     | FILE = <file-name-expr>
+                     | ACCESS = <scalar-default-char-variable>
+                     | ACTION = <scalar-default-char-variable>
+                     | ASYNCHRONOUS = <scalar-default-char-variable>
+                     | BLANK = <scalar-default-char-variable>
+                     | DECIMAL = <scalar-default-char-variable>
+                     | DELIM = <scalar-default-char-variable>
+                     | DIRECT = <scalar-default-char-variable>
+                     | ENCODING = <scalar-default-char-variable>
+                     | ERR = <label>
+                     | EXIST = <scalar-default-logical-variable>
+                     | FORM = <scalar-default-char-variable>
+                     | FORMATTED = <scalar-default-char-variable>
+                     | ID = <scalar-int-expr>
+                     | IOMSG = <iomsg-variable>
+                     | IOSTAT = <scalar-int-variable>
+                     | NAME = <scalar-default-char-variable>
+                     | NAMED = <scalar-default-logical-variable>
+                     | NEXTREC = <scalar-int-variable>
+                     | NUMBER = <scalar-int-variable>
+                     | OPENED = <scalar-default-logical-variable>
+                     | PAD = <scalar-default-char-variable>
+                     | PENDING = <scalar-default-logical-variable>
+                     | POS = <scalar-int-variable>
+                     | POSITION = <scalar-default-char-variable>
+                     | READ = <scalar-default-char-variable>
+                     | READWRITE = <scalar-default-char-variable>
+                     | RECL = <scalar-int-variable>
+                     | ROUND = <scalar-default-char-variable>
+                     | SEQUENTIAL = <scalar-default-char-variable>
+                     | SIGN = <scalar-default-char-variable>
+                     | SIZE = <scalar-int-variable>
+                     | STREAM = <scalar-default-char-variable>
+                     | UNFORMATTED = <scalar-default-char-variable>
+                     | WRITE = <scalar-default-char-variable>
+    """
+    subclass_names = []
+    use_names = ['File_Unit_Number', 'File_Name_Expr', 'Scalar_Default_Char_Variable',
+                 'Scalar_Default_Logical_Variable', 'Scalar_Int_Variable', 'Scalar_Int_Expr',
+                 'Label', 'Iomsg_Variable']
+
+
 ###############################################################################
 ############################### SECTION 10 ####################################
 ###############################################################################
@@ -3916,6 +4379,7 @@
 
     def _rpl_list(clsname):
         if not Base_classes.has_key(clsname):
+            print 'Not implemented:',clsname
             return [] # remove this code when all classes are implemented
         cls = Base_classes[clsname]
         if cls.__dict__.has_key('match'): return [clsname]
@@ -3956,7 +4420,7 @@
         else:
             print '%s not implemented needed by %s' % (n,clsname)
 
-if 0:
+if 1:
     for cls in Base_classes.values():
         subclasses = Base.subclasses.get(cls.__name__,[])
         subclasses_names = [c.__name__ for c in subclasses]
@@ -3970,7 +4434,7 @@
             break
             if n not in subclasses_names:
                 print '%s needs to be added to %s subclass_name list' % (n,cls.__name__)
-        for n in use_names:            
+        for n in use_names + subclass_names:            
             if not Base_classes.has_key(n):
                 print '%s not defined used by %s' % (n, cls.__name__)
 

Modified: trunk/numpy/f2py/lib/parser/pattern_tools.py
===================================================================
--- trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-10-31 14:58:19 UTC (rev 3422)
+++ trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-11-01 10:09:49 UTC (rev 3423)
@@ -274,6 +274,7 @@
 defined_unary_op = Pattern('<defined-unary-op>','[.][A-Z]+[.]',flags=re.I)
 defined_binary_op = Pattern('<defined-binary-op>','[.][A-Z]+[.]',flags=re.I)
 defined_operator = defined_unary_op | defined_binary_op | extended_intrinsic_operator
+abs_defined_operator = abs(defined_operator)
 
 non_defined_binary_op = intrinsic_operator | logical_literal_constant
 

Added: trunk/numpy/f2py/lib/parser/test_Fortran2003.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2006-10-31 14:58:19 UTC (rev 3422)
+++ trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2006-11-01 10:09:49 UTC (rev 3423)
@@ -0,0 +1,226 @@
+from numpy.testing import *
+
+from Fortran2003 import *
+from api import get_reader
+
+class test_Program(NumpyTestCase):
+
+    def check_simple(self):
+        reader = get_reader('''\
+      subroutine foo
+      end subroutine foo
+      subroutine bar
+      end
+      ''')
+        cls = Program
+        a = cls(reader)
+        print a
+
+class test_Declaration_Type_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Declaration_Type_Spec
+        a = cls('Integer*2')
+        assert isinstance(a, Intrinsic_Type_Spec),`a`
+        assert_equal(str(a), 'INTEGER*2')
+        
+        a = cls('type(foo)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'TYPE(foo)')
+        assert_equal(repr(a), "Declaration_Type_Spec('TYPE', Type_Name('foo'))")
+
+class test_Type_Declaration_Stmt(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Type_Declaration_Stmt
+        a = cls('integer a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'INTEGER :: a')
+        assert_equal(repr(a), "Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None))")
+
+        a = cls('integer ,dimension(2):: a*3')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'INTEGER, DIMENSION(2) :: a*3')
+
+class test_Access_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Access_Spec
+        a = cls('private')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'PRIVATE')
+        assert_equal(repr(a), "Access_Spec('PRIVATE')")
+
+        a = cls('public')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'PUBLIC')
+
+class test_Attr_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Attr_Spec
+        a = cls('allocatable')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'ALLOCATABLE')
+
+        a = cls('dimension(a)')
+        assert isinstance(a, Dimension_Attr_Spec),`a`
+        assert_equal(str(a),'DIMENSION(a)')
+
+class test_Dimension_Attr_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Dimension_Attr_Spec
+        a = cls('dimension(a)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'DIMENSION(a)')
+        assert_equal(repr(a),"Dimension_Attr_Spec('DIMENSION', Name('a'))")
+
+class test_Intent_Attr_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Intent_Attr_Spec
+        a = cls('intent(in)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTENT(IN)')
+        assert_equal(repr(a),"Intent_Attr_Spec('INTENT', Intent_Spec('IN'))")
+
+class test_Language_Binding_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Language_Binding_Spec
+        a = cls('bind(c)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'BIND(C)')
+        assert_equal(repr(a),'Language_Binding_Spec(None)')
+
+        a = cls('bind(c, name="hey")')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'BIND(C, NAME = "hey")')
+
+class test_Entity_Decl(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Entity_Decl
+        a = cls('a(1)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)')
+        assert_equal(repr(a),"Entity_Decl(Name('a'), Int_Literal_Constant('1', None), None, None)")
+
+        a = cls('a(1)*(3)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3)')
+
+        a = cls('a(1)*(3) = 2')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3) = 2')
+
+class test_Prefix_Spec(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Prefix_Spec
+        a = cls('pure')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PURE')
+        assert_equal(repr(a),"Prefix_Spec('PURE')")
+
+        a = cls('elemental')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'ELEMENTAL')
+
+        a = cls('recursive')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'RECURSIVE')
+
+        a = cls('integer * 2')
+        assert isinstance(a, Intrinsic_Type_Spec),`a`
+        assert_equal(str(a),'INTEGER*2')
+
+class test_Prefix(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Prefix
+        a = cls('pure  recursive')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PURE RECURSIVE')
+        assert_equal(repr(a), "Prefix(' ', (Prefix_Spec('PURE'), Prefix_Spec('RECURSIVE')))")
+
+        a = cls('integer * 2 pure')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER*2 PURE')
+
+class test_Subroutine_Stmt(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Subroutine_Stmt
+        a = cls('subroutine foo')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'SUBROUTINE foo')
+        assert_equal(repr(a),"Subroutine_Stmt(None, Name('foo'), None, None)")
+
+        a = cls('pure subroutine foo')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PURE SUBROUTINE foo')
+
+        a = cls('pure subroutine foo(a,b)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PURE SUBROUTINE foo(a, b)')
+
+        a = cls('subroutine foo() bind(c)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'SUBROUTINE foo BIND(C)')
+
+class test_End_Subroutine_Stmt(NumpyTestCase):
+
+    def check_simple(self):
+        cls = End_Subroutine_Stmt
+        a = cls('end subroutine foo')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END SUBROUTINE foo')
+        assert_equal(repr(a),"End_Subroutine_Stmt('SUBROUTINE', Name('foo'))")
+
+        a = cls('end')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END SUBROUTINE')
+
+        a = cls('endsubroutine')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END SUBROUTINE')
+
+class test_Specification_Part(NumpyTestCase):
+
+    def check_simple(self):
+        from api import get_reader
+        reader = get_reader('''\
+      integer a''')
+        cls = Specification_Part
+        a = cls(reader)
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER :: a')
+        assert_equal(repr(a), "Specification_Part(Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None)))")
+
+class test_Subroutine_Subprogram(NumpyTestCase):
+
+    def check_simple(self):
+        from api import get_reader
+        reader = get_reader('''\
+      subroutine foo
+      end subroutine foo''')
+        cls = Subroutine_Subprogram
+        a = cls(reader)
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'SUBROUTINE foo\nEND SUBROUTINE foo')
+        assert_equal(repr(a),"Subroutine_Subprogram(Subroutine_Stmt(None, Name('foo'), None, None), End_Subroutine_Stmt('SUBROUTINE', Name('foo')))")
+
+        reader = get_reader('''\
+      subroutine foo
+        integer a
+      end subroutine foo''')
+        cls = Subroutine_Subprogram
+        a = cls(reader)
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'SUBROUTINE foo\nINTEGER :: a\nEND SUBROUTINE foo')
+
+
+if __name__ == "__main__":
+    NumpyTest().run()



From numpy-svn at scipy.org  Wed Nov  1 23:35:12 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed,  1 Nov 2006 22:35:12 -0600 (CST)
Subject: [Numpy-svn] r3424 - in trunk/numpy: core/include/numpy core/src
	linalg
Message-ID: <20061102043512.306B139C045@new.scipy.org>

Author: oliphant
Date: 2006-11-01 22:35:04 -0600 (Wed, 01 Nov 2006)
New Revision: 3424

Modified:
   trunk/numpy/core/include/numpy/ndarrayobject.h
   trunk/numpy/core/src/multiarraymodule.c
   trunk/numpy/linalg/lapack_litemodule.c
   trunk/numpy/linalg/linalg.py
Log:
Fix problem with dgesdd where the optimal work size is not computed correctly.

Modified: trunk/numpy/core/include/numpy/ndarrayobject.h
===================================================================
--- trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-01 10:09:49 UTC (rev 3423)
+++ trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-02 04:35:04 UTC (rev 3424)
@@ -1114,8 +1114,7 @@
 #define NPY_ITEM_HASOBJECT  0x01  /* Same as needing REFCOUNT */
 
 #define NPY_LIST_PICKLE     0x02  /* Convert to list for pickling */
-#define NPY_ITEM_IS_POINTER 0x06  /* The item is a POINTER -- automatic
-                                     LIST_PICKLE       */
+#define NPY_ITEM_IS_POINTER 0x04  /* The item is a POINTER  */
 
 #define NPY_NEEDS_INIT      0x08  /* memory needs to be initialized 
                                      for this data-type */

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2006-11-01 10:09:49 UTC (rev 3423)
+++ trunk/numpy/core/src/multiarraymodule.c	2006-11-02 04:35:04 UTC (rev 3424)
@@ -7243,6 +7243,7 @@
         ADDCONST(NEEDS_INIT);
         ADDCONST(NEEDS_PYAPI);
         ADDCONST(USE_GETITEM);
+        ADDCONST(USE_SETITEM);
 
         ADDCONST(RAISE);
         ADDCONST(WRAP);

Modified: trunk/numpy/linalg/lapack_litemodule.c
===================================================================
--- trunk/numpy/linalg/lapack_litemodule.c	2006-11-01 10:09:49 UTC (rev 3423)
+++ trunk/numpy/linalg/lapack_litemodule.c	2006-11-02 04:35:04 UTC (rev 3424)
@@ -437,6 +437,33 @@
                           DDATA(vt),&ldvt,DDATA(work),&lwork,IDATA(iwork),
                           &info);
 
+    if (info == 0 && lwork == -1) {
+            /* We need to check the result because
+               sometimes the "optimal" value is actually
+               too small.
+               Change it to the maximum of the minimum and the optimal.
+            */
+            long nwork, work0 = (long) *DDATA(work);
+            int mn = MIN(m,n);
+            int mx = MAX(m,n);
+            switch(jobz){
+            case 'N':
+                    nwork = MAX(work0,3*mn + MAX(mx,6*mn)+500);
+                    break;
+            case 'O':
+                    nwork = MAX(work0,3*mn*mn +                 \
+                                MAX(mx,5*mn*mn+4*mn+500));
+                    break;
+            case 'S':
+            case 'A':
+                    nwork = MAX(work0,3*mn*mn +                 \
+                                MAX(mx,4*mn*(mn+1))+500);
+                    break;
+            defaul:
+                    nwork = work0;
+            }
+            *DDATA(work) = (double) nwork;
+    }
     return Py_BuildValue("{s:i,s:c,s:i,s:i,s:i,s:i,s:i,s:i,s:i}","dgesdd_",
                          lapack_lite_status__,"jobz",jobz,"m",m,"n",n,
                          "lda",lda,"ldu",ldu,"ldvt",ldvt,"lwork",lwork,

Modified: trunk/numpy/linalg/linalg.py
===================================================================
--- trunk/numpy/linalg/linalg.py	2006-11-01 10:09:49 UTC (rev 3423)
+++ trunk/numpy/linalg/linalg.py	2006-11-02 04:35:04 UTC (rev 3424)
@@ -590,15 +590,6 @@
         results = lapack_routine(option, m, n, a, m, s, u, m, vt, nvt,
                                  work, -1, iwork, 0)
         lwork = int(work[0])
-        if option == 'N' and lwork==1:
-            # there seems to be a bug in dgesdd of lapack
-            #   (NNemec, 060310)
-            # returning the wrong lwork size for option == 'N'
-            results = lapack_routine('A', m, n, a, m, s, u, m, vt, n,
-                                     work, -1, iwork, 0)
-            lwork = int(work[0])
-            assert lwork > 1
-
         work = zeros((lwork,), t)
         results = lapack_routine(option, m, n, a, m, s, u, m, vt, nvt,
                                  work, lwork, iwork, 0)



From numpy-svn at scipy.org  Thu Nov  2 11:07:54 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu,  2 Nov 2006 10:07:54 -0600 (CST)
Subject: [Numpy-svn] r3425 - in trunk/numpy: f2py lib
Message-ID: <20061102160754.6138A39C073@new.scipy.org>

Author: oliphant
Date: 2006-11-02 10:07:43 -0600 (Thu, 02 Nov 2006)
New Revision: 3425

Modified:
   trunk/numpy/f2py/crackfortran.py
   trunk/numpy/lib/shape_base.py
Log:
Apply #368

Modified: trunk/numpy/f2py/crackfortran.py
===================================================================
--- trunk/numpy/f2py/crackfortran.py	2006-11-02 04:35:04 UTC (rev 3424)
+++ trunk/numpy/f2py/crackfortran.py	2006-11-02 16:07:43 UTC (rev 3425)
@@ -1647,13 +1647,13 @@
             if args is not None and b['name'] not in args:
                 continue
             else:
-                as=b['args']
+                as_=b['args']
             if b['name'] in skipfuncs:
                 continue
             if onlyfuncs and b['name'] not in onlyfuncs:
                 continue
-        else: as=args
-        b=postcrack(b,as,tab=tab+'\t')
+        else: as_=args
+        b=postcrack(b,as_,tab=tab+'\t')
         if b['block']=='interface' and not b['body']:
             if not b.has_key('f2pyenhancements'):
                 continue

Modified: trunk/numpy/lib/shape_base.py
===================================================================
--- trunk/numpy/lib/shape_base.py	2006-11-02 04:35:04 UTC (rev 3424)
+++ trunk/numpy/lib/shape_base.py	2006-11-02 16:07:43 UTC (rev 3425)
@@ -553,20 +553,20 @@
     ndb, nda = b.ndim, a.ndim
     if (nda == 0 or ndb == 0):
         return _nx.multiply(a,b)
-    as = a.shape
+    as_ = a.shape
     bs = b.shape
     if not a.flags.contiguous:
-        a = reshape(a, as)
+        a = reshape(a, as_)
     if not b.flags.contiguous:
         b = reshape(b, bs)
     nd = ndb
     if (ndb != nda):
         if (ndb > nda):
-            as = (1,)*(ndb-nda) + as
+            as_ = (1,)*(ndb-nda) + as_
         else:
             bs = (1,)*(nda-ndb) + bs
             nd = nda        
-    result = outer(a,b).reshape(as+bs)
+    result = outer(a,b).reshape(as_+bs)
     axis = nd-1
     for k in xrange(nd):
         result = concatenate(result, axis=axis)



From numpy-svn at scipy.org  Thu Nov  2 11:12:36 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu,  2 Nov 2006 10:12:36 -0600 (CST)
Subject: [Numpy-svn] r3426 - trunk/numpy/lib
Message-ID: <20061102161236.A319CC84002@new.scipy.org>

Author: oliphant
Date: 2006-11-02 10:12:34 -0600 (Thu, 02 Nov 2006)
New Revision: 3426

Modified:
   trunk/numpy/lib/function_base.py
Log:
Fix #369: windows returning invalid results for M=1

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2006-11-02 16:07:43 UTC (rev 3425)
+++ trunk/numpy/lib/function_base.py	2006-11-02 16:12:34 UTC (rev 3426)
@@ -920,24 +920,40 @@
 def blackman(M):
     """blackman(M) returns the M-point Blackman window.
     """
+    if M < 1:
+        return array([])
+    if M == 1:
+        return ones(1, float)
     n = arange(0,M)
     return 0.42-0.5*cos(2.0*pi*n/(M-1)) + 0.08*cos(4.0*pi*n/(M-1))
 
 def bartlett(M):
     """bartlett(M) returns the M-point Bartlett window.
     """
+    if M < 1:
+        return array([])
+    if M == 1:
+        return ones(1, float)
     n = arange(0,M)
     return where(less_equal(n,(M-1)/2.0),2.0*n/(M-1),2.0-2.0*n/(M-1))
 
 def hanning(M):
     """hanning(M) returns the M-point Hanning window.
     """
+    if M < 1:
+        return array([])
+    if M == 1:
+        return ones(1, float)
     n = arange(0,M)
     return 0.5-0.5*cos(2.0*pi*n/(M-1))
 
 def hamming(M):
     """hamming(M) returns the M-point Hamming window.
     """
+    if M < 1:
+        return array([])
+    if M == 1:
+        return ones(1,float)
     n = arange(0,M)
     return 0.54-0.46*cos(2.0*pi*n/(M-1))
 



From numpy-svn at scipy.org  Fri Nov  3 16:57:28 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  3 Nov 2006 15:57:28 -0600 (CST)
Subject: [Numpy-svn] r3427 - in trunk/numpy/f2py/lib: . parser
Message-ID: <20061103215728.644E139C0E6@new.scipy.org>

Author: pearu
Date: 2006-11-03 15:57:11 -0600 (Fri, 03 Nov 2006)
New Revision: 3427

Removed:
   trunk/numpy/f2py/lib/parser/test_expressions.py
   trunk/numpy/f2py/lib/parser/test_statements2.py
Modified:
   trunk/numpy/f2py/lib/main.py
   trunk/numpy/f2py/lib/parser/Fortran2003.py
   trunk/numpy/f2py/lib/parser/api.py
   trunk/numpy/f2py/lib/parser/base_classes.py
   trunk/numpy/f2py/lib/parser/pattern_tools.py
   trunk/numpy/f2py/lib/parser/test_Fortran2003.py
Log:
F2PY G3: continued F2003 parser implementation and unittesting.

Modified: trunk/numpy/f2py/lib/main.py
===================================================================
--- trunk/numpy/f2py/lib/main.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/main.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -38,7 +38,7 @@
 Options
 -------
 
-  --3g-numpy       Use numpy.f2py.lib tool, the 3rd generation of F2PY,
+  --g3-numpy       Use numpy.f2py.lib tool, the 3rd generation of F2PY,
                    with NumPy support.
   --2d-numpy       Use numpy.f2py tool with NumPy support. [DEFAULT]
   --2d-numeric     Use f2py2e tool with Numeric support.
@@ -48,6 +48,7 @@
                    file <modulename>module.c or extension module <modulename>.
                    For wrapping Fortran 90 modules, f2py will use Fortran
                    module names.
+  --parse          Parse Fortran files and print result to stdout.
 
 
 Options effective only with -h
@@ -98,6 +99,7 @@
 
 import re
 import shutil
+import parser.api
 from parser.api import parse, PythonModule, EndStatement, Module, Subroutine, Function
 
 def get_values(sys_argv, prefix='', suffix='', strip_prefix=False, strip_suffix=False):
@@ -154,6 +156,33 @@
 def get_signature_output(sys_argv):
     return get_option_value(sys_argv,'-h','stdout')
 
+
+def parse_files(sys_argv):
+    flag = 'file'
+    file_names = [] 
+    only_names = []
+    skip_names = []
+    options = []
+    for word in sys_argv:
+        if word=='': pass
+        elif word=='only:': flag = 'only'
+        elif word=='skip:': flag = 'skip'
+        elif word==':': flag = 'file'
+        elif word.startswith('--'): options.append(word)
+        else:
+            {'file': file_names,'only': only_names, 'skip': skip_names}[flag].append(word)
+
+    if options:
+        sys.stderr.write('Unused options: %s\n' % (', '.join(options)))
+    for filename in file_names:
+        if not os.path.isfile(filename):
+            sys.stderr.write('No or not a file %r. Skipping.\n' % (filename))
+            continue
+        sys.stderr.write('Parsing %r..\n' % (filename))
+        reader = parser.api.get_reader(filename)
+        print parser.api.Fortran2003.Program(reader)
+    return
+
 def dump_signature(sys_argv):
     """ Read Fortran files and dump the signatures to file or stdout.
     XXX: Not well tested.
@@ -303,7 +332,7 @@
         clean_build_dir = True
     else:
         clean_build_dir = False
-    if not os.path.exists(build_dir): os.makedirs(build_dir)
+    if build_dir and not os.path.exists(build_dir): os.makedirs(build_dir)
 
     include_dirs = get_values(sys_argv,'-I',strip_prefix=True)
     library_dirs = get_values(sys_argv,'-L',strip_prefix=True)
@@ -408,6 +437,10 @@
         sys_argv.remove('-c')
         build_extension(sys_argv)
         return
+    if '--parse' in sys_argv:
+        sys_argv.remove('--parse')
+        parse_files(sys_argv)
+        return
     if '-h' in sys_argv:
         dump_signature(sys_argv)
         return

Modified: trunk/numpy/f2py/lib/parser/Fortran2003.py
===================================================================
--- trunk/numpy/f2py/lib/parser/Fortran2003.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/Fortran2003.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -24,12 +24,26 @@
 class NoMatchError(Exception):
     pass
 
+class ParseError(Exception):
+    pass
+
 class Base(object):
+    """ Base class for Fortran 2003 syntax rules.
+
+    All Base classes have the following attributes:
+      .string - original argument to construct a class instance, it's type
+                is either str or FortranReaderBase.
+      .item   - Line instance (holds label) or None.
     """
-    """
     subclasses = {}
 
-    def __new__(cls, string):
+    def __new__(cls, string, parent_cls = None):
+        """
+        """
+        if parent_cls is None:
+            parent_cls = [cls]
+        elif cls not in parent_cls:
+            parent_cls.append(cls)
         #print '__new__:',cls.__name__,`string`
         match = cls.__dict__.get('match', None)
         if isinstance(string, FortranReaderBase) and not issubclass(cls, BlockBase) \
@@ -38,41 +52,52 @@
             item = reader.get_item()
             if item is None: return
             try:
-                obj = cls(item.line)
+                obj = cls(item.line, parent_cls = parent_cls)
             except NoMatchError:
                 obj = None
             if obj is None:
                 reader.put_item(item)
                 return
-            obj._item = item
+            obj.item = item
             return obj
+        errmsg = '%s: %r' % (cls.__name__, string)
         if match is not None:
-            result = cls.match(string)
+            try:
+                result = cls.match(string)
+            except NoMatchError, msg:
+                if str(msg)==errmsg: # avoid recursion 1.
+                    raise
+                result = None
         else:
             result = None
+
         #print '__new__:result:',cls.__name__,`string,result`
         if isinstance(result, tuple):
             obj = object.__new__(cls)
             obj.string = string
-            if hasattr(cls, 'init'):
-                obj.init(*result)
+            obj.item = None
+            if hasattr(cls, 'init'): obj.init(*result)
             return obj
         elif isinstance(result, Base):
             return result
         elif result is None:
             for subcls in Base.subclasses.get(cls.__name__,[]):
-                #print cls.__name__,subcls.__name__,`string`
+                if subcls in parent_cls: # avoid recursion 2.
+                    continue
+                #print '%s:%s: %r' % (cls.__name__,subcls.__name__,string)
                 try:
-                    return subcls(string)
-                except NoMatchError:
-                    pass
+                    obj = subcls(string, parent_cls = parent_cls)
+                except NoMatchError, msg:
+                    obj = None
+                if obj is not None:
+                    return obj
         else:
             raise AssertionError,`result`
-        raise NoMatchError,'%s: %r' % (cls.__name__, string)
+        raise NoMatchError,errmsg
 
-    def restore_reader(self):
-        self._item.reader.put_item(self._item)
-        return
+##     def restore_reader(self):
+##         self._item.reader.put_item(self._item)
+##         return
 
     def init_list(self, *items):
         self.items = items
@@ -84,23 +109,19 @@
     def torepr_list(self):
         return '%s(%s)' % (self.__class__.__name__,', '.join(map(repr,self.items)))
 
-    def __str__(self):
-        return self.tostr()
-        if self.__class__.__dict__.has_key('tostr'):
-            return self.tostr()
-        return repr(self)
+    def __str__(self): return self.tostr()
 
-    def __repr__(self):
-        return self.torepr()
-        if self.__class__.__dict__.has_key('torepr'):
-            return self.torepr()
-        return '%s(%r)' % (self.__class__.__name__, self.string)
+    def __repr__(self): return self.torepr()
 
     def __cmp__(self, other):
         if self is other: return 0
         if not isinstance(other, self.__class__): return -1
         return self.compare(other)
 
+    def tofortran(self, tab='', isfix=None):
+        return tab + str(self)
+
+
 class BlockBase(Base):
     """
     <block-base> = [ <startcls> ]
@@ -151,14 +172,19 @@
                 if item is not None:
                     reader.error('failed to parse with %s, skipping.' % ('|'.join([c.__name__ for c in classes[i:]])), item)
                     continue
-                reader.error('unexpected eof file while looking line for <%s>.' % (classes[-1].__name__.lower().replace('_','-')))
+                if hasattr(content[0],'name'):
+                    reader.error('unexpected eof file while looking line for <%s> of %s.'\
+                                 % (classes[-1].__name__.lower().replace('_','-'), content[0].name))
+                else:
+                    reader.error('unexpected eof file while looking line for <%s>.'\
+                                 % (classes[-1].__name__.lower().replace('_','-')))
             break
         if not content: return
         if startcls is not None and endcls is not None:
             # check names of start and end statements:
             start_stmt = content[0]
             end_stmt = content[-1]
-            if isinstance(end_stmt, endcls) and hasattr(end_stmt, 'name'):
+            if isinstance(end_stmt, endcls) and hasattr(end_stmt, 'name') and hasattr(start_stmt, 'name'):
                 if end_stmt.name is not None:
                     if start_stmt.name != end_stmt.name:
                         end_stmt._item.reader.error('expected <%s-name> is %s but got %s. Ignoring.'\
@@ -172,17 +198,31 @@
         self.content = content
         return
     def tostr(self):
-        return '\n'.join(map(str, self.content))
+        return self.tofortran()
     def torepr(self):
         return '%s(%s)' % (self.__class__.__name__,', '.join(map(repr, self.content)))
 
-    def restore_reader(self):
-        content = self.content[:]
-        content.reverse()
-        for obj in content:
-            obj.restore_reader()
-        return
-    
+    def tofortran(self, tab='', isfix=None):
+        l = []
+        start = self.content[0]
+        end = self.content[-1]
+        extra_tab = ''
+        if isinstance(end, EndStmtBase):
+            extra_tab = '  '
+        l.append(start.tofortran(tab=tab,isfix=isfix))
+        for item in self.content[1:-1]:
+            l.append(item.tofortran(tab=tab+extra_tab,isfix=isfix))
+        if len(self.content)>1:
+            l.append(end.tofortran(tab=tab,isfix=isfix))
+        return '\n'.join(l)
+
+##     def restore_reader(self):
+##         content = self.content[:]
+##         content.reverse()
+##         for obj in content:
+##             obj.restore_reader()
+##         return
+
 class SequenceBase(Base):
     """
     <sequence-base> = <obj>, <obj> [ , <obj> ]...
@@ -245,15 +285,26 @@
     """
     def match(lhs_cls, op_pattern, rhs_cls, string, right=True):
         line, repmap = string_replace_map(string)
-        if right:
-            t = op_pattern.rsplit(line)
+        if isinstance(op_pattern, str):
+            if right:
+                t = line.rsplit(op_pattern,1)
+            else:
+                t = line.split(op_pattern,1)
+            if len(t)!=2: return
+            lhs, rhs = t[0].rstrip(), t[1].lstrip()
+            op = op_pattern
         else:
-            t = op_pattern.lsplit(line)
-        if t is None or len(t)!=3: return
-        lhs, op, rhs = t
+            if right:
+                t = op_pattern.rsplit(line)
+            else:
+                t = op_pattern.lsplit(line)
+            if t is None or len(t)!=3: return
+            lhs, op, rhs = t
+            lhs = lhs.rstrip()
+            rhs = rhs.lstrip()
+            op = op.upper()
         if not lhs: return
         if not rhs: return
-        op = op.upper()
         lhs_obj = lhs_cls(repmap(lhs))
         rhs_obj = rhs_cls(repmap(rhs))
         return lhs_obj, op, rhs_obj
@@ -270,25 +321,78 @@
     def compare(self, other):
         return cmp((self.op,self.lhs,self.rhs),(other.op,other.lhs,other.rhs))
 
-class SeparatorBase(BinaryOpBase):
+class SeparatorBase(Base):
     """
-    <shape-base> = <lhs> : <rhs>
+    <separator-base> = [ <lhs> ] : [ <rhs> ]
     """
-    def init(self, lhs, rhs):
-        self.lhs = lhs
-        self.op = ':'
-        self.rhs = rhs
+    def match(lhs_cls, rhs_cls, string, require_lhs=False, require_rhs=False):
+        line, repmap = string_replace_map(string)
+        if ':' not in line: return
+        lhs,rhs = line.split(':',1)
+        lhs = lhs.rstrip()
+        rhs = rhs.lstrip()
+        lhs_obj, rhs_obj = None, None
+        if lhs:
+            if lhs_cls is None: return
+            lhs_obj = lhs_cls(repmap(lhs))
+        elif require_lhs:
+            return
+        if rhs:
+            if rhs_cls is None: return
+            rhs_obj = rhs_cls(repmap(rhs))
+        elif require_rhs:
+            return
+        return lhs_obj, rhs_obj
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
         return
+    def tostr(self):
+        s = ''
+        if self.items[0] is not None:
+            s += '%s :' % (self.items[0])
+        else:
+            s += ':'
+        if self.items[1] is not None:
+            s += ' %s' % (self.items[1])
+        return s
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
-class KeywordValueBase(BinaryOpBase):
+class KeywordValueBase(Base):
     """
-    <keyword-value-base> = <keyword> = <rhs>
+    <keyword-value-base> = [ <lhs> = ] <rhs>
     """
-    def match(cls, string):
-        if '=' not in string: return
+    def match(lhs_cls, rhs_cls, string, require_lhs = True, upper_lhs = False):
+        if require_lhs and '=' not in string: return
+        if isinstance(lhs_cls, (list, tuple)):
+            for s in lhs_cls:
+                try:
+                    obj = KeywordValueBase.match(s, rhs_cls, string, require_lhs=require_lhs, upper_lhs=upper_lhs)
+                except NoMatchError:
+                    obj = None
+                if obj is not None: return obj
+            return obj
         lhs,rhs = string.split('=',1)
-        return Keyword(lhs.rstrip()),'=',cls(rhs.lstrip())
+        lhs = lhs.rstrip()
+        rhs = rhs.lstrip()
+        if not rhs: return
+        if not lhs:
+            if require_lhs: return
+            return None, rhs_cls(rhs)
+        if isinstance(lhs_cls, str):
+            if upper_lhs:
+                lhs = lhs.upper()
+            if lhs_cls!=lhs: return
+            return lhs, rhs_cls(rhs)
+        return lhs_cls(lhs),rhs_cls(rhs)
     match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        if self.items[0] is None: return str(self.items[1])
+        return '%s = %s' % tuple(self.items)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class BracketBase(Base):
     """
@@ -317,8 +421,6 @@
     def compare(self, other):
         return cmp((self.left,self.item,self.right),(other.left,other.item,other.right))
 
-
-
 class NumberBase(Base):
     """
     <number-base> = <number> [ _ <kind-param> ]
@@ -344,7 +446,7 @@
     """
     <call-base> = <lhs> ( [ <rhs> ] )
     """
-    def match(lhs_cls, rhs_cls, string):
+    def match(lhs_cls, rhs_cls, string, upper_lhs = False, require_rhs=False):
         if not string.endswith(')'): return
         line, repmap = string_replace_map(string)
         i = line.find('(')
@@ -353,27 +455,54 @@
         if not lhs: return
         rhs = line[i+1:-1].strip()
         lhs = repmap(lhs)
+        if upper_lhs:
+            lhs = lhs.upper()
+        rhs = repmap(rhs)
+        if isinstance(lhs_cls, str):
+            if lhs_cls!=lhs: return
+        else:
+            lhs = lhs_cls(lhs)
         if rhs:
-            rhs = repmap(rhs)
-            return lhs_cls(lhs), rhs_cls(rhs)
-        return lhs_cls(lhs), None
+            if isinstance(rhs_cls, str):
+                if rhs_cls!=rhs: return
+            else:
+                rhs = rhs_cls(rhs)
+            return lhs, rhs
+        elif require_rhs:
+            return
+        return lhs, None
     match = staticmethod(match)
-    def init(self, lhs, rhs):
-        self.lhs = lhs
-        self.rhs = rhs
+    def init(self, *args):
+        self.items = args
         return
     def tostr(self):
-        if self.rhs is None: return '%s()' % (self.lhs)
-        return '%s(%s)' % (self.lhs, self.rhs)
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.lhs, self.rhs)
+        if self.items[1] is None: return '%s()' % (self.items[0])
+        return '%s(%s)' % (self.items[0], self.items[1])
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
     def compare(self, other):
-        return cmp((self.lhs,self.rhs),(other.lhs,other.rhs))
+        return cmp(self.items,other.items)
 
+class CALLBase(CallBase):
+    """
+    <CALL-base> = <LHS> ( [ <rhs> ] )
+    """
+    def match(lhs_cls, rhs_cls, string, require_rhs = False):
+        return CallBase.match(lhs_cls, rhs_cls, string, upper_lhs=True, require_rhs = require_rhs)
+    match = staticmethod(match)
+
 class StringBase(Base):
     """
     <string-base> = <xyz>
     """
     def match(pattern, string):
+        if isinstance(pattern, (list,tuple)):
+            for p in pattern:
+                obj = StringBase.match(p, string)
+                if obj is not None: return obj
+            return
+        if isinstance(pattern, str):
+            if len(pattern)==len(string) and pattern==string: return string,
+            return
         if pattern.match(string): return string,
         return
     match = staticmethod(match)
@@ -390,25 +519,60 @@
     <STRING-base> = <XYZ>
     """
     match = staticmethod(StringBase.match)
-    def init(self, string):
-        self.string = string.upper()
+    def match(pattern, string):
+        if isinstance(pattern, (list,tuple)):
+            for p in pattern:
+                obj = STRINGBase.match(p, string)
+                if obj is not None: return obj
+            return
+        STRING = string.upper()
+        if isinstance(pattern, str):
+            if len(pattern)==len(string) and pattern==STRING: return STRING,
+            return
+        if pattern.match(STRING): return STRING,
         return
+    match = staticmethod(match)
 
-class EndStmtBase(Base):
+class StmtBase(Base):
     """
+    [ <label> ] <stmt>
+    """
+    def tofortran(self, tab='', isfix=None):
+        label = None
+        if self.item is not None: label = self.item.label
+        if isfix:
+            colon = ''
+            c = ' '
+        else:
+            colon = ':'
+            c = ''
+        if label:
+            t = c + label + colon
+            if isfix:
+                while len(t)<6: t += ' '
+            else:
+                tab = tab[len(t):] or ' '
+        else:
+            t = ''
+        return t + tab + str(self)
+
+class EndStmtBase(StmtBase):
+    """
     <end-stmt-base> = END [ <stmt> [ <stmt-name>] ]
     """
-    def match(stmt_type, stmt_name, string):
+    def match(stmt_type, stmt_name, string, require_stmt_type=False):
         start = string[:3].upper()
         if start != 'END': return
         line = string[3:].lstrip()
         start = line[:len(stmt_type)].upper()
         if start:
-            if start != stmt_type: return
+            if start.replace(' ','') != stmt_type.replace(' ',''): return
             line = line[len(stmt_type):].lstrip()
         else:
+            if require_stmt_type: return
             line = ''
         if line:
+            if stmt_name is None: return
             return stmt_type, stmt_name(line)
         return stmt_type, None
     match = staticmethod(match)
@@ -424,7 +588,60 @@
     def compare(self, other):
         return cmp((self.type,self.name),(other.type,other.name))
 
+def _ensure_single_spaces(string):
+    return ' '.join([s for s in string.split(' ') if s])
 
+class WORDClsBase(Base):
+    """
+    <WORD-cls> = <WORD> [ [ :: ] <cls> ]
+    """
+    def match(pattern, cls, string, check_colons=False, require_cls=False):
+        if isinstance(pattern, (tuple,list)):
+            for p in pattern:
+                try:
+                    obj = WORDClsBase.match(p, cls, string, check_colons=check_colons, require_cls=require_cls)
+                except NoMatchError:
+                    obj = None
+                if obj is not None: return obj
+            return
+        if isinstance(pattern, str):
+            if string[:len(pattern)].upper()!=pattern: return
+            line = string[len(pattern):]
+            if not line: return pattern, None
+            if 'a'<=line[0].lower()<='z' or line[0]=='_': return
+            line = line.lstrip()
+            if not line:
+                if require_cls: return
+                return pattern, None
+            if cls is None: return
+            return pattern, cls(line)
+        m = pattern.match(string)
+        if m is None: return
+        line = string[len(m.group()):]
+        if pattern.value is not None:
+            pattern_value = pattern.value
+        else:
+            pattern_value = m.group().upper()
+        if not line: return pattern_value, None
+        if 'a'<=line[0].lower()<='z' or line[0]=='_': return
+        line = line.lstrip()
+        if not line:
+            if require_cls: return
+            return pattern_value, None
+        if cls is None: return
+        return pattern_value, cls(line)
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        if self.items[1] is None: return str(self.items[0])
+        s = str(self.items[1])
+        if s and s[0] in '(*':
+            return '%s%s' % (self.items[0], s)
+        return '%s %s' % (self.items[0], s)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
+
 ###############################################################################
 ############################### SECTION  1 ####################################
 ###############################################################################
@@ -512,7 +729,7 @@
                       'Interface_Block', 'Parameter_Stmt', 'Procedure_Declaration_Stmt',
                       'Specification_Stmt', 'Type_Declaration_Stmt', 'Stmt_Function_Stmt']
 
-class Execution_Part(Base): # R208
+class Execution_Part(BlockBase): # R208
     """
     <execution-part> = <executable-construct>
                        | [ <execution-part-construct> ]...
@@ -520,7 +737,9 @@
     <execution-part> shall not contain <end-function-stmt>, <end-program-stmt>, <end-subroutine-stmt>
     """
     subclass_names = []
-    use_names = ['Executable_Construct', 'Execution_Part_Construct']
+    use_names = ['Executable_Construct_C201', 'Execution_Part_Construct_C201']
+    def match(string): return BlockBase.match(Executable_Construct_C201, [Execution_Part_Construct_C201], None, string)
+    match = staticmethod(match)
 
 class Execution_Part_Construct(Base): # R209
     """
@@ -531,6 +750,9 @@
     """
     subclass_names = ['Executable_Construct', 'Format_Stmt', 'Entry_Stmt', 'Data_Stmt']
 
+class Execution_Part_Construct_C201(Base):
+    subclass_names = ['Executable_Construct_C201', 'Format_Stmt', 'Entry_Stmt', 'Data_Stmt']
+
 class Internal_Subprogram_Part(Base): # R210
     """
     <internal-subprogram-part> = <contains-stmt>
@@ -589,6 +811,11 @@
     subclass_names = ['Action_Stmt', 'Associate_Stmt', 'Case_Construct', 'Do_Construct',
                       'Forall_Construct', 'If_Construct', 'Select_Type_Construct', 'Where_Construct']
 
+class Executable_Construct_C201(Base):
+    subclass_names = Executable_Construct.subclass_names[:]
+    subclass_names[subclass_names.index('Action_Stmt')] = 'Action_Stmt_C201'
+    
+
 class Action_Stmt(Base):# R214
     """
     <action-stmt> = <allocate-stmt>
@@ -631,7 +858,42 @@
                       'Read_Stmt', 'Return_Stmt', 'Rewind_Stmt', 'Stop_Stmt', 'Wait_Stmt',
                       'Where_Stmt', 'Write_Stmt', 'Arithmetic_If_Stmt', 'Computed_Goto_Stmt']
 
+class Action_Stmt_C201(Base):
+    """
+    <action-stmt-c201> = <action-stmt>
+    C201 is applied.
+    """
+    subclass_names = Action_Stmt.subclass_names[:]
+    subclass_names.remove('End_Function_Stmt')
+    subclass_names.remove('End_Subroutine_Stmt')
+    #subclass_names.remove('End_Program_Stmt')
 
+class Action_Stmt_C802(Base):
+    """
+    <action-stmt-c802> = <action-stmt>
+    C802 is applied.
+    """
+    subclass_names = Action_Stmt.subclass_names[:]
+    subclass_names.remove('End_Function_Stmt')
+    subclass_names.remove('End_Subroutine_Stmt')
+    subclass_names.remove('If_Stmt')
+
+class Action_Stmt_C824(Base):
+    """
+    <action-stmt-c824> = <action-stmt>
+    C824 is applied.
+    """
+    subclass_names = Action_Stmt.subclass_names[:]
+    subclass_names.remove('End_Function_Stmt')
+    subclass_names.remove('End_Subroutine_Stmt')
+    subclass_names.remove('Continue_Stmt')
+    subclass_names.remove('Goto_Stmt')
+    subclass_names.remove('Return_Stmt')
+    subclass_names.remove('Stop_Stmt')
+    subclass_names.remove('Exit_Stmt')
+    subclass_names.remove('Cycle_Stmt')
+    subclass_names.remove('Arithmetic_If_Stmt')
+
 class Keyword(Base): # R215
     """
     <keyword> = <name>
@@ -714,7 +976,7 @@
     """
     subclass_names = ['Intrinsic_Type_Spec', 'Derived_Type_Spec']
 
-class Type_Param_Value(Base): # R402
+class Type_Param_Value(StringBase): # R402
     """
     <type-param-value> = <scalar-int-expr>
                        | *
@@ -722,15 +984,10 @@
     """
     subclass_names = ['Scalar_Int_Expr']
     use_names = []
-    def match(string):
-        if string in ['*',':']: return string,
-        return
+    def match(string): return StringBase.match(['*',':'], string)
     match = staticmethod(match)
-    def init(self, value): self.value = value
-    def tostr(self): return str(self.value)
-    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.value)
 
-class Intrinsic_Type_Spec(Base): # R403
+class Intrinsic_Type_Spec(WORDClsBase): # R403
     """
     <intrinsic-type-spec> = INTEGER [ <kind-selector> ]
                             | REAL [ <kind-selector> ]
@@ -746,46 +1003,24 @@
     use_names = ['Kind_Selector','Char_Selector']
         
     def match(string):
-        if string[:7].upper()=='INTEGER':
-            t = string[:7].upper()
-            line = string[7:].lstrip()
-            if line: return t,Kind_Selector(line)
-            return t,None
-        elif string[:4].upper()=='REAL':
-            t = string[:4].upper()
-            line = string[4:].lstrip()
-            if line: return t,Kind_Selector(line)
-            return t,None
-        elif string[:7].upper()=='COMPLEX':
-            t = string[:7].upper()
-            line = string[7:].lstrip()
-            if line: return t,Kind_Selector(line)
-            return t,None
-        elif string[:7].upper()=='LOGICAL':
-            t = string[:7].upper()
-            line = string[7:].lstrip()
-            if line: return t,Kind_Selector(line)
-            return t,None
-        elif string[:9].upper()=='CHARACTER':
-            t = string[:9].upper()
-            line = string[9:].lstrip()
-            if line: return t,Char_Selector(line)
-        elif string[:6].upper()=='DOUBLE':
-            line = string[6:].lstrip().upper()
-            if line=='COMPLEX':
-                return 'DOUBLE COMPLEX',None
-            if line=='PRECISION':
-                return 'DOUBLE PRECISION',None
-        elif string.upper()=='BYTE':
-            return 'BYTE',None
+        for w,cls in [('INTEGER',Kind_Selector),
+                      ('REAL',Kind_Selector),
+                      ('COMPLEX',Kind_Selector),
+                      ('LOGICAL',Kind_Selector),
+                      ('CHARACTER',Char_Selector),
+                      (pattern.abs_double_complex_name, None),
+                      (pattern.abs_double_precision_name, None),
+                      ('BYTE', None),
+                      ]:
+            try:
+                obj = WORDClsBase.match(w,cls,string)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
         return
     match = staticmethod(match)
-    init = Base.init_list
-    def tostr(self):
-        if self.items[1] is None: return str(self.items[0])
-        return '%s%s' % tuple(self.items)
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
 
+
 class Kind_Selector(Base): # R404
     """
     <kind-selector> = ( [ KIND = ] <scalar-int-initialization-expr> )
@@ -847,41 +1082,32 @@
     """
     subclass_names = ['Binary_Constant','Octal_Constant','Hex_Constant']
 
-class Binary_Constant(StringBase): # R412
+class Binary_Constant(STRINGBase): # R412
     """
     <binary-constant> = B ' <digit> [ <digit> ]... '
                         | B \" <digit> [ <digit> ]... \"
     """
     subclass_names = []
-    def match(string): return StringBase.match(pattern.abs_binary_constant, string)
+    def match(string): return STRINGBase.match(pattern.abs_binary_constant, string)
     match = staticmethod(match)
-    def init(self, string):
-        self.string = string.upper()
-        return
 
-class Octal_Constant(StringBase): # R413
+class Octal_Constant(STRINGBase): # R413
     """
     <octal-constant> = O ' <digit> [ <digit> ]... '
                        | O \" <digit> [ <digit> ]... \"
     """
     subclass_names = []
-    def match(string): return StringBase.match(pattern.abs_octal_constant, string)
+    def match(string): return STRINGBase.match(pattern.abs_octal_constant, string)
     match = staticmethod(match)
-    def init(self, string):
-        self.string = string.upper()
-        return
 
-class Hex_Constant(StringBase): # R414
+class Hex_Constant(STRINGBase): # R414
     """
     <hex-constant> = Z ' <digit> [ <digit> ]... '
                      | Z \" <digit> [ <digit> ]... \"
     """
     subclass_names = []
-    def match(string): return StringBase.match(pattern.abs_hex_constant, string)
+    def match(string): return STRINGBase.match(pattern.abs_hex_constant, string)
     match = staticmethod(match)
-    def init(self, string):
-        self.string = string.upper()
-        return
 
 #R415: <hex-digit> = <digit> | A | B | C | D | E | F
 
@@ -913,7 +1139,7 @@
     subclass_names = []
     use_names = ['Real_Part','Imag_Part']
     def match(string):
-        if string[0]+string[-1]!='()': return
+        if not string or string[0]+string[-1]!='()': return
         if not pattern.abs_complex_literal_constant.match(string):
             return
         r,i = string[1:-1].split(',')
@@ -1092,12 +1318,43 @@
     use_names = ['Derived_Type_Stmt', 'Type_Param_Def_Stmt', 'Private_Or_Sequence',
                  'Component_Part', 'Type_Bound_Procedure_Part', 'End_Type_Stmt']
 
-class Derived_Type_Stmt(Base): # R430
+class Derived_Type_Stmt(StmtBase): # R430
     """
     <derived-type-stmt> = TYPE [ [ , <type-attr-spec-list> ] :: ] <type-name> [ ( <type-param-name-list> ) ]
     """
     subclass_names = []
     use_names = ['Type_Attr_Spec_List', 'Type_Name', 'Type_Param_Name_List']
+    def match(string):
+        if string[:4].upper()!='TYPE': return
+        line = string[4:].lstrip()
+        i = line.find('::')
+        attr_specs = None
+        if i!=-1:
+            if line.startswith(','):
+                l = line[1:i].strip()
+                if not l: return
+                attr_specs = Type_Attr_Spec_List(l)
+            line = line[i+2:].lstrip()
+        m = pattern.name.match(line)
+        if m is None: return
+        name = Type_Name(m.group())
+        line = line[m.end():].lstrip()
+        if not line: return attr_specs, name, None
+        if line[0]+line[-1]!='()': return
+        return attr_specs, name, Type_Param_Name_List(line[1:-1].strip())
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+    def tostr(self):
+        s = 'TYPE'
+        if self.items[0] is not None:
+            s += ', %s :: %s' % (self.items[0], self.items[1])
+        else:
+            s += ' :: %s' % (self.items[1])
+        if self.items[2] is not None:
+            s += '(%s)' % (self.items[2])
+        return s
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class Type_Name(Name): # C424
     """
@@ -1120,6 +1377,29 @@
     """
     subclass_names = ['Access_Spec']
     use_names = ['Parent_Type_Name']
+    def match(string):
+        if len(string)==8 and string.upper()=='ABSTRACT': return 'ABSTRACT',None
+        if string[:4].upper()=='BIND':
+            line = string[4:].lstrip()
+            if not line: return
+            if line[0]+line[-1]!='()': return
+            if line[1:-1].strip().upper()=='C': return 'BIND','C'
+            return
+        if string[:7].upper()=='EXTENDS':
+            line = string[7:].lstrip()
+            if not line: return
+            if line[0]+line[-1]!='()': return
+            line = line[1:-1].strip()
+            if not line: return
+            return 'EXTENDS', Parent_Type_Name(line)
+    match = staticmethod(match)
+    def init(self,*args):
+        self.items = args
+    def tostr(self):
+        if self.items[1] is None: return str(self.items[0])
+        return '%s(%s)' % tuple(self.items)
+    def torepr(self):
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class Private_Or_Sequence(Base): # R432
     """
@@ -1128,53 +1408,110 @@
     """
     subclass_names = ['Private_Components_Stmt', 'Sequence_Stmt']
 
-class End_Type_Stmt(Base): # R433
+class End_Type_Stmt(EndStmtBase): # R433
     """
     <end-type-stmt> = END TYPE [ <type-name> ]
     """
     subclass_names = []
     use_names = ['Type_Name']
-    
-class Sequence_Stmt(Base): # R434
+    def match(string): return EndStmtBase.match('TYPE',Type_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
+
+class Sequence_Stmt(STRINGBase): # R434
     """
     <sequence-stmt> = SEQUENCE
     """
     subclass_names = []
-    def match(string):
-        if len(string) != 8: return
-        start = string.upper()
-        if start=='SEQUENCE': return start,
-        return
+    def match(string): return STRINGBase.match('SEQUENCE', string)
     match = staticmethod(match)
 
-class Type_Param_Def_Stmt(Base): # R435
+class Type_Param_Def_Stmt(StmtBase): # R435
     """
     <type-param-def-stmt> = INTEGER [ <kind-selector> ] , <type-param-attr-spec> :: <type-param-decl-list>
     """
     subclass_names = []
     use_names = ['Kind_Selector', 'Type_Param_Attr_Spec', 'Type_Param_Decl_List']
+    def match(string):
+        if string[:7].upper()!='INTEGER': return
+        line, repmap = string_replace_map(string[7:].lstrip())
+        if not line: return
+        i = line.find(',')
+        if i==-1: return
+        kind_selector = repmap(line[:i].rstrip()) or None
+        line = repmap(line[i+1:].lstrip())
+        i = line.find('::')
+        if i==-1: return
+        l1 = line[:i].rstrip()
+        l2 = line[i+2:].lstrip()
+        if not l1 or not l2: return
+        if kind_selector: kind_selector = Kind_Selector(kind_selector)
+        return kind_selector, Type_Param_Attr_Spec(l1), Type_Param_Decl_List(l2)
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+    def tostr(self):
+        s = 'INTEGER'
+        if self.items[0] is not None:
+            s += '%s, %s :: %s' % (self.items[0], self.items[1], self.items[2])
+        else:
+            s += ', %s :: %s' % (self.items[1], self.items[2])
+        return s
+    def torepr(self):
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))        
 
-class Type_Param_Decl(Base): # R436
+
+class Type_Param_Decl(BinaryOpBase): # R436
     """
     <type-param-decl> = <type-param-name> [ = <scalar-int-initialization-expr> ]
     """
-    subclass_names = []
-    use_names = ['Type_Param_Name', 'Scalar_Int_Initialization_Expr']
-
-class Type_Param_Attr_Spec(Base): # R437
+    subclass_names = ['Type_Param_Name']
+    use_names = ['Scalar_Int_Initialization_Expr']
+    def match(string):
+        if '=' not in string: return
+        lhs,rhs = string.split('=',1)
+        lhs = lhs.rstrip()
+        rhs = rhs.lstrip()
+        if not lhs or not rhs: return
+        return Type_Param_Name(lhs),'=',Scalar_Int_Initialization_Expr(rhs)
+    match = staticmethod(match)
+    
+class Type_Param_Attr_Spec(STRINGBase): # R437
     """
     <type-param-attr-spec> = KIND
                              | LEN
     """
     subclass_names = []
+    def match(string): return STRINGBase.match(['KIND', 'LEN'], string)
+    match = staticmethod(match)
 
-class Component_Part(Base): # R438
+
+class Component_Part(BlockBase): # R438
     """
     <component-part> = [ <component-def-stmt> ]...
     """
     subclass_names = []
     use_names = ['Component_Def_Stmt']
+    def match(reader):
+        content = []
+        while 1:
+            try:
+                obj = Component_Def_Stmt(reader)
+            except NoMatchError:
+                obj = None
+            if obj is None:
+                break
+            content.append(obj)
+        if content:
+            return content,
+        return
+    match = staticmethod(match)
 
+    def tofortran(self, tab='', isfix=None):
+        l = []
+        for item in self.content:
+            l.append(item.tofortran(tab=tab,isfix=isfix))
+        return '\n'.join(l)
+
 class Component_Def_Stmt(Base): # R439
     """
     <component-def-stmt> = <data-component-def-stmt>
@@ -1182,22 +1519,33 @@
     """
     subclass_names = ['Data_Component_Def_Stmt', 'Proc_Component_Def_Stmt']
 
-class Data_Component_Def_Stmt(Base): # R440
+class Data_Component_Def_Stmt(StmtBase): # R440
     """
     <data-component-def-stmt> = <declaration-type-spec> [ [ , <component-attr-spec-list> ] :: ] <component-decl-list>
     """
     subclass_names = []
     use_names = ['Declaration_Type_Spec', 'Component_Attr_Spec_List', 'Component_Decl_List']
 
-class Component_Attr_Spec(Base): # R441
+class Dimension_Component_Attr_Spec(CALLBase):
     """
+    <dimension-component-attr-spec> = DIMENSION ( <component-array-spec> )
+    """
+    subclass_names = []
+    use_names = ['Component_Array_Spec']
+    def match(string): return CALLBase.match('DIMENSION', Component_Array_Spec, string)
+    match = staticmethod(match)
+
+class Component_Attr_Spec(STRINGBase): # R441
+    """
     <component-attr-spec> = POINTER
                             | DIMENSION ( <component-array-spec> )
                             | ALLOCATABLE
                             | <access-spec>
     """
-    subclass_names = ['Access_Spec']
-    use_names = ['Component_Array_Spec']
+    subclass_names = ['Access_Spec', 'Dimension_Component_Attr_Spec']
+    use_names = []
+    def match(string): return STRINGBase.match(['POINTER', 'ALLOCATABLE'], string)
+    match = staticmethod(match)
 
 class Component_Decl(Base): # R442
     """
@@ -1205,6 +1553,51 @@
     """
     subclass_names = []
     use_names = ['Component_Name', 'Component_Array_Spec', 'Char_Length', 'Component_Initialization']
+    def match(string):
+        m = pattern.name.match(string)
+        if m is None: return
+        name = Component_Name(m.group())
+        newline = string[m.end():].lstrip()
+        if not newline: return name, None, None, None
+        array_spec = None
+        char_length = None
+        init = None
+        if newline.startswith('('):
+            line, repmap = string_replace_map(newline)
+            i = line.find(')')
+            if i==-1: return
+            array_spec = Component_Array_Spec(repmap(line[1:i].strip()))
+            newline = repmap(line[i+1:].lstrip())
+        if newline.startswith('*'):
+            line, repmap = string_replace_map(newline)
+            i = line.find('=')
+            if i!=-1:
+                char_length = repmap(line[1:i].strip())
+                newline = repmap(newline[i:].lstrip())
+            else:
+                char_length = repmap(newline[1:].strip())
+                newline = ''
+            char_length = Char_Length(char_length)
+        if newline.startswith('='):
+            init = Component_Initialization(newline)
+        else:
+            assert newline=='',`newline`
+        return name, array_spec, char_length, init
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        s = str(self.items[0])
+        if self.items[1] is not None:
+            s += '(' + str(self.items[1]) + ')'
+        if self.items[2] is not None:
+            s += '*' + str(self.items[2])
+        if self.items[3] is not None:
+            s += ' ' + str(self.items[3])
+        return s
+    def torepr(self):
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class Component_Array_Spec(Base): # R443
     """
@@ -1220,8 +1613,21 @@
     """
     subclass_names = []
     use_names = ['Initialization_Expr', 'Null_Init']
+    def match(string):
+        if string.startswith('=>'):
+            return '=>', Null_Init(string[2:].lstrip())
+        if string.startswith('='):
+            return '=', Initialization_Expr(string[2:].lstrip())
+        return
+    match = staticmethod(match)
+    def init(self, op, rhs):
+        self.op = op
+        self.rhs = rhs
+        return
+    def tostr(self): return '%s %s' % (self.op, self.rhs)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.op, self.rhs)
 
-class Proc_Component_Def_Stmt(Base): # R445
+class Proc_Component_Def_Stmt(StmtBase): # R445
     """
     <proc-component-def-stmt> = PROCEDURE ( [ <proc-interface> ] ) , <proc-component-attr-spec-list> :: <proc-decl-list>
     """
@@ -1238,7 +1644,7 @@
     subclass_names = []
     use_names = ['Arg_Name', 'Access_Spec']
 
-class Private_Components_Stmt(Base): # R447
+class Private_Components_Stmt(StmtBase): # R447
     """
     <private-components-stmt> = PRIVATE
     """
@@ -1254,7 +1660,7 @@
     subclass_names = []
     use_names = ['Contains_Stmt', 'Binding_Private_Stmt', 'Proc_Binding_Stmt']
 
-class Binding_Private_Stmt(Base): # R449
+class Binding_Private_Stmt(StmtBase): # R449
     """
     <binding-private-stmt> = PRIVATE
     """
@@ -1314,16 +1720,16 @@
     """
     subclass_names = ['Type_Param_Value']
     use_names = ['Keyword']
-    def match(string): return KeywordValueBase.match(Type_Param_Value, string)
+    def match(string): return KeywordValueBase.match(Keyword, Type_Param_Value, string)
     match = staticmethod(match)
 
-class Structure_Constructor_2(KeywordValueBase):
+class Structure_Constructor_2(KeywordValueBase): # R457.b
     """
     <structure-constructor-2> = [ <keyword> = ] <component-data-source>
     """
     subclass_names = ['Component_Data_Source']
     use_names = ['Keyword']
-    def match(string): return KeywordValueBase.match(Component_Data_Source, string)
+    def match(string): return KeywordValueBase.match(Keyword, Component_Data_Source, string)
     match = staticmethod(match)
 
 class Structure_Constructor(CallBase): # R457
@@ -1342,7 +1748,7 @@
     """
     subclass_names = ['Component_Data_Source']
     use_names = ['Keyword']
-    def match(string): return KeywordValueBase.match(Component_Data_Source, string)
+    def match(string): return KeywordValueBase.match(Keyword, Component_Data_Source, string)
     match = staticmethod(match)
 
 class Component_Data_Source(Base): # R459
@@ -1363,13 +1769,13 @@
     subclass_names = []
     use_names = ['Enum_Def_Stmt', 'Enumerator_Def_Stmt', 'End_Enum_Stmt']
 
-class Enum_Def_Stmt(Base): # R461
+class Enum_Def_Stmt(StmtBase): # R461
     """
     <enum-def-stmt> = ENUM, BIND(C)
     """
     subclass_names = []
 
-class Enumerator_Def_Stmt(Base): # R462
+class Enumerator_Def_Stmt(StmtBase): # R462
     """
     <enumerator-def-stmt> = ENUMERATOR [ :: ] <enumerator-list>
     """
@@ -1388,13 +1794,15 @@
         return Named_Constant(lhs.rstrip()),'=',Scalar_Int_Initialization_Expr(rhs.lstrip())
     match = staticmethod(match)
 
-class End_Enum_Stmt(Base): # R464
+class End_Enum_Stmt(EndStmtBase): # R464
     """
     <end-enum-stmt> = END ENUM
     """
     subclass_names = []
+    def match(string): return EndStmtBase.match('ENUM',None, string, requite_stmt_type=True)
+    match = staticmethod(match)
 
-class Array_Constructor(BracketBase): # R469
+class Array_Constructor(BracketBase): # R465
     """
     <array-constructor> = (/ <ac-spec> /)
                           | <left-square-bracket> <ac-spec> <right-square-bracket>
@@ -1512,14 +1920,21 @@
 
     def match(string):
         line, repmap = string_replace_map(string)
-        i = line.find(',')
-        if i==-1:
-            i = line.find('::')
-        if i==-1:
-            m = re.search(r'\s[a-z_]',line,re.I)
-            if m is None: return
-            i = m.start()
-        type_spec = Declaration_Type_Spec(repmap(line[:i]))
+        i = line.find('::')
+        if i!=-1:
+            j = line[:i].find(',')
+            if j!=-1:
+                i = j
+        else:
+            if line[:6].upper()=='DOUBLE':
+                m = re.search(r'\s[a-z_]',line[6:].lstrip(),re.I)
+                if m is None: return
+                i = m.start() + len(line)-len(line[6:].lstrip())
+            else:
+                m = re.search(r'\s[a-z_]',line,re.I)
+                if m is None: return
+                i = m.start()
+        type_spec = Declaration_Type_Spec(repmap(line[:i].rstrip()))
         if type_spec is None: return
         line = line[i:].lstrip()
         if line.startswith(','):
@@ -1577,31 +1992,23 @@
     def tostr(self): return '%s(%s)' % tuple(map(str,self.items))
     def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
 
-class Dimension_Attr_Spec(CallBase):
+class Dimension_Attr_Spec(CALLBase): # R503.d
     """
     <dimension-attr-spec> = DIMENSION ( <array-spec> )
     """
     subclass_names = []
     use_names = ['Array_Spec']
-    def match(string): return CallBase.match(pattern.abs_dimension, Array_Spec, string)
+    def match(string): return CALLBase.match('DIMENSION', Array_Spec, string)
     match = staticmethod(match)
-    def init(self, lhs, rhs):
-        self.lhs = lhs.upper()
-        self.rhs = rhs
-        return
 
-class Intent_Attr_Spec(CallBase):
+class Intent_Attr_Spec(CALLBase): # R503.f
     """
     <intent-attr-spec> = INTENT ( <intent-spec> )
     """
     subclass_names = []
     use_names = ['Intent_Spec']
-    def match(string): return CallBase.match(pattern.abs_intent, Intent_Spec, string)
+    def match(string): return CALLBase.match('INTENT', Intent_Spec, string)
     match = staticmethod(match)
-    def init(self, lhs, rhs):
-        self.lhs = lhs.upper()
-        self.rhs = rhs
-        return
 
 class Attr_Spec(STRINGBase): # R503
     """
@@ -1709,13 +2116,15 @@
     def tostr(self): return '%s %s' % (self.op, self.rhs)
     def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.op, self.rhs)
 
-class Null_Init(Base): # R507
+class Null_Init(STRINGBase): # R507
     """
     <null-init> = <function-reference>
 
     <function-reference> shall be a reference to the NULL intrinsic function with no arguments.
     """
     subclass_names = ['Function_Reference']
+    def match(string): return STRINGBase.match('NULL', string)
+    match = staticmethod(match)
 
 class Access_Spec(STRINGBase): # R508
     """
@@ -1723,7 +2132,7 @@
                     | PRIVATE
     """
     subclass_names = []
-    def match(string): return STRINGBase.match(pattern.abs_access_spec, string)
+    def match(string): return STRINGBase.match(['PUBLIC','PRIVATE'], string)
     match = staticmethod(match)
 
 class Language_Binding_Spec(Base): # R509
@@ -1766,21 +2175,29 @@
                    | <deferred-shape-spec-list>
                    | <assumed-size-spec>
     """
-    subclass_names = ['Explicit_Shape_Spec_List', 'Assumed_Shape_Spec_List',
-                      'Deferred_Shape_Spec_List', 'Assumed_Size_Spec']
+    subclass_names = ['Assumed_Size_Spec', 'Explicit_Shape_Spec_List', 'Assumed_Shape_Spec_List',
+                      'Deferred_Shape_Spec_List']
 
 class Explicit_Shape_Spec(SeparatorBase): # R511
     """
     <explicit-shape-spec> = [ <lower-bound> : ] <upper-bound>
     """
-    subclass_names = ['Upper_Bound']
-    use_names = ['Lower_Bound']
+    subclass_names = []
+    use_names = ['Lower_Bound', 'Upper_Bound']
     def match(string):
         line, repmap = string_replace_map(string)
-        if ':' not in line: return
+        if ':' not in line:
+            return None, Upper_Bound(string)
         lower,upper = line.split(':',1)
+        lower = lower.rstrip()
+        upper = upper.lstrip()
+        if not upper: return
+        if not lower: return
         return Lower_Bound(repmap(lower)), Upper_Bound(repmap(upper))
     match = staticmethod(match)
+    def tostr(self):
+        if self.items[0] is None: return str(self.items[1])
+        return SeparatorBase.tostr(self)
     
 class Lower_Bound(Base): # R512
     """
@@ -1794,18 +2211,24 @@
     """
     subclass_names = ['Specification_Expr']
 
-class Assumed_Shape_Spec(Base): # R514
+class Assumed_Shape_Spec(SeparatorBase): # R514
     """
     <assumed-shape-spec> = [ <lower-bound> ] :
     """
     subclass_names = []
     use_names = ['Lower_Bound']
+    def match(string): return SeparatorBase.match(Lower_Bound, None, string)
+    match = staticmethod(match)
 
-class Deferred_Shape_Spec(Base): # R515
+class Deferred_Shape_Spec(SeparatorBase): # R515
     """
     <deferred_shape_spec> = :
     """
     subclass_names = []
+    def match(string):
+        if string==':': return None,None
+        return
+    match = staticmethod(match)
 
 class Assumed_Size_Spec(Base): # R516
     """
@@ -1813,7 +2236,33 @@
     """
     subclass_names = []
     use_names = ['Explicit_Shape_Spec_List', 'Lower_Bound']
-
+    def match(string):
+        if not string.endswith('*'): return
+        line = string[:-1].rstrip()
+        if not line: return None,None
+        if line.endswith(':'):
+            line, repmap = string_replace_map(line[:-1].rstrip())
+            i = line.rfind(',')
+            if i==-1:
+                return None, Lower_Bound(repmap(line))
+            return Explicit_Shape_Spec_List(repmap(line[:i].rstrip())), Lower_Bound(repmap(line[i+1:].lstrip()))
+        if not line.endswith(','): return
+        line = line[:-1].rstrip()
+        return Explicit_Shape_Spec_List(line), None
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        s = ''
+        if self.items[0] is not None:
+            s += str(self.items[0]) + ', '
+        if self.items[1] is not None:
+            s += str(self.items[1]) + ' : '
+        s += '*'
+        return s
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
+    
 class Intent_Spec(STRINGBase): # R517
     """
     <intent-spec> = IN
@@ -1824,7 +2273,7 @@
     def match(string): return STRINGBase.match(pattern.abs_intent_spec, string)
     match = staticmethod(match)
 
-class Access_Stmt(Base): # R518
+class Access_Stmt(StmtBase): # R518
     """
     <access-stmt> = <access-spec> [ [ :: ] <access-id-list> ]
     """
@@ -1838,21 +2287,21 @@
     """
     subclass_names = ['Use_Name', 'Generic_Spec']
 
-class Allocatable_Stmt(Base): # R520
+class Allocatable_Stmt(StmtBase): # R520
     """
     <allocateble-stmt> = ALLOCATABLE [ :: ] <object-name> [ ( <deferred-shape-spec-list> ) ] [ , <object-name> [ ( <deferred-shape-spec-list> ) ] ]...
     """
     subclass_names = []
     use_names = ['Object_Name', 'Deferred_Shape_Spec_List']
 
-class Asynchronous_Stmt(Base): # R521
+class Asynchronous_Stmt(StmtBase): # R521
     """
     <asynchronous-stmt> = ASYNCHRONOUS [ :: ] <object-name-list>
     """
     subclass_names = []
     use_names = ['Object_Name_List']
 
-class Bind_Stmt(Base): # R522
+class Bind_Stmt(StmtBase): # R522
     """
     <bind-stmt> = <language-binding-spec> [ :: ] <bind-entity-list>
     """
@@ -1867,7 +2316,7 @@
     subclass_names = ['Entity_Name']
     use_names = ['Common_Block_Name']
 
-class Data_Stmt(Base): # R524
+class Data_Stmt(StmtBase): # R524
     """
     <data-stmt> = DATA <data-stmt-set> [ [ , ] <data-stmt-set> ]...
     """
@@ -1948,64 +2397,91 @@
     """
     subclass_names = ['Designator']
 
-class Dimension_Stmt(Base): # R535
+class Dimension_Stmt(StmtBase): # R535
     """
     <dimension-stmt> = DIMENSION [ :: ] <array-name> ( <array-spec> ) [ , <array-name> ( <array-spec> ) ]...
     """
     subclass_names = []
     use_names = ['Array_Name', 'Array_Spec']
+    def match(string):
+        if string[:9].upper()!='DIMENSION': return
+        line, repmap = string_replace_map(string[9:].lstrip())
+        if line.startswith('::'): line = line[2:].lstrip()
+        decls = []
+        for s in line.split(','):
+            s = s.strip()
+            if not s.endswith(')'): return
+            i = s.find('(')
+            if i==-1: return
+            decls.append((Array_Name(repmap(s[:i].rstrip())), Array_Spec(repmap(s[i+1:-1].strip()))))
+        if not decls: return
+        return decls,
+    match = staticmethod(match)
+    def init(self, items):
+        self.items = items
+        return
+    def tostr(self):
+        return 'DIMENSION :: ' + ', '.join(['%s(%s)' % ns for ns in self.items])
+    def torepr(self):
+        return '%s(%r)' % (self.__class__.__name__, self.items)
 
-class Intent_Stmt(Base): # R536
+class Intent_Stmt(StmtBase): # R536
     """
     <intent-stmt> = INTENT ( <intent-spec> ) [ :: ] <dummy-arg-name-list>
     """
     subclass_names = []
     use_names = ['Intent_Spec', 'Dummy_Arg_Name_List']
 
-class Optional_Stmt(Base): # R537
+class Optional_Stmt(StmtBase): # R537
     """
     <optional-stmt> = OPTIONAL [ :: ] <dummy-arg-name-list>
     """
     subclass_names = []
     use_names = ['Dummy_Arg_Name_List']
 
-class Parameter_Stmt(Base): # R538
+class Parameter_Stmt(StmtBase, CALLBase): # R538
     """
     <parameter-stmt> = PARAMETER ( <named-constant-def-list> )
     """
     subclass_names = []
     use_names = ['Named_Constant_Def_List']
+    def match(string): return CALLBase.match('PARAMETER', Named_Constant_Def_List, string, require_rhs=True)
+    match = staticmethod(match)
 
-class Named_Constant_Def(Base): # R539
+class Named_Constant_Def(KeywordValueBase): # R539
     """
     <named-constant-def> = <named-constant> = <initialization-expr>
     """
     subclass_names = []
     use_names = ['Named_Constant', 'Initialization_Expr']
-
-class Pointer_Stmt(Base): # R540
+    def match(string): return KeywordValueBase.match(Named_Constant, Initialization_Expr, string)
+    match = staticmethod(match)
+    
+class Pointer_Stmt(StmtBase): # R540
     """
     <pointer-stmt> = POINTER [ :: ] <pointer-decl-list>
     """
     subclass_names = []
     use_names = ['Pointer_Decl_List']
 
-class Pointer_Decl(Base): # R541
+class Pointer_Decl(CallBase): # R541
     """
     <pointer-decl> = <object-name> [ ( <deferred-shape-spec-list> ) ]
                      | <proc-entity-name>
     """
-    use_names = ['Object_Name', 'Deferred_Shape_Spec_List']
-    subclass_names = ['Proc_Entity_Name']
+    subclass_names = ['Proc_Entity_Name', 'Object_Name']
+    use_names = ['Deferred_Shape_Spec_List']
+    def match(string): return CallBase.match(Object_Name, Deferred_Shape_Spec_List, string, require_rhs=True)
+    match = staticmethod(match)
 
-class Protected_Stmt(Base): # R542
+class Protected_Stmt(StmtBase): # R542
     """
     <protected-stmt> = PROTECTED [ :: ] <entity-name-list>
     """
     subclass_names = []
     use_names = ['Entity_Name_List']
 
-class Save_Stmt(Base): # R543
+class Save_Stmt(StmtBase): # R543
     """
     <save-stmt> = SAVE [ [ :: ] <saved-entity-list> ]
     """
@@ -2027,49 +2503,88 @@
     """
     subclass_names = ['Name']
 
-class Target_Stmt(Base): # R546
+class Target_Stmt(StmtBase): # R546
     """
     <target-stmt> = TARGET [ :: ] <object-name> [ ( <array-spec> ) ] [ , <object-name> [ ( <array-spec> ) ]]
     """
     subclass_names = []
     use_names = ['Object_Name', 'Array_Spec']
 
-class Value_Stmt(Base): # R547
+class Value_Stmt(StmtBase): # R547
     """
     <value-stmt> = VALUE [ :: ] <dummy-arg-name-list>
     """
     subclass_names = []
     use_names = ['Dummy_Arg_Name_List']
 
-class Volatile_Stmt(Base): # R548
+class Volatile_Stmt(StmtBase): # R548
     """
     <volatile-stmt> = VOLATILE [ :: ] <object-name-list>
     """
     subclass_names = []
     use_names = ['Object_Name_List']
 
-class Implicit_Stmt(Base): # R549
+class Implicit_Stmt(StmtBase, WORDClsBase): # R549
     """
     <implicit-stmt> = IMPLICIT <implicit-spec-list>
                       | IMPLICIT NONE
     """
     subclass_names = []
     use_names = ['Implicit_Spec_List']
+    def match(string):
+        for w,cls in [(pattern.abs_implicit_none, None),
+                      ('IMPLICIT', Implicit_Spec_List)]:
+            try:
+                obj = WORDClsBase.match(w, cls, string)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
+        return
+    match = staticmethod(match)
 
-class Implicit_Spec(Base): # R550
+class Implicit_Spec(CallBase): # R550
     """
     <implicit-spec> = <declaration-type-spec> ( <letter-spec-list> )
     """
     subclass_names = []
     use_names = ['Declaration_Type_Spec', 'Letter_Spec_List']
+    def match(string):
+        if not string.endswith(')'): return
+        i = string.rfind('(')
+        if i==-1: return
+        s1 = string[:i].rstrip()
+        s2 = string[i+1:-1].strip()
+        if not s1 or not s2: return
+        return Declaration_Type_Spec(s1), Letter_Spec_List(s2)
+    match = staticmethod(match)
 
 class Letter_Spec(Base): # R551
     """
     <letter-spec> = <letter> [ - <letter> ]
     """
     subclass_names = []
+    def match(string):
+        if len(string)==1:
+            lhs = string.upper()
+            if 'A'<=lhs<='Z': return lhs, None
+            return
+        if '-' not in string: return
+        lhs,rhs = string.split('-',1)
+        lhs = lhs.strip().upper()
+        rhs = rhs.strip().upper()
+        if not len(lhs)==len(rhs)==1: return
+        if not ('A'<=lhs<=rhs<='Z'): return
+        return lhs,rhs
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        if self.items[1] is None: return str(self.items[0])
+        return '%s - %s' % tuple(self.items)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
-class Namelist_Stmt(Base): # R552
+class Namelist_Stmt(StmtBase): # R552
     """
     <namelist-stmt> = NAMELIST / <namelist-group-name> / <namelist-group-object-list> [ [ , ] / <namelist-group-name> / <namelist-group-object-list> ]
     """
@@ -2082,12 +2597,14 @@
     """
     subclass_names = ['Variable_Name']
 
-class Equivalence_Stmt(Base): # R554
+class Equivalence_Stmt(StmtBase, WORDClsBase): # R554
     """
     <equivalence-stmt> = EQUIVALENCE <equivalence-set-list>
     """
     subclass_names = []
     use_names = ['Equivalence_Set_List']
+    def match(string): return WORDClsBase.match('EQUIVALENCE', Equivalence_Set_List, string)
+    match = staticmethod(match)
 
 class Equivalence_Set(Base): # R555
     """
@@ -2095,6 +2612,21 @@
     """
     subclass_names = []
     use_names = ['Equivalence_Object', 'Equivalence_Object_List']
+    def match(string):
+        if not string or string[0]+string[-1]!='()': return
+        line = string[1:-1].strip()
+        if not line: return
+        l = Equivalence_Object_List(line)
+        obj = l.items[0]
+        l.items = l.items[1:]
+        if not l.items: return
+        return obj, l
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self): return '(%s, %s)' % tuple(self.items)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class Equivalence_Object(Base): # R556
     """
@@ -2104,20 +2636,89 @@
     """
     subclass_names = ['Variable_Name', 'Array_Element', 'Substring']
 
-class Common_Stmt(Base): # R557
+class Common_Stmt(StmtBase): # R557
     """
     <common-stmt> = COMMON [ / [ <common-block-name> ] / ] <common-block-object-list> [ [ , ] / [ <common-block-name> ] / <common-block-object-list> ]...
     """
     subclass_names = []
     use_names = ['Common_Block_Name', 'Common_Block_Object_List']
+    def match(string):
+        if string[:6].upper()!='COMMON': return
+        line = string[6:]
+        if not line or 'A'<=line[0].upper()<='Z' or line[0]=='_': return
+        line, repmap = string_replace_map(line.lstrip())
+        items = []
+        if line.startswith('/'):
+            i = line.find('/',1)
+            if i==-1: return
+            name = line[1:i].strip() or None
+            if name is not None: name = Common_Block_Name(name)
+            line = line[i+1:].lstrip()
+            i = line.find('/')
+            if i==-1:
+                lst = Common_Block_Object_List(repmap(line))
+                line = ''
+            else:
+                l = line[:i].rstrip()
+                if l.endswith(','): l = l[:-1].rstrip()
+                if not l: return
+                lst = Common_Block_Object_List(repmap(l))
+                line = line[i:].lstrip()
+        else:
+            name = None
+            i = line.find('/')
+            if i==-1:
+                lst = Common_Block_Object_List(repmap(line))
+                line = ''
+            else:
+                l = line[:i].rstrip()
+                if l.endswith(','): l = l[:-1].rstrip()
+                if not l: return
+                lst = Common_Block_Object_List(repmap(l))
+                line = line[i:].lstrip()
+        items.append((name, lst))
+        while line:
+            if line.startswith(','): line = line[1:].lstrip()
+            if not line.startswith('/'): return
+            i = line.find('/',1)
+            name = line[1:i].strip() or None
+            if name is not None: name = Common_Block_Name(name)
+            line = line[i+1:].lstrip()
+            i = line.find('/')
+            if i==-1:
+                lst = Common_Block_Object_List(repmap(line))
+                line = ''
+            else:
+                l = line[:i].rstrip()
+                if l.endswith(','): l = l[:-1].rstrip()
+                if not l: return
+                lst = Common_Block_Object_List(repmap(l))
+                line = line[i:].lstrip()
+            items.append((name, lst))
+        return items,
+    match = staticmethod(match)
+    def init(self, items):
+        self.items = items
+        return
+    def tostr(self):
+        s = 'COMMON'
+        for (name, lst) in self.items:
+            if name is not None:
+                s += ' /%s/ %s' % (name, lst)
+            else:
+                s += ' // %s' % (lst)
+        return s
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.items)
 
-class Common_Block_Object(Base): # R558
+class Common_Block_Object(CallBase): # R558
     """
     <common-block-object> = <variable-name> [ ( <explicit-shape-spec-list> ) ]
                             | <proc-pointer-name>
     """
-    subclass_names = ['Proc_Pointer_Name']
+    subclass_names = ['Proc_Pointer_Name','Variable_Name']
     use_names = ['Variable_Name', 'Explicit_Shape_Spec_List']
+    def match(string): return CallBase.match(Variable_Name, Explicit_Shape_Spec_List, string, require_rhs=True)
+    match = staticmethod(match)
 
 ###############################################################################
 ############################### SECTION  6 ####################################
@@ -2183,11 +2784,11 @@
 
 class Substring(CallBase): # R609
     """
-    <substring> = <parent-string> ( <substring-range> )    
+    <substring> = <parent-string> ( <substring-range> )
     """
     subclass_names = []
     use_names = ['Parent_String','Substring_Range']
-    def match(string): return CallBase.match(Parent_String, Substring_Range, string)
+    def match(string): return CallBase.match(Parent_String, Substring_Range, string, require_rhs=True)
     match = staticmethod(match)
 
 class Parent_String(Base): # R610
@@ -2199,36 +2800,15 @@
     """
     subclass_names = ['Scalar_Variable_Name', 'Array_Element', 'Scalar_Structure_Component', 'Scalar_Constant']
 
-class Substring_Range(Base): # R611
+class Substring_Range(SeparatorBase): # R611
     """
     <substring-range> = [ <scalar-int-expr> ] : [ <scalar-int-expr> ]
     """
     subclass_names = []
     use_names = ['Scalar_Int_Expr']
     def match(string):
-        line, repmap = string_replace_map(string)
-        if ':' not in line: return
-        lhs,rhs = line.split(':',1)
-        lhs = lhs.rstrip()
-        rhs = rhs.lstrip()
-        lhs_obj, rhs_obj = None, None
-        if lhs:
-            lhs_obj = Scalar_Int_Expr(repmap(lhs))
-        if rhs:
-            rhs_obj = Scalar_Int_Expr(repmap(rhs))
-        return lhs_obj, rhs_obj
+        return SeparatorBase.match(Scalar_Int_Expr, Scalar_Int_Expr, string)
     match = staticmethod(match)
-    def init(self, lhs, rhs):
-        self.lhs, self.rhs = lhs, rhs
-        return
-    def tostr(self):
-        if self.lhs is None:
-            if self.rhs is None: return ':'
-            return ': '+ str(self.rhs)
-        else:
-            if self.rhs is None: return str(self.lhs)+' :'
-            return str(self.lhs)+' : '+ str(self.rhs)
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.lhs, self.rhs)
 
 class Data_Ref(SequenceBase): # R612
     """
@@ -2236,7 +2816,7 @@
     """
     subclass_names = ['Part_Ref']
     use_names = []
-    def match(string): return SequenceBase.match('%', Part_Ref, string)
+    def match(string): return SequenceBase.match(r'%', Part_Ref, string)
     match = staticmethod(match)
 
 class Part_Ref(CallBase): # R613
@@ -2245,7 +2825,8 @@
     """
     subclass_names = ['Part_Name']
     use_names = ['Section_Subscript_List']
-    def match(string): return CallBase.match(Part_Name, Section_Subscript_List, string)
+    def match(string):
+        return CallBase.match(Part_Name, Section_Subscript_List, string, require_rhs=True)
     match = staticmethod(match)
 
 class Structure_Component(Base): # R614
@@ -2277,7 +2858,7 @@
     """
     subclass_names = ['Data_Ref']
     use_names = ['Substring_Range']
-    def match(string): return CallBase.match(Data_Ref, Substring_Range, string)
+    def match(string): return CallBase.match(Data_Ref, Substring_Range, string, require_rhs=True)
     match = staticmethod(match)
 
 class Subscript(Base): # R618
@@ -2346,23 +2927,35 @@
     """
     subclass_names = ['Int_Expr']
 
-class Allocate_Stmt(Base): # R623
+class Allocate_Stmt(StmtBase): # R623
     """
     <allocate-stmt> = ALLOCATE ( [ <type-spec> :: ] <allocation-list> [ , <alloc-opt-list> ] )
     """
     subclass_names = []
     use_names = ['Type_Spec', 'Allocation_List', 'Alloc_Opt_List']
     
-class Alloc_Opt(Base):# R624
+class Alloc_Opt(KeywordValueBase):# R624
     """
     <alloc-opt> = STAT = <stat-variable>
                   | ERRMSG = <errmsg-variable>
                   | SOURCE = <source-expr>
     """
     subclass_names = []
-    use_names = ['Stat_Variable', 'Errmsg_Variable', 'Source_Expr',
-                 ]
+    use_names = ['Stat_Variable', 'Errmsg_Variable', 'Source_Expr']
+    def match(string):
+        for (k,v) in [('STAT', Stat_Variable),
+                      ('ERRMSG', Errmsg_Variable),
+                      ('SOURCE', Source_Expr)
+                      ]:
+            try:
+                obj = KeywordValueBase.match(k, v, string, upper_lhs = True)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
+        return
+    match = staticmethod(match)
 
+
 class Stat_Variable(Base):# R625
     """
     <stat-variable> = <scalar-int-variable>
@@ -2396,13 +2989,27 @@
     """
     subclass_names = ['Variable_Name', 'Structure_Component']
 
-class Allocate_Shape_Spec(Base): # R630
+class Allocate_Shape_Spec(SeparatorBase): # R630
     """
     <allocate-shape-spec> = [ <lower-bound-expr> : ] <upper-bound-expr>
     """
     subclass_names = []
     use_names = ['Lower_Bound_Expr', 'Upper_Bound_Expr']
+    def match(string):
+        line, repmap = string_replace_map(string)
+        if ':' not in line: return None, Upper_Bound_Expr(string)
+        lower,upper = line.split(':',1)
+        lower = lower.rstrip()
+        upper = upper.lstrip()
+        if not upper: return
+        if not lower: return
+        return Lower_Bound_Expr(repmap(lower)), Upper_Bound_Expr(repmap(upper))
+    match = staticmethod(match)
+    def tostr(self):
+        if self.items[0] is None: return str(self.items[1])
+        return SeparatorBase.tostr(self)
 
+
 class Lower_Bound_Expr(Base): # R631
     """
     <lower-bound-expr> = <scalar-int-expr>
@@ -2415,13 +3022,15 @@
     """
     subclass_names = ['Scalar_Int_Expr']
 
-class Nullify_Stmt(Base): # R633
+class Nullify_Stmt(StmtBase, CALLBase): # R633
     """
     <nullify-stmt> = NULLIFY ( <pointer-object-list> )
     """
     subclass_names = []
     use_names = ['Pointer_Object_List']
-
+    def match(string): return CALLBase.match('NULLIFY', Pointer_Object_List, string, require_rhs=True)
+    match = staticmethod(match)
+    
 class Pointer_Object(Base): # R634
     """
     <pointer-object> = <variable-name>
@@ -2430,22 +3039,32 @@
     """
     subclass_names = ['Variable_Name', 'Structure_Component', 'Proc_Pointer_Name']
 
-class Deallocate_Stmt(Base): # R635
+class Deallocate_Stmt(StmtBase): # R635
     """
     <deallocate-stmt> = DEALLOCATE ( <allocate-object-list> [ , <dealloc-opt-list> ] )
     """
     subclass_names = []
     use_names = ['Allocate_Object_List', 'Dealloc_Opt_List']
 
-class Dealloc_Opt(Base): # R636
+class Dealloc_Opt(KeywordValueBase): # R636
     """
     <dealloc-opt> = STAT = <stat-variable>
                     | ERRMSG = <errmsg-variable>
     """
     subclass_names = []
     use_names = ['Stat_Variable', 'Errmsg_Variable']
+    def match(string):
+        for (k,v) in [('STAT', Stat_Variable),
+                      ('ERRMSG', Errmsg_Variable),
+                      ]:
+            try:
+                obj = KeywordValueBase.match(k, v, string, upper_lhs = True)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
+        return
+    match = staticmethod(match)
 
-
 class Scalar_Char_Initialization_Expr(Base):
     subclass_names = ['Char_Initialization_Expr']
 
@@ -2469,7 +3088,7 @@
                       'Function_Reference', 'Type_Param_Inquiry', 'Type_Param_Name', 
                        ]
 
-class Parenthesis(BracketBase):
+class Parenthesis(BracketBase): # R701.h
     """
     <parenthesis> = ( <expr> )
     """
@@ -2487,7 +3106,7 @@
     use_names = []
     def match(string):
         if pattern.non_defined_binary_op.match(string):
-            raise NoMatchError,`string`
+            raise NoMatchError,'%s: %r' % (Level_1_Expr.__name__, string)
         return UnaryOpBase.match(\
             pattern.defined_unary_op.named(),Primary,string)
     match = staticmethod(match)
@@ -2515,8 +3134,7 @@
     subclass_names = ['Mult_Operand']
     use_names = ['Add_Operand','Mult_Operand']
     def match(string):
-        return BinaryOpBase.match(\
-            Add_Operand,pattern.mult_op.named(),Mult_Operand,string)
+        return BinaryOpBase.match(Add_Operand,pattern.mult_op.named(),Mult_Operand,string)
     match = staticmethod(match)
 
 class Level_2_Expr(BinaryOpBase): # R706
@@ -2534,7 +3152,7 @@
             Level_2_Expr,pattern.add_op.named(),Add_Operand,string)
     match = staticmethod(match)
 
-class Level_2_Unary_Expr(UnaryOpBase):
+class Level_2_Unary_Expr(UnaryOpBase): # R706.c
     """
     <level-2-unary-expr> = [ <add-op> ] <add-operand>
     """
@@ -2705,14 +3323,17 @@
     """
     subclass_names = ['Logical_Expr']
 
-class Assignment_Stmt(Base): # R734
+class Assignment_Stmt(StmtBase, BinaryOpBase): # R734
     """
     <assignment-stmt> = <variable> = <expr>
     """
     subclass_names = []
     use_names = ['Variable', 'Expr']
-
-class Pointer_Assignment_Stmt(Base): # R735
+    def match(string):
+        return BinaryOpBase.match(Variable, '=', Expr, string, right=False)
+    match = staticmethod(match)
+    
+class Pointer_Assignment_Stmt(StmtBase): # R735
     """
     <pointer-assignment-stmt> = <data-pointer-object> [ ( <bounds-spec-list> ) ] => <data-target>
                                 | <data-pointer-object> ( <bounds-remapping-list> ) => <data-target>
@@ -2730,19 +3351,23 @@
     subclass_names = ['Variable_Name']
     use_names = ['Variable', 'Data_Pointer_Component_Name']
 
-class Bounds_Spec(Base): # R737
+class Bounds_Spec(SeparatorBase): # R737
     """
     <bounds-spec> = <lower-bound-expr> :
     """
     subclass_names = []
     use_names = ['Lower_Bound_Expr']
+    def match(string): return SeparatorBase.match(Lower_Bound_Expr, None, string, require_lhs=True)
+    match = staticmethod(match)
 
-class Bounds_Remapping(Base): # R738
+class Bounds_Remapping(SeparatorBase): # R738
     """
     <bounds-remapping> = <lower-bound-expr> : <upper-bound-expr>
     """
     subclass_names = []
     use_classes = ['Lower_Bound_Expr', 'Upper_Bound_Expr']
+    def match(string): return SeparatorBase.match(Lower_Bound_Expr, Upper_Bound_Expr, string, require_lhs=True, require_rhs=True)
+    match = staticmethod(match)
 
 class Data_Target(Base): # R739
     """
@@ -2765,8 +3390,7 @@
     subclass_names = []
     use_names = ['Variable','Procedure_Component_Name']
     def match(string):
-        return BinaryOpBase.match(\
-            Variable, pattern.percent_op.named(), Procedure_Component_Name, string)            
+        return BinaryOpBase.match(Variable, r'%', Procedure_Component_Name, string)            
     match = staticmethod(match)
 
 class Proc_Target(Base): # R742
@@ -2778,7 +3402,7 @@
     subclass_names = ['Proc_Component_Ref', 'Procedure_Name', 'Expr']
 
 
-class Where_Stmt(Base): # R743
+class Where_Stmt(StmtBase): # R743
     """
     <where-stmt> = WHERE ( <mask-expr> ) <where-assignment-stmt>
     """
@@ -2801,7 +3425,7 @@
                  'Elsewhere_Stmt', 'End_Where_Stmt'
                  ]
 
-class Where_Construct_Stmt(Base): # R745
+class Where_Construct_Stmt(StmtBase): # R745
     """
     <where-construct-stmt> = [ <where-construct-name> : ] WHERE ( <mask-expr> )
     """
@@ -2828,27 +3452,30 @@
     """
     subclass_names = ['Logical_Expr']
 
-class Masked_Elsewhere_Stmt(Base): # R749
+class Masked_Elsewhere_Stmt(StmtBase): # R749
     """
     <masked-elsewhere-stmt> = ELSEWHERE ( <mask-expr> ) [ <where-construct-name> ]
     """
     subclass_names = []
     use_names = ['Mask_Expr', 'Where_Construct_Name']
 
-class Elsewhere_Stmt(Base): # R750
+class Elsewhere_Stmt(StmtBase): # R750
     """
     <elsewhere-stmt> = ELSEWHERE [ <where-construct-name> ]
     """
     subclass_names = []
     use_names = ['Where_Construct_Name']
 
-class End_Where_Stmt(Base): # R751
+class End_Where_Stmt(EndStmtBase): # R751
     """
     <end-where-stmt> = END WHERE [ <where-construct-name> ]
     """
     subclass_names = []
     use_names = ['Where_Construct_Name']
+    def match(string): return EndStmtBase.match('WHERE',Where_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
+
 class Forall_Construct(Base): # R752
     """
     <forall-construct> = <forall-construct-stmt>
@@ -2858,7 +3485,7 @@
     subclass_names = []
     use_names = ['Forall_Construct_Stmt', 'Forall_Body_Construct', 'End_Forall_Stmt']
 
-class Forall_Construct_Stmt(Base): # R753
+class Forall_Construct_Stmt(StmtBase): # R753
     """
     <forall-construct-stmt> = [ <forall-construct-name> : ] FORALL <forall-header>
     """
@@ -2897,14 +3524,16 @@
     """
     subclass_names = ['Assignment_Stmt', 'Pointer_Assignment_Stmt']
 
-class End_Forall_Stmt(Base): # R758
+class End_Forall_Stmt(EndStmtBase): # R758
     """
     <end-forall-stmt> = END FORALL [ <forall-construct-name> ]
     """
     subclass_names = []
     use_names = ['Forall_Construct_Name']
+    def match(string): return EndStmtBase.match('FORALL',Forall_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
-class Forall_Stmt(Base): # R759
+class Forall_Stmt(StmtBase): # R759
     """
     <forall-stmt> = FORALL <forall-header> <forall-assignment-stmt>
     """
@@ -2915,14 +3544,16 @@
 ############################### SECTION  8 ####################################
 ###############################################################################
 
-class Block(Base): # R801
+class Block(BlockBase): # R801
     """
     block = [ <execution-part-construct> ]...
     """
     subclass_names = []
     use_names = ['Execution_Part_Construct']
+    def match(string): return BlockBase.match(None, [Execution_Part_Construct], None, string)
+    match = staticmethod(match)
 
-class If_Construct(Base): # R802
+class If_Construct(BlockBase): # R802
     """
     <if-construct> = <if-then-stmt>
                            <block>
@@ -2937,41 +3568,165 @@
     subclass_names = []
     use_names = ['If_Then_Stmt', 'Block', 'Else_If_Stmt', 'Else_Stmt', 'End_If_Stmt']
 
-class If_Then_Stmt(Base): # R803
+    def match(reader):
+        content = []
+        try:
+            obj = If_Then_Stmt(reader)
+        except NoMatchError:
+            obj = None
+        if obj is None: return
+        content.append(obj)
+        obj = Block(reader)
+        if obj is None: return # todo: restore reader
+        content.append(obj)
+        while 1:
+            try:
+                obj = Else_If_Stmt(reader)
+            except NoMatchError:
+                obj = None
+            if obj is not None:
+                content.append(obj)
+                obj = Block(reader)
+                if obj is None: return # todo: restore reader
+                content.append(obj)
+                continue
+            try:
+                obj = Else_Stmt(reader)
+            except NoMatchError:
+                obj = None
+            if obj is not None:
+                content.append(obj)
+                obj = Block(reader)
+                if obj is None: return # todo: restore reader
+                content.append(obj)
+            break
+        try:
+            obj = End_If_Stmt(reader)
+        except NoMatchError:
+            obj = None
+        if obj is None: return # todo: restore reader
+        content.append(obj)
+        return content,
+    match = staticmethod(match)
+
+    def tofortran(self, tab='', isfix=None):
+        l = []
+        start = self.content[0]
+        end = self.content[-1]
+        l.append(start.tofortran(tab=tab,isfix=isfix))
+        for item in self.content[1:-1]:
+            if isinstance(item, (Else_If_Stmt, Else_Stmt)):
+                l.append(item.tofortran(tab=tab,isfix=isfix))
+            else:
+                l.append(item.tofortran(tab=tab+'  ',isfix=isfix))
+        l.append(end.tofortran(tab=tab,isfix=isfix))
+        return '\n'.join(l)
+
+
+class If_Then_Stmt(StmtBase): # R803
     """
     <if-then-stmt> = [ <if-construct-name> : ] IF ( <scalar-logical-expr> ) THEN
     """
     subclass_names = []
     use_names = ['If_Construct_Name', 'Scalar_Logical_Expr']
+    def match(string):
+        if string[:2].upper()!='IF': return
+        if string[-4:].upper()!='THEN': return
+        line = string[2:-4].strip()
+        if not line: return
+        if line[0]+line[-1]!='()': return
+        return Scalar_Logical_Expr(line[1:-1].strip()),
+    match = staticmethod(match)
+    def init(self, expr):
+        self.expr = expr
+        return
+    def tostr(self): return 'IF (%s) THEN' % (self.expr)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.expr)
 
-class Else_If_Stmt(Base): # R804
+class Else_If_Stmt(StmtBase): # R804
     """
     <else-if-stmt> = ELSE IF ( <scalar-logical-expr> ) THEN [ <if-construct-name> ]
     """
     subclass_names = []
     use_names = ['Scalar_Logical_Expr', 'If_Construct_Name']
 
-class Else_Stmt(Base): # R805
+    def match(string):
+        if string[:4].upper()!='ELSE': return
+        line = string[4:].lstrip()
+        if line[:2].upper()!='IF': return
+        line = line[2:].lstrip()
+        if not line.startswith('('): return
+        i = line.rfind(')')
+        if i==-1: return
+        expr = line[1:i].strip()
+        line = line[i+1:].lstrip()
+        if line[:4].upper()!='THEN': return
+        line = line[4:].lstrip()
+        if line: return Scalar_Logical_Expr(expr), If_Construct_Name(line)
+        return Scalar_Logical_Expr(expr), None
+    match = staticmethod(match)
+    def init(self, *args):
+        self.expr, self.iflabel = args
+        return
+    def tostr(self):
+        if self.iflabel is None:
+            return 'ELSE IF (%s) THEN' % (self.expr)
+        return 'ELSE IF (%s) THEN %s' % (self.expr, self.iflabel)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.expr, self.iflabel)
+
+class Else_Stmt(StmtBase): # R805
     """
     <else-stmt> = ELSE [ <if-construct-name> ]
     """
     subclass_names = []
     use_names = ['If_Construct_Name']
+    def match(string):
+        if string[:4].upper()!='ELSE': return
+        line = string[4:].lstrip()
+        if line: return If_Construct_Name(line),
+        return None,
+    match = staticmethod(match)
+    def init(self, iflabel):
+        self.iflabel = iflabel
+        return
+    def tostr(self):
+        if self.iflabel is None:
+            return 'ELSE'
+        return 'ELSE %s' % (self.expr, self.iflabel)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.iflabel)
 
-class End_If_Stmt(Base): # R806
+class End_If_Stmt(EndStmtBase): # R806
     """
     <end-if-stmt> = END IF [ <if-construct-name> ]
     """
     subclass_names = []
     use_names = ['If_Construct_Name']
+    def match(string): return EndStmtBase.match('IF',If_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
-class If_Stmt(Base): # R807
+class If_Stmt(StmtBase): # R807
     """
     <if-stmt> = IF ( <scalar-logical-expr> ) <action-stmt>
     """
     subclass_names = []
-    use_names = ['Scalar_Logical_Expr', 'Action_Stmt']
-
+    use_names = ['Scalar_Logical_Expr', 'Action_Stmt_C802']
+    def match(string):
+        if string[:2].upper() != 'IF': return
+        line, repmap = string_replace_map(string)
+        line = line[2:].lstrip()
+        if not line.startswith('('): return
+        i = line.find(')')
+        if i==-1: return
+        expr = repmap(line[1:i].strip())
+        stmt = repmap(line[i+1:].lstrip())
+        return Scalar_Logical_Expr(expr), Action_Stmt_C802(stmt)
+    match = staticmethod(match)
+    def init(self, *args):
+        self.expr, self.stmt = args
+        return
+    def tostr(self): return 'IF (%s) %s' % (self.expr, self.stmt)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.expr, self.stmt)
+    
 class Case_Construct(Base): # R808
     """
     <case-construct> = <select-case-stmt>
@@ -2983,26 +3738,28 @@
     subclass_names = []
     use_names = ['Select_Case_Stmt', 'Case_Stmt', 'End_Select_Stmt']
 
-class Select_Case_Stmt(Base): # R809
+class Select_Case_Stmt(StmtBase): # R809
     """
     <select-case-stmt> = [ <case-construct-name> : ] SELECT CASE ( <case-expr> )
     """
     subclass_names = []
     use_names = ['Case_Construct_Name', 'Case_Expr']
 
-class Case_Stmt(Base): # R810
+class Case_Stmt(StmtBase): # R810
     """
     <case-stmt> = CASE <case-selector> [ <case-construct-name> ]
     """
     subclass_names = []
     use_names = ['Case_Selector', 'Case_Construct_Name']
 
-class End_Select_Stmt(Base): # R811
+class End_Select_Stmt(EndStmtBase): # R811
     """
     <end-select-stmt> = END SELECT [ <case-construct-name> ]
     """
     subclass_names = []
     use_names = ['Case_Construct_Name']
+    def match(string): return EndStmtBase.match('SELECT',Case_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Case_Expr(Base): # R812
     """
@@ -3021,7 +3778,7 @@
     subclass_names = []
     use_names = ['Case_Value_Range_List']
 
-class Case_Value_Range(Base): # R814
+class Case_Value_Range(SeparatorBase): # R814
     """
     <case-value-range> = <case-value>
                          | <case-value> :
@@ -3029,6 +3786,8 @@
                          | <case-value> : <case-value>
     """
     subclass_names = ['Case_Value']
+    def match(string): return SeparatorBase.match(Case_Value, Case_Value, string)
+    match = staticmethod(match)
 
 class Case_Value(Base): # R815
     """
@@ -3048,19 +3807,21 @@
     subclass_names = []
     use_names = ['Associate_Stmt', 'Block', 'End_Associate_Stmt']
 
-class Associate_Stmt(Base): # R817
+class Associate_Stmt(StmtBase): # R817
     """
     <associate-stmt> = [ <associate-construct-name> : ] ASSOCIATE ( <association-list> )
     """
     subclass_names = []
     use_names = ['Associate_Construct_Name', 'Association_List']
 
-class Association(Base): # R818
+class Association(BinaryOpBase): # R818
     """
     <association> = <associate-name> => <selector>
     """
     subclass_names = []
     use_names = ['Associate_Name', 'Selector']
+    def match(string): return BinaryOpBase.match(Assiciate_Name, '=>', Selector, string)
+    match = staticmethod(match)
 
 class Selector(Base): # R819
     """
@@ -3069,12 +3830,14 @@
     """
     subclass_names = ['Expr', 'Variable']
 
-class End_Associate_Stmt(Base): # R820
+class End_Associate_Stmt(EndStmtBase): # R820
     """
     <end-associate-stmt> = END ASSOCIATE [ <associate-construct-name> ]
     """
     subclass_names = []
     use_names = ['Associate_Construct_Name']
+    def match(string): return EndStmtBase.match('ASSOCIATE',Associate_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Select_Type_Construct(Base): # R821
     """
@@ -3087,14 +3850,14 @@
     subclass_names = []
     use_names = ['Select_Type_Stmt', 'Type_Guard_Stmt', 'Block', 'End_Select_Type_Stmt']
 
-class Select_Type_Stmt(Base): # R822
+class Select_Type_Stmt(StmtBase): # R822
     """
     <select-type-stmt> = [ <select-construct-name> : ] SELECT TYPE ( [ <associate-name> => ] <selector> )
     """
     subclass_names = []
     use_names = ['Select_Construct_Name', 'Associate_Name', 'Selector']
 
-class Type_Guard_Stmt(Base): # R823
+class Type_Guard_Stmt(StmtBase): # R823
     """
     <type-guard-stmt> = TYPE IS ( <type-spec> ) [ <select-construct-name> ]
                         | CLASS IS ( <type-spec> ) [ <select-construct-name> ]
@@ -3103,12 +3866,14 @@
     subclass_names = []
     use_names = ['Type_Spec', 'Select_Construct_Name']
 
-class End_Select_Type_Stmt(Base): # R824
+class End_Select_Type_Stmt(EndStmtBase): # R824
     """
     <end-select-type-stmt> = END SELECT [ <select-construct-name> ]
     """
     subclass_names = []
     use_names = ['Select_Construct_Name']
+    def match(string): return EndStmtBase.match('SELECT',Select_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Do_Construct(Base): # R825
     """
@@ -3117,7 +3882,7 @@
     """
     subclass_names = ['Block_Do_Construct', 'Nonblock_Do_Construct']
 
-class Block_Do_Construct(Base): # R826
+class Block_Do_Construct(BlockBase): # R826
     """
     <block-do-construct> = <do-stmt>
                                <do-block>
@@ -3125,7 +3890,49 @@
     """
     subclass_names = []
     use_names = ['Do_Stmt', 'Do_Block', 'End_Do']
+    def match(reader):
+        assert isinstance(reader,FortranReaderBase),`reader`
+        content = []
+        try:
+            obj = Do_Stmt(reader)
+        except NoMatchError:
+            obj = None
+        if obj is None: return
+        content.append(obj)
+        if isinstance(obj, Label_Do_Stmt):
+            label = str(obj.dolabel)
+            while 1:
+                try:
+                    obj = Execution_Part_Construct(reader)
+                except NoMatchError:
+                    obj = None
+                if obj is None: break
+                content.append(obj)
+                if isinstance(obj, Continue_Stmt) and obj.item.label==label:
+                    return content,
+            return
+            raise RuntimeError,'Expected continue stmt with specified label'
+        else:
+            obj = End_Do(reader)
+            content.append(obj)
+            raise NotImplementedError
+        return content,
+    match = staticmethod(match)
 
+    def tofortran(self, tab='', isfix=None):
+        if not isinstance(self.content[0], Label_Do_Stmt):
+            return BlockBase.tofortran(tab, isfix)
+        l = []
+        start = self.content[0]
+        end = self.content[-1]
+        extra_tab = '  '
+        l.append(start.tofortran(tab=tab,isfix=isfix))
+        for item in self.content[1:-1]:
+            l.append(item.tofortran(tab=tab+extra_tab,isfix=isfix))
+        if len(self.content)>1:
+            l.append(end.tofortran(tab=tab,isfix=isfix))
+        return '\n'.join(l)
+
 class Do_Stmt(Base): # R827
     """
     <do-stmt> = <label-do-stmt>
@@ -3133,14 +3940,29 @@
     """
     subclass_names = ['Label_Do_Stmt', 'Nonlabel_Do_Stmt']
 
-class Label_Do_Stmt(Base): # R828
+class Label_Do_Stmt(StmtBase): # R828
     """
     <label-do-stmt> = [ <do-construct-name> : ] DO <label> [ <loop-control> ]
     """
     subclass_names = []
     use_names = ['Do_Construct_Name', 'Label', 'Loop_Control']
-
-class Nonlabel_Do_Stmt(Base): # R829
+    def match(string):
+        if string[:2].upper()!='DO': return
+        line = string[2:].lstrip()
+        m = pattern.label.match(line)
+        if m is None: return
+        label = m.group()
+        line = line[m.end():].lstrip()
+        if line: return Label(label), Loop_Control(line)
+        return Label(label), None
+    match = staticmethod(match)
+    def init(self,*args):
+        self.dolabel, self.loop_control = args
+    def tostr(self):
+        if self.loop_control is None: return 'DO %s' % (self.dolabel)
+        return 'DO %s %s' % (self.dolabel, self.loop_control)
+    
+class Nonlabel_Do_Stmt(StmtBase): # R829
     """
     <nonlabel-do-stmt> = [ <do-construct-name> : ] DO [ <loop-control> ]
     """
@@ -3154,7 +3976,31 @@
     """
     subclass_names = []
     use_names = ['Do_Variable', 'Scalar_Int_Expr', 'Scalar_Logical_Expr']
-
+    def match(string):
+        if string.startswith(','):
+            line, repmap = string_replace_map(string[1:].lstrip())
+        else:
+            line, repmap = string_replace_map(string)
+        if line[:5].upper()=='WHILE' and line[5:].lstrip().startswith('('):
+            l = line[5:].lstrip()
+            i = l.find(')')
+            if i!=-1 and i==len(l)-1:
+                return Scalar_Logical_Expr(repmap(l[1:i].strip())),
+        if line.count('=')!=1: return
+        var,rhs = line.split('=')
+        rhs = [s.strip() for s in rhs.lstrip().split(',')]
+        if not 2<=len(rhs)<=3: return
+        return Variable(repmap(var.rstrip())),map(Scalar_Int_Expr, map(repmap,rhs))
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+    def tostr(self):
+        if len(self.items)==1: return ', WHILE (%s)' % (self.items[0])
+        return ', %s = %s' % (self.items[0], ', '.join(map(str,self.items[1])))
+    def torepr(self):
+        if len(self.items)==1: return '%s(%r)' % (self.__class__.__name__, self.items[0])
+        return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
+    
 class Do_Variable(Base): # R831
     """
     <do-variable> = <scalar-int-variable>
@@ -3174,12 +4020,14 @@
     """
     subclass_names = ['End_Do_Stmt', 'Continue_Stmt']
 
-class End_Do_Stmt(Base): # R834
+class End_Do_Stmt(EndStmtBase): # R834
     """
     <end-do-stmt> = END DO [ <do-construct-name> ]
     """
     subclass_names = []
     use_names = ['Do_Construct_Name']
+    def match(string): return EndStmtBase.match('DO',Do_Construct_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Nonblock_Do_Construct(Base): # R835
     """
@@ -3188,7 +4036,7 @@
     """
     subclass_names = ['Action_Term_Do_Construct', 'Outer_Shared_Do_Construct']
 
-class Action_Term_Do_Construct(Base): # R836
+class Action_Term_Do_Construct(BlockBase): # R836
     """
     <action-term-do-construct> = <label-do-stmt>
                                      <do-body>
@@ -3196,24 +4044,35 @@
     """
     subclass_names = []
     use_names = ['Label_Do_Stmt', 'Do_Body', 'Do_Term_Action_Stmt']
+    def match(reader):
+        content = []
+        for cls in [Label_Do_Stmt, Do_Body, Do_Term_Action_Stmt]:
+            obj = cls(reader)
+            if obj is None: # todo: restore reader
+                return
+            content.append(obj)
+        return content,
+    match = staticmethod(match)
 
-class Do_Body(Base): # R837
+class Do_Body(BlockBase): # R837
     """
     <do-body> = [ <execution-part-construct> ]...
     """
     subclass_names = []
     use_names = ['Execution_Part_Construct']
+    def match(string): return BlockBase.match(None, [Execution_Part_Construct], None, string)
+    match = staticmethod(match)
 
-class Do_Term_Action_Stmt(Base): # R838
+class Do_Term_Action_Stmt(StmtBase): # R838
     """
     <do-term-action-stmt> = <action-stmt>
     C824: <do-term-action-stmt> shall not be <continue-stmt>, <goto-stmt>, <return-stmt>, <stop-stmt>,
                           <exit-stmt>, <cycle-stmt>, <end-function-stmt>, <end-subroutine-stmt>,
                           <end-program-stmt>, <arithmetic-if-stmt>
     """
-    subclass_names = ['Action_Stmt']
+    subclass_names = ['Action_Stmt_C824']
 
-class Outer_Shared_Do_Construct(Base): # R839
+class Outer_Shared_Do_Construct(BlockBase): # R839
     """
     <outer-shared-do-construct> = <label-do-stmt>
                                       <do-body>
@@ -3221,6 +4080,15 @@
     """
     subclass_names = []
     use_names = ['Label_Do_Stmt', 'Do_Body', 'Shared_Term_Do_Construct']
+    def match(reader):
+        content = []
+        for cls in [Label_Do_Stmt, Do_Body, Shared_Term_Do_Construct]:
+            obj = cls(reader)
+            if obj is None: # todo: restore reader
+                return
+            content.append(obj)
+        return content,
+    match = staticmethod(match)
 
 class Shared_Term_Do_Construct(Base): # R840
     """
@@ -3229,7 +4097,7 @@
     """
     subclass_names = ['Outer_Shared_Do_Construct', 'Inner_Shared_Do_Construct']
 
-class Inner_Shared_Do_Construct(Base): # R841
+class Inner_Shared_Do_Construct(BlockBase): # R841
     """
     <inner-shared-do-construct> = <label-do-stmt>
                                       <do-body>
@@ -3238,60 +4106,104 @@
     subclass_names = []
     use_names = ['Label_Do_Stmt', 'Do_Body', 'Do_Term_Shared_Stmt']
 
-class Do_Term_Shared_Stmt(Base): # R842
+    def match(reader):
+        content = []
+        for cls in [Label_Do_Stmt, Do_Body, Do_Term_Shared_Stmt]:
+            obj = cls(reader)
+            if obj is None: # todo: restore reader
+                return
+            content.append(obj)
+        return content,
+    match = staticmethod(match)
+
+class Do_Term_Shared_Stmt(StmtBase): # R842
     """
     <do-term-shared-stmt> = <action-stmt>
     C826: see C824 above.
     """
     subclass_names = ['Action_Stmt']
 
-class Cycle_Stmt(Base): # R843
+class Cycle_Stmt(StmtBase, WORDClsBase): # R843
     """
     <cycle-stmt> = CYCLE [ <do-construct-name> ]
     """
     subclass_names = []
     use_names = ['Do_Construct_Name']
+    def match(string): return WORDClsBase.match('CYCLE', Do_Construct_Name, string)
+    match = staticmethod(match)
 
-class Exit_Stmt(Base): # R844
+class Exit_Stmt(StmtBase, WORDClsBase): # R844
     """
     <exit-stmt> = EXIT [ <do-construct-name> ]
     """
     subclass_names = []
     use_names = ['Do_Construct_Name']
+    def match(string): return WORDClsBase.match('EXIT', Do_Construct_Name, string)
+    match = staticmethod(match)
 
-class Goto_Stmt(Base): # R845
+class Goto_Stmt(StmtBase): # R845
     """
     <goto-stmt> = GO TO <label>
     """
     subclass_names = []
     use_names = ['Label']
+    def match(string):
+        if string[:2].upper() != 'GO': return
+        line = string[2:].lstrip()
+        if line[:2].upper() != 'TO': return
+        return Label(line[2:].lstrip()),
+    match = staticmethod(match)
+    def init(self, value): self.value = value
+    def tostr(self): return 'GO TO %s' % (self.value)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.value)
 
-class Computed_Goto_Stmt(Base): # R846
+class Computed_Goto_Stmt(StmtBase): # R846
     """
     <computed-goto-stmt> = GO TO ( <label-list> ) [ , ] <scalar-int-expr>
     """
     subclass_names = []
     use_names = ['Label_List', 'Scalar_Int_Expr']
 
-class Arithmetic_If_Stmt(Base): # R847
+class Arithmetic_If_Stmt(StmtBase): # R847
     """
     <arithmetic-if-stmt> = IF ( <scalar-numeric-expr> ) <label> , <label> , <label>
     """
     subclass_names = []
     use_names = ['Scalar_Numeric_Expr', 'Label']
+    def match(string):
+        if string[:2].upper() != 'IF': return
+        line = string[2:].lstrip()
+        if not line.startswith('('): return
+        i = line.rfind(')')
+        if i==-1: return
+        labels = line[i+1:].lstrip().split(',')
+        if len(labels) != 3: return
+        labels = [Label(l.strip()) for l in labels]
+        return Scalar_Numeric_Expr(line[1:i].strip()), labels
+    match = staticmethod(match)
+    def init(self, *args):
+        self.expr, self.labels = args
+        return
+    def tostr(self): return 'IF (%s) %s' % (self.expr, ', '.join(map(str,self.labels)))
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.expr, ', '.join(map(repr,self.labels)))
 
-class Continue_Stmt(Base): # R848
+class Continue_Stmt(StmtBase, STRINGBase): # R848
     """
     <continue-stmt> = CONTINUE
     """
     subclass_names = []
-    
-class Stop_Stmt(Base): # R849
+    def match(string): return STRINGBase.match('CONTINUE', string)
+    match = staticmethod(match)
+
+
+class Stop_Stmt(StmtBase, WORDClsBase): # R849
     """
     <stop-stmt> = STOP [ <stop-code> ]
     """
     subclass_names = []
     use_names = ['Stop_Code']
+    def match(string): return WORDClsBase.match('STOP', Stop_Code, string)
+    match = staticmethod(match)
 
 class Stop_Code(StringBase): # R850
     """
@@ -3307,13 +4219,15 @@
 ############################### SECTION  9 ####################################
 ###############################################################################
 
-class Io_Unit(Base): # R901
+class Io_Unit(StringBase): # R901
     """
     <io-unit> = <file-unit-number>
                 | *
                 | <internal-file-variable>
     """
     subclass_names = ['File_Unit_Number', 'Internal_File_Variable']
+    def match(string): return StringBase.match('*', string)
+    match = staticmethod(match)
 
 class File_Unit_Number(Base): # R902
     """
@@ -3328,7 +4242,7 @@
     """
     subclass_names = ['Char_Variable']
 
-class Open_Stmt(Base): # R904
+class Open_Stmt(StmtBase): # R904
     """
     <open-stmt> = OPEN ( <connect-spec-list> )
     """
@@ -3373,7 +4287,7 @@
     """
     subclass_names = ['Scalar_Default_Char_Variable']
 
-class Close_Stmt(Base): # R908
+class Close_Stmt(StmtBase): # R908
     """
     <close-stmt> = CLOSE ( <close-spec-list> )
     """
@@ -3392,7 +4306,7 @@
     use_names = ['File_Unit_Number', 'Scalar_Default_Char_Expr', 'Label', 'Iomsg_Variable',
                  'Scalar_Int_Variable']
 
-class Read_Stmt(Base): # R910
+class Read_Stmt(StmtBase): # R910
     """
     <read-stmt> = READ ( <io-control-spec-list> ) [ <input-item-list> ]
                   | READ <format> [ , <input-item-list> ]
@@ -3400,21 +4314,95 @@
     subclass_names = []
     use_names = ['Io_Control_Spec_List', 'Input_Item_List', 'Format']
 
-class Write_Stmt(Base): # R911
+class Write_Stmt(StmtBase): # R911
     """
     <write-stmt> = WRITE ( <io-control-spec-list> ) [ <output-item-list> ]
     """
     subclass_names = []
     use_names = ['Io_Control_Spec_List', 'Output_Item_List']
-
-class Print_Stmt(Base): # R912
+    def match(string):
+        if string[:5].upper()!='WRITE': return
+        line = string[5:].lstrip()
+        if not line.startswith('('): return
+        line, repmap = string_replace_map(line)
+        i = line.find(')')
+        if i==-1: return
+        l = line[1:i].strip()
+        if not l: return
+        l = repmap(l)
+        if i==len(line)-1:
+            return Io_Control_Spec_List(l),None
+        return Io_Control_Spec_List(l), Output_Item_List(repmap(line[i+1:].lstrip()))
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        if self.items[1] is None: return 'WRITE(%s)' % (self.items[0])
+        return 'WRITE(%s) %s' % tuple(self.items)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
+    
+class Print_Stmt(StmtBase): # R912
     """
     <print-stmt> = PRINT <format> [ , <output-item-list> ]
     """
     subclass_names = []
     use_names = ['Format', 'Output_Item_List']
+    def match(string):
+        if string[:5].upper()!='PRINT': return
+        line = string[5:]
+        if not line: return
+        c = line[0].upper()
+        if 'A'<=c<='Z' or c=='_' or '0'<=c<='9': return
+        line, repmap = string_replace_map(line.lstrip())
+        i = line.find(',')
+        if i==-1: return Format(repmap(line)), None
+        l = repmap(line[i+1:].lstrip())
+        if not l: return
+        return Format(repmap(line[:i].rstrip())), Output_Item_List(l)
+    match = staticmethod(match)
+    def init(self, *args):
+        self.items = args
+        return
+    def tostr(self):
+        if self.items[1] is None: return 'PRINT %s' % (self.items[0])
+        return 'PRINT %s, %s' % tuple(self.items)
+    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
+    
+class Io_Control_Spec_List(SequenceBase): # R913-list
+    """
+    <io-control-spec-list> is a list taking into account C910, C917, C918
+    """
+    subclass_names = []
+    use_names = ['Io_Control_Spec']
+    def match(string):
+        line, repmap = string_replace_map(string)
+        splitted = line.split(',')
+        if not splitted: return
+        lst = []
+        for i in range(len(splitted)):
+            p = splitted[i].strip()
+            if i==0:
+                if '=' not in p: p = 'UNIT=%s' % (repmap(p))
+                else: p = repmap(p)
+            elif i==1:
+                if '=' not in p:
+                    p = repmap(p)
+                    try:
+                        f = Format(p)
+                        # todo: make sure that f is char-expr, if not, raise NoMatchError
+                        p = 'FMT=%s' % (Format(p))
+                    except NoMatchError:
+                        p = 'NML=%s' % (Namelist_Group_Name(p))
+                else:
+                    p = repmap(p)
+            else:
+                p = repmap(p)
+            lst.append(Io_Control_Spec(p))
+        return ',', tuple(lst)
+    match = staticmethod(match)
 
-class Io_Control_Spec(Base): # R913
+class Io_Control_Spec(KeywordValueBase): # R913
     """
     <io-control-spec> = [ UNIT = ] <io-unit>
                         | [ FMT = ] <format>
@@ -3441,14 +4429,35 @@
     use_names = ['Io_Unit', 'Format', 'Namelist_Group_Name', 'Scalar_Default_Char_Expr',
                  'Scalar_Char_Initialization_Expr', 'Label', 'Scalar_Int_Variable',
                  'Iomsg_Variable', 'Scalar_Int_Expr']
+    def match(string):
+        for (k,v) in [\
+            (['ADVANCE', 'BLANK', 'DECIMAL', 'DELIM', 'PAD', 'ROUND', 'SIGN'], Scalar_Default_Char_Expr),
+            ('ASYNCHRONOUS', Scalar_Char_Initialization_Expr),
+            (['END','EOR','ERR'], Label),
+            (['ID','IOSTAT','SIZE'], Scalar_Int_Variable),
+            ('IOMSG', Iomsg_Variable),
+            (['POS', 'REC'], Scalar_Int_Expr),
+            ('UNIT', Io_Unit),
+            ('FMT', Format),
+            ('NML', Namelist_Group_Name)
+            ]:
+            try:
+                obj = KeywordValueBase.match(k, v, string, upper_lhs = True)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
+        return
+    match = staticmethod(match)
 
-class Format(Base): # R914
+class Format(StringBase): # R914
     """
     <format> = <default-char-expr>
                | <label>
                | *
     """
-    subclass_names = ['Default_Char_Expr', 'Label']
+    subclass_names = ['Label', 'Default_Char_Expr']
+    def match(string): return StringBase.match('*', string)
+    match = staticmethod(match)
 
 class Input_Item(Base): # R915
     """
@@ -3493,14 +4502,16 @@
     subclass_names = []
     use_names = ['Derived_Type_Spec']
 
-class Wait_Stmt(Base): # R921
+class Wait_Stmt(StmtBase, CALLBase): # R921
     """
     <wait-stmt> = WAIT ( <wait-spec-list> )
     """
     subclass_names = []
     use_names = ['Wait_Spec_List']
+    def match(string): return CALLBase.match('WAIT', Wait_Spec_List, string, require_rhs=True)
+    match = staticmethod(match)
 
-class Wait_Spec(Base): # R922
+class Wait_Spec(KeywordValueBase): # R922
     """
     <wait-spec> = [ UNIT = ] <file-unit-number>
                   | END = <label>
@@ -3512,8 +4523,24 @@
     """
     subclass_names = []
     use_names = ['File_Unit_Number', 'Label', 'Scalar_Int_Expr', 'Iomsg_Variable', 'Scalar_Int_Variable']
+    def match(string):
+        for (k,v) in [\
+            (['END','EOR','ERR'], Label),
+            ('IOSTAT', Scalar_Int_Variable),
+            ('IOMSG', Iomsg_Variable),
+            ('ID', Scalar_Int_Expr),
+            ('UNIT', File_Unit_Number),
+            ]:
+            try:
+                obj = KeywordValueBase.match(k, v, string, upper_lhs = True)
+            except NoMatchError:
+                obj = None
+            if obj is not None: return obj
+        return 'UNIT', File_Unit_Number(string)
 
-class Backspace_Stmt(Base): # R923
+    match = staticmethod(match)
+
+class Backspace_Stmt(StmtBase): # R923
     """
     <backspace-stmt> = BACKSPACE <file-unit-number>
                        | BACKSPACE ( <position-spec-list> )
@@ -3521,7 +4548,7 @@
     subclass_names = []
     use_names = ['File_Unit_Number', 'Position_Spec_List']
 
-class Endfile_Stmt(Base): # R924
+class Endfile_Stmt(StmtBase): # R924
     """
     <endfile-stmt> = ENDFILE <file-unit-number>
                      | ENDFILE ( <position-spec-list> )
@@ -3529,7 +4556,7 @@
     subclass_names = []
     use_names = ['File_Unit_Number', 'Position_Spec_List']
 
-class Rewind_Stmt(Base): # R925
+class Rewind_Stmt(StmtBase): # R925
     """
     <rewind-stmt> = REWIND <file-unit-number>
                     | REWIND ( <position-spec-list> )
@@ -3547,7 +4574,7 @@
     subclass_names = []
     use_names = ['File_Unit_Number', 'Iomsg_Variable', 'Scalar_Int_Variable', 'Label']
 
-class Flush_Stmt(Base): # R927
+class Flush_Stmt(StmtBase): # R927
     """
     <flush-stmt> = FLUSH <file-unit-number>
                     | FLUSH ( <position-spec-list> )
@@ -3565,7 +4592,7 @@
     subclass_names = []
     use_names = ['File_Unit_Number', 'Iomsg_Variable', 'Scalar_Int_Variable', 'Label']
 
-class Inquire_Stmt(Base): # R929
+class Inquire_Stmt(StmtBase): # R929
     """
     <inquire-stmt> = INQUIRE ( <inquire-spec-list> )
                      | INQUIRE ( IOLENGTH = <scalar-int-variable> ) <output-item-list>
@@ -3622,7 +4649,7 @@
 ############################### SECTION 10 ####################################
 ###############################################################################
 
-class Format_Stmt(Base): # R1001
+class Format_Stmt(StmtBase): # R1001
     """
     <format-stmt> = FORMAT <format-specification>
     """
@@ -3739,22 +4766,26 @@
     """
     subclass_names = ['Int_Literal_Constant']
 
-class Sign_Edit_Desc(Base): # R1015
+class Sign_Edit_Desc(STRINGBase): # R1015
     """
     <sign-edit-desc> = SS
                        | SP
                        | S
     """
     subclass_names = []
+    def match(string): return STRINGBase.match(['SS','SP','S'], string)
+    match = staticmethod(match)
     
-class Blank_Interp_Edit_Desc(Base): # R1016
+class Blank_Interp_Edit_Desc(STRINGBase): # R1016
     """
     <blank-interp-edit-desc> = BN
                                | BZ
     """
     subclass_names = []
-    
-class Round_Edit_Desc(Base): # R1017
+    def match(string): return STRINGBase.match(['BN','BZ',], string)
+    match = staticmethod(match)
+
+class Round_Edit_Desc(STRINGBase): # R1017
     """
     <round-edit-desc> = RU
                         | RD
@@ -3764,14 +4795,18 @@
                         | RP
     """
     subclass_names = []
-    
-class Decimal_Edit_Desc(Base): # R1018
+    def match(string): return STRINGBase.match(['RU','RD','RZ','RN','RC','RP'], string)
+    match = staticmethod(match)
+
+class Decimal_Edit_Desc(STRINGBase): # R1018
     """
     <decimal-edit-desc> = DC
                           | DP
     """
     subclass_names = []
-    
+    def match(string): return STRINGBase.match(['DC','DP'], string)
+    match = staticmethod(match)
+
 class Char_String_Edit_Desc(Base): # R1019
     """
     <char-string-edit-desc> = <char-literal-constant>
@@ -3794,20 +4829,22 @@
     use_names = ['Program_Stmt', 'Specification_Part', 'Execution_Part', 'Internal_Subprogram_Part',
                  'End_Program_Stmt']
 
-class Program_Stmt(Base): # R1102
+class Program_Stmt(StmtBase): # R1102
     """
     <program-stmt> = PROGRAM <program-name>
     """
     subclass_names = []
     use_names = ['Program_Name']
 
-class End_Program_Stmt(Base): # R1103
+class End_Program_Stmt(EndStmtBase): # R1103
     """
     <end-program-stmt> = END [ PROGRAM [ <program-name> ] ]
     """
     subclass_names = []
     use_names = ['Program_Name']
-    
+    def match(string): return EndStmtBase.match('PROGRAM',Program_Name, string)
+    match = staticmethod(match)
+
 class Module(Base): # R1104
     """
     <module> = <module-stmt>
@@ -3818,19 +4855,21 @@
     subclass_names = []
     use_names = ['Module_Stmt', 'Specification_Part', 'Module_Subprogram_Part', 'End_Module_Stmt']
 
-class Module_Stmt(Base): # R1105
+class Module_Stmt(StmtBase): # R1105
     """
     <module-stmt> = MODULE <module-name>
     """
     subclass_names = []
     use_names = ['Module_Name']
 
-class End_Module_Stmt(Base): # R1106
+class End_Module_Stmt(EndStmtBase): # R1106
     """
     <end-module-stmt> = END [ MODULE [ <module-name> ] ]
     """
     subclass_names = []
     use_names = ['Module_Name']
+    def match(string): return EndStmtBase.match('MODULE',Module_Name, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Module_Subprogram_Part(Base): # R1107
     """
@@ -3848,7 +4887,7 @@
     """
     subclass_names = ['Function_Subprogram', 'Subroutine_Subprogram']
 
-class Use_Stmt(Base): # R1109
+class Use_Stmt(StmtBase): # R1109
     """
     <use-stmt> = USE [ [ , <module-nature> ] :: ] <module-name> [ , <rename-list> ]
                  | USE [ [ , <module-nature> ] :: ] <module-name> , ONLY: [ <only-list> ]
@@ -3856,13 +4895,15 @@
     subclass_names = []
     use_names = ['Module_Nature', 'Module_Name', 'Rename_List', 'Only_List']
 
-class Module_Nature(Base): # R1110
+class Module_Nature(STRINGBase): # R1110
     """
     <module-nature> = INTRINSIC
                       | NON_INTRINSIC
     """
     subclass_names = []
-    
+    def match(string): return STRINGBase.match(['INTRINSIC','NON_INTRINSIC'], string)
+    match = staticmethod(match)
+
 class Rename(Base): # R1111
     """
     <rename> = <local-name> => <use-name>
@@ -3908,19 +4949,21 @@
     subclass_names = []
     use_names = ['Block_Data_Stmt', 'Specification_Part', 'End_Block_Data_Stmt']
 
-class Block_Data_Stmt(Base): # R1117
+class Block_Data_Stmt(StmtBase): # R1117
     """
     <block-data-stmt> = BLOCK DATA [ <block-data-name> ]
     """
     subclass_names = []
     use_names = ['Block_Data_Name']
 
-class End_Block_Data_Stmt(Base): # R1118
+class End_Block_Data_Stmt(EndStmtBase): # R1118
     """
     <end-block-data-stmt> = END [ BLOCK DATA [ <block-data-name> ] ]
     """
     subclass_names = []
     use_names = ['Block_Data_Name']
+    def match(string): return EndStmtBase.match('BLOCK DATA',Block_Data_Name, string)
+    match = staticmethod(match)
 
 ###############################################################################
 ############################### SECTION 12 ####################################
@@ -3943,7 +4986,7 @@
     """
     subclass_names = ['Interface_Body', 'Procedure_Stmt']
 
-class Interface_Stmt(Base): # R1203
+class Interface_Stmt(StmtBase): # R1203
     """
     <interface-stmt> = INTERFACE [ <generic-spec> ]
                        | ABSTRACT INTERFACE
@@ -3951,12 +4994,14 @@
     subclass_names = []
     use_names = ['Generic_Spec']
 
-class End_Interface_Stmt(Base): # R1204
+class End_Interface_Stmt(EndStmtBase): # R1204
     """
     <end-interface-stmt> = END INTERFACE [ <generic-spec> ]
     """
     subclass_names = []
     use_names = ['Generic_Spec']
+    def match(string): return EndStmtBase.match('INTERFACE',Generic_Spec, string, require_stmt_type=True)
+    match = staticmethod(match)
 
 class Interface_Body(Base): # R1205
     """
@@ -3970,7 +5015,7 @@
     subclass_names = []
     use_names = ['Function_Stmt', 'Specification_Part', 'Subroutine_Stmt', 'End_Function_Stmt', 'End_Subroutine_Stmt']
 
-class Procedure_Stmt(Base): # R1206
+class Procedure_Stmt(StmtBase): # R1206
     """
     <procedure-stmt> = [ MODULE ] PROCEDURE <procedure-name-list>
     """
@@ -3996,7 +5041,7 @@
     """
     subclass_names = []
 
-class Import_Stmt(Base): # R1209
+class Import_Stmt(StmtBase): # R1209
     """
     <import-stmt> = IMPORT [ :: ] <import-name-list>
     """
@@ -4016,14 +5061,25 @@
     def tostr(self): return 'IMPORT :: %s' % (self.names)
     def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.names)
 
-class External_Stmt(Base): # R1210
+class External_Stmt(StmtBase): # R1210
     """
     <external-stmt> = EXTERNAL [ :: ] <external-name-list>
     """
     subclass_names = []
     use_names = ['External_Name_List']
+    def match(string):
+        if string[:8].upper() != 'EXTERNAL': return
+        line = string[8:].lstrip()
+        if line.startswith('::'): line = line[2:].lstrip()
+        return External_Name_List(line),
+    match = staticmethod(match)
+    def init(self, names):
+        self.names = names
+        return
+    def tostr(self): return 'EXTERNAL :: %s' % (self.names)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.names)
 
-class Procedure_Declaration_Stmt(Base): # R1211
+class Procedure_Declaration_Stmt(StmtBase): # R1211
     """
     <procedure-declaration-stmt> = PROCEDURE ( [ <proc-interface> ] ) [ [ , <proc-attr-spec> ]... :: ] <proc-decl-list>
     """
@@ -4061,7 +5117,7 @@
     """
     subclass_names = ['Name']
 
-class Intrinsic_Stmt(Base): # R1216
+class Intrinsic_Stmt(StmtBase): # R1216
     """
     <intrinsic-stmt> = INTRINSIC [ :: ] <intrinsic-procedure-name-list>
     """
@@ -4078,12 +5134,30 @@
         return CallBase.match(Procedure_Designator, Actual_Arg_Spec_List, string)
     match = staticmethod(match)
 
-class Call_Stmt(Base): # R1218
+class Call_Stmt(StmtBase): # R1218
     """
     <call-stmt> = CALL <procedure-designator> [ ( [ <actual-arg-spec-list> ] ) ]
     """
     subclass_names = []
     use_names = ['Procedure_Designator', 'Actual_Arg_Spec_List']
+    def match(string):
+        if string[:4].upper()!='CALL': return
+        line, repmap = string_replace_map(string[4:].lstrip())
+        if line.endswith(')'):
+            i = line.rfind('(')
+            if i==-1: return
+            args = repmap(line[i+1:-1].strip())
+            if args:
+                return Procedure_Designator(repmap(line[:i].rstrip())),Actual_Arg_Spec_List(args)
+            return Procedure_Designator(repmap(line[:i].rstrip())),None
+        return Procedure_Designator(string[4:].lstrip()),None
+    match = staticmethod(match)
+    def init(self, *args):
+        self.designator, self.args = args
+    def tostr(self):
+        if self.args is None: return 'CALL %s' % (self.designator)
+        return 'CALL %s(%s)' % (self.designator, self.args)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.designator, self.args)
 
 class Procedure_Designator(BinaryOpBase): # R1219
     """
@@ -4104,7 +5178,7 @@
     """
     subclass_names = ['Actual_Arg']
     use_names = ['Keyword']
-    def match(string): return KeywordValueBase.match(Actual_Arg, string)
+    def match(string): return KeywordValueBase.match(Keyword, Actual_Arg, string)
     match = staticmethod(match)
 
 class Actual_Arg(Base): # R1221
@@ -4150,7 +5224,7 @@
         return BlockBase.match(Function_Stmt, [Specification_Part, Execution_Part, Internal_Subprogram_Part], End_Function_Stmt, reader)
     match = staticmethod(match)
 
-class Function_Stmt(Base): # R1224
+class Function_Stmt(StmtBase): # R1224
     """
     <function-stmt> = [ <prefix> ] FUNCTION <function-name> ( [ <dummy-arg-name-list> ] ) [ <suffix> ]
     """
@@ -4178,7 +5252,7 @@
     def match(string): return SequenceBase.match(Prefix._separator, Prefix_Spec, string)
     match = staticmethod(match)
 
-class Prefix_Spec(StringBase): # R1228
+class Prefix_Spec(STRINGBase): # R1228
     """
     <prefix-spec> = <declaration-type-spec>
                     | RECURSIVE
@@ -4187,13 +5261,7 @@
     """
     subclass_names = ['Declaration_Type_Spec']
     def match(string):
-        if len(string)==9:
-            upper = string.upper()
-            if upper in ['RECURSIVE', 'ELEMENTAL']: return upper,
-        elif len(string)==4:
-            upper = string.upper()
-            if upper=='PURE': return upper,
-        return None
+        return STRINGBase.match(['RECURSIVE', 'PURE', 'ELEMENTAL'], string)
     match = staticmethod(match)
 
 class Suffix(Base): # R1229
@@ -4210,8 +5278,7 @@
     """
     subclass_names = []
     use_names = ['Function_Name']
-    def match(string):
-        return EndStmtBase.match('FUNCTION',Function_Name, string)
+    def match(string): return EndStmtBase.match('FUNCTION',Function_Name, string)
     match = staticmethod(match)
 
 class Subroutine_Subprogram(BlockBase): # R1231
@@ -4229,7 +5296,7 @@
         return BlockBase.match(Subroutine_Stmt, [Specification_Part, Execution_Part, Internal_Subprogram_Part], End_Subroutine_Stmt, reader)
     match = staticmethod(match)
 
-class Subroutine_Stmt(Base): # R1232
+class Subroutine_Stmt(StmtBase): # R1232
     """
     <subroutine-stmt> = [ <prefix> ] SUBROUTINE <subroutine-name> [ ( [ <dummy-arg-list> ] ) [ <proc-language-binding-spec> ] ]
     """
@@ -4238,6 +5305,7 @@
     def match(string):
         line, repmap = string_replace_map(string)
         m = pattern.subroutine.search(line)
+        if m is None: return
         prefix = line[:m.start()].rstrip() or None
         if prefix is not None:
             prefix = Prefix(repmap(prefix))
@@ -4282,9 +5350,7 @@
                   | *
     """
     subclass_names = ['Dummy_Arg_Name']
-    def match(string):
-        if string=='*': return '*',
-        return
+    def match(string): return StringBase.match('*', string)
     match = staticmethod(match)
 
 class End_Subroutine_Stmt(EndStmtBase): # R1234
@@ -4296,27 +5362,42 @@
     def match(string): return EndStmtBase.match('SUBROUTINE', Subroutine_Name, string)
     match = staticmethod(match)
 
-class Entry_Stmt(Base): # R1235
+class Entry_Stmt(StmtBase): # R1235
     """
     <entry-stmt> = ENTRY <entry-name> [ ( [ <dummy-arg-list> ] ) [ <suffix> ] ]
     """
     subclass_names = []
     use_names = ['Entry_Name', 'Dummy_Arg_List', 'Suffix']
 
-class Return_Stmt(Base): # R1236
+class Return_Stmt(StmtBase): # R1236
     """
     <return-stmt> = RETURN [ <scalar-int-expr> ]
     """
     subclass_names = []
     use_names = ['Scalar_Int_Expr']
+    def match(string):
+        start = string[:6].upper()
+        if start!='RETURN': return
+        if len(string)==6: return None,
+        return Scalar_Int_Expr(string[6:].lstrip()),
+    match = staticmethod(match)
+    def init(self, value):
+        self.value = value
+        return
+    def tostr(self): 
+        if self.value is None: return 'RETURN'
+        return 'RETURN %s' % (self.value)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.value)
 
-class Contains_Stmt(Base): # R1237
+class Contains_Stmt(StmtBase, STRINGBase): # R1237
     """
     <contains-stmt> = CONTAINS
     """
     subclass_names = []
+    def match(string): return STRINGBase.match('CONTAINS',string)
+    match = staticmethod(match)
 
-class Stmt_Function_Stmt(Base): # R1238
+class Stmt_Function_Stmt(StmtBase): # R1238
     """
     <stmt-function-stmt> = <function-name> ( [ <dummy-arg-name-list> ] ) = Scalar_Expr
     """

Modified: trunk/numpy/f2py/lib/parser/api.py
===================================================================
--- trunk/numpy/f2py/lib/parser/api.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/api.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -11,6 +11,7 @@
 -----
 """
 
+import Fortran2003
 # import all Statement classes:
 from base_classes import EndStatement
 from block_statements import *
@@ -64,6 +65,7 @@
                          Default contains current working directory
                          and the directory of file name.
     """
+    from parsefortran import FortranParser
     reader = get_reader(input, isfree, isstrict, include_dirs)
     parser = FortranParser(reader)
     parser.parse()

Modified: trunk/numpy/f2py/lib/parser/base_classes.py
===================================================================
--- trunk/numpy/f2py/lib/parser/base_classes.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/base_classes.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -399,7 +399,7 @@
             self.rank = len(array_spec)
             if self.is_deferred_shape_array(): # a(:,:)
                 pass
-            elif self.is_explict_shape_array(self):
+            elif self.is_explicit_shape_array():
                 shape = []
                 for spec in array_spec:
                     if len(spec)==1:

Modified: trunk/numpy/f2py/lib/parser/pattern_tools.py
===================================================================
--- trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -47,18 +47,19 @@
                            '=': '[=]'
                            }
 
-    def __init__(self, label, pattern, optional=0, flags=0):
+    def __init__(self, label, pattern, optional=0, flags=0, value=None):
         self.label = label
         self.pattern = pattern
         self.optional = optional
         self._flags = flags
+        self.value = value
         return
 
     def flags(self, *flags):
         f = self._flags
         for f1 in flags:
             f = f | f1
-        return Pattern(self.label, self.pattern, optional=self.optional, flags=f)
+        return Pattern(self.label, self.pattern, optional=self.optional, flags=f, value=self.value)
 
     def get_compiled(self):
         try:
@@ -83,6 +84,7 @@
         compiled = self.get_compiled()
         t = compiled.split(string)
         if len(t) < 3: return
+        if '' in t[1:-1]: return
         rhs = t[-1].strip()
         pattern_match = t[-2].strip()
         assert abs(self).match(pattern_match),`self,string,t,pattern_match`
@@ -106,7 +108,7 @@
         return lhs, pattern_match, rhs
 
     def __abs__(self):
-        return Pattern(self.label, r'\A' + self.pattern+ r'\Z',flags=self._flags)
+        return Pattern(self.label, r'\A' + self.pattern+ r'\Z',flags=self._flags, value=self.value)
 
     def __repr__(self):
         return '%s(%r, %r)' % (self.__class__.__name__, self.label, self.pattern)
@@ -178,16 +180,17 @@
         else:
             label = '<%s>' % (name)
         pattern = '(?P%s%s)' % (label.replace('-','_'), self.pattern)
-        return Pattern(label, pattern, flags=self._flags)
+        return Pattern(label, pattern, flags=self._flags, value= self.value)
 
     def rename(self, label):
         if label[0]+label[-1]!='<>':
             label = '<%s>' % (label)
-        return Pattern(label, self.pattern, optional=self.optional, flags=self._flags)
+        return Pattern(label, self.pattern, optional=self.optional, flags=self._flags, value=self.value)
 
     def __call__(self, string):
         m = self.match(string)
         if m is None: return
+        if self.value is not None: return self.value
         return m.group()
 
 # Predefined patterns
@@ -259,7 +262,7 @@
 primary = constant | name | data_ref | (r'[(]' + name + r'[)]')
 
 power_op = Pattern('<power-op>','[*]{2}')
-mult_op = Pattern('<mult-op>','[*/]')
+mult_op = Pattern('<mult-op>',r'[/*]')
 add_op = Pattern('<add-op>',r'[+-]')
 concat_op = Pattern('<concat-op>',r'[/]{2}')
 rel_op = Pattern('<rel-op>','[.]EQ[.]|[.]NE[.]|[.]LT[.]|[.]LE[.]|[.]GT[.]|[.]GE[.]|[=]{2}|/[=]|[<][=]|[<]|[>][=]|[>]',flags=re.I)
@@ -311,10 +314,17 @@
 
 intrinsic_type_name = Pattern('<intrinsic-type-name>',r'(INTEGER|REAL|COMPLEX|LOGICAL|CHARACTER|DOUBLE\s*COMPLEX|DOUBLE\s*PRECISION|BYTE)',flags=re.I)
 abs_intrinsic_type_name = abs(intrinsic_type_name)
+double_complex_name = Pattern('<double-complex-name>','DOUBLE\s*COMPLEX', flags=re.I, value='DOUBLE COMPLEX')
+double_precision_name = Pattern('<double-precision-name>','DOUBLE\s*PRECISION', flags=re.I, value='DOUBLE PRECISION')
+abs_double_complex_name = abs(double_complex_name)
+abs_double_precision_name = abs(double_precision_name)
 
 access_spec = Pattern('<access-spec>',r'PUBLIC|PRIVATE',flags=re.I)
 abs_access_spec = abs(access_spec)
 
+implicit_none = Pattern('<implicit-none>',r'IMPLICIT\s*NONE',flags=re.I, value='IMPLICIT NONE')
+abs_implicit_none = abs(implicit_none)
+
 attr_spec = Pattern('<attr-spec>',r'ALLOCATABLE|ASYNCHRONOUS|EXTERNAL|INTENT|INTRINSIC|OPTIONAL|PARAMETER|POINTER|PROTECTED|SAVE|TARGET|VALUE|VOLATILE',flags=re.I)
 abs_attr_spec = abs(attr_spec)
 

Modified: trunk/numpy/f2py/lib/parser/test_Fortran2003.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -3,8 +3,12 @@
 from Fortran2003 import *
 from api import get_reader
 
-class test_Program(NumpyTestCase):
+###############################################################################
+############################### SECTION  2 ####################################
+###############################################################################
 
+class test_Program(NumpyTestCase): # R201
+
     def check_simple(self):
         reader = get_reader('''\
       subroutine foo
@@ -14,24 +18,823 @@
       ''')
         cls = Program
         a = cls(reader)
-        print a
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'SUBROUTINE foo\nEND SUBROUTINE foo\nSUBROUTINE bar\nEND SUBROUTINE bar')
 
-class test_Declaration_Type_Spec(NumpyTestCase):
+class test_Specification_Part(NumpyTestCase): # R204
 
     def check_simple(self):
-        cls = Declaration_Type_Spec
+        from api import get_reader
+        reader = get_reader('''\
+      integer a''')
+        cls = Specification_Part
+        a = cls(reader)
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER :: a')
+        assert_equal(repr(a), "Specification_Part(Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None)))")
+
+###############################################################################
+############################### SECTION  3 ####################################
+###############################################################################
+
+class test_Name(NumpyTestCase): # R304
+
+    def check_name(self):
+        a = Name('a')
+        assert isinstance(a,Name),`a`
+        a = Name('a2')
+        assert isinstance(a,Name),`a`
+        a = Designator('a')
+        assert isinstance(a,Name),`a`
+        a = Constant('a')
+        assert isinstance(a,Name),`a`
+        a = Expr('a')
+        assert isinstance(a,Name),`a`
+
+###############################################################################
+############################### SECTION  4 ####################################
+###############################################################################
+
+class test_Type_Param_Value(NumpyTestCase): # 402
+
+    def check_type_param_value(self):
+        cls = Type_Param_Value
+        a = cls('*')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'*')
+        assert_equal(repr(a),"Type_Param_Value('*')")
+
+        a = cls(':')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),':')
+
+        a = cls('1+2')
+        assert isinstance(a,Level_2_Expr),`a`
+        assert_equal(str(a),'1 + 2')
+
+class test_Intrinsic_Type_Spec(NumpyTestCase): # R403
+
+    def check_intrinsic_type_spec(self):
+        cls = Intrinsic_Type_Spec
+        a = cls('INTEGER')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'INTEGER')
+        assert_equal(repr(a), "Intrinsic_Type_Spec('INTEGER', None)")
+
         a = cls('Integer*2')
-        assert isinstance(a, Intrinsic_Type_Spec),`a`
-        assert_equal(str(a), 'INTEGER*2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'INTEGER*2')
+
+        a = cls('real*2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'REAL*2')
+
+        a = cls('logical*2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'LOGICAL*2')
+
+        a = cls('complex*2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'COMPLEX*2')
+
+        a = cls('character*2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'CHARACTER*2')
+
+        a = cls('double complex')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'DOUBLE COMPLEX')
+
+        a = cls('double  precision')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'DOUBLE PRECISION')
+
+class test_Kind_Selector(NumpyTestCase): # R404
+
+    def check_kind_selector(self):
+        cls = Kind_Selector
+        a = cls('(1)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(KIND = 1)')
+        assert_equal(repr(a),"Kind_Selector('(', Int_Literal_Constant('1', None), ')')")
+
+        a = cls('(kind=1+2)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(KIND = 1 + 2)')
+
+        a = cls('* 1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'*1')
+
+class test_Signed_Int_Literal_Constant(NumpyTestCase): # R405
+
+    def check_int_literal_constant(self):
+        cls = Signed_Int_Literal_Constant
+        a = cls('1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1')
+        assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
+
+        a = cls('+ 21_2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+ 21_2')
+        assert_equal(repr(a),"%s('+ 21', '2')" % (cls.__name__))
+
+        a = cls('-21_SHORT')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'-21_SHORT')
+
+        a = cls('21_short')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'21_short')
+
+        a = cls('+1976354279568241_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+1976354279568241_8')
+
+class test_Int_Literal_Constant(NumpyTestCase): # R406
+
+    def check_int_literal_constant(self):
+        cls = Int_Literal_Constant
+        a = cls('1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1')
+        assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
+
+        a = cls('21_2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'21_2')
+        assert_equal(repr(a),"%s('21', '2')" % (cls.__name__))
+
+        a = cls('21_SHORT')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'21_SHORT')
+
+        a = cls('21_short')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'21_short')
+
+        a = cls('1976354279568241_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1976354279568241_8')
+
+class test_Binary_Constant(NumpyTestCase): # R412
+
+    def check_boz_literal_constant(self):
+        cls = Boz_Literal_Constant
+        bcls = Binary_Constant
+        a = cls('B"01"')
+        assert isinstance(a,bcls),`a`
+        assert_equal(str(a),'B"01"')
+        assert_equal(repr(a),"%s('B\"01\"')" % (bcls.__name__))
+
+class test_Octal_Constant(NumpyTestCase): # R413
+
+    def check_boz_literal_constant(self):
+        cls = Boz_Literal_Constant
+        ocls = Octal_Constant
+        a = cls('O"017"')
+        assert isinstance(a,ocls),`a`
+        assert_equal(str(a),'O"017"')
+        assert_equal(repr(a),"%s('O\"017\"')" % (ocls.__name__))
+
+class test_Hex_Constant(NumpyTestCase): # R414
+
+    def check_boz_literal_constant(self):
+        cls = Boz_Literal_Constant
+        zcls = Hex_Constant
+        a = cls('Z"01A"')
+        assert isinstance(a,zcls),`a`
+        assert_equal(str(a),'Z"01A"')
+        assert_equal(repr(a),"%s('Z\"01A\"')" % (zcls.__name__))
+
+class test_Signed_Real_Literal_Constant(NumpyTestCase): # R416
+
+    def check_signed_real_literal_constant(self):
+        cls = Signed_Real_Literal_Constant
+        a = cls('12.78')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'12.78')
+        assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
+
+        a = cls('+12.78_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+12.78_8')
+        assert_equal(repr(a),"%s('+12.78', '8')" % (cls.__name__))
+
+        a = cls('- 12.')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'- 12.')
+
+        a = cls('1.6E3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E3')
+
+        a = cls('+1.6E3_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+1.6E3_8')
+
+        a = cls('1.6D3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6D3')
+
+        a = cls('-1.6E-3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'-1.6E-3')
+        a = cls('1.6E+3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E+3')
+
+        a = cls('3E4')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'3E4')
+
+        a = cls('.123')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.123')
+
+        a = cls('+1.6E-3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+1.6E-3')
+
+        a = cls('10.9E7_QUAD')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'10.9E7_QUAD')
+
+        a = cls('-10.9e-17_quad')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'-10.9E-17_quad')
+
+class test_Real_Literal_Constant(NumpyTestCase): # R417
+
+    def check_real_literal_constant(self):
+        cls = Real_Literal_Constant
+        a = cls('12.78')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'12.78')
+        assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
+
+        a = cls('12.78_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'12.78_8')
+        assert_equal(repr(a),"%s('12.78', '8')" % (cls.__name__))
+
+        a = cls('12.')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'12.')
+
+        a = cls('1.6E3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E3')
+
+        a = cls('1.6E3_8')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E3_8')
+
+        a = cls('1.6D3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6D3')
+
+        a = cls('1.6E-3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E-3')
+        a = cls('1.6E+3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E+3')
+
+        a = cls('3E4')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'3E4')
+
+        a = cls('.123')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.123')
+
+        a = cls('1.6E-3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'1.6E-3')
+
+        a = cls('10.9E7_QUAD')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'10.9E7_QUAD')
+
+        a = cls('10.9e-17_quad')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'10.9E-17_quad')
+
+        a = cls('0.0D+0')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'0.0D+0')
         
-        a = cls('type(foo)')
+class test_Char_Selector(NumpyTestCase): # R424
+
+    def check_char_selector(self):
+        cls = Char_Selector
+        a = cls('(len=2, kind=8)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(LEN = 2, KIND = 8)')
+        assert_equal(repr(a),"Char_Selector(Int_Literal_Constant('2', None), Int_Literal_Constant('8', None))")
+
+
+        a = cls('(2, kind=8)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(LEN = 2, KIND = 8)')
+
+        a = cls('(2, 8)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(LEN = 2, KIND = 8)')
+        
+        a = cls('(kind=8)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(KIND = 8)')
+
+        a = cls('(kind=8,len=2)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(LEN = 2, KIND = 8)')
+
+class test_Complex_Literal_Constant(NumpyTestCase): # R421
+
+    def check_complex_literal_constant(self):
+        cls = Complex_Literal_Constant
+        a = cls('(1.0, -1.0)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(1.0, -1.0)')
+        assert_equal(repr(a),"Complex_Literal_Constant(Signed_Real_Literal_Constant('1.0', None), Signed_Real_Literal_Constant('-1.0', None))")
+
+        a = cls('(3,3.1E6)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(3, 3.1E6)')
+
+        a = cls('(4.0_4, 3.6E7_8)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(4.0_4, 3.6E7_8)')
+
+        a = cls('( 0., PI)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(0., PI)')
+
+
+class test_Type_Name(NumpyTestCase): # C424
+
+    def check_simple(self):
+        cls = Type_Name
+        a = cls('a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a')
+        assert_equal(repr(a),"Type_Name('a')")
+
+        self.assertRaises(NoMatchError,cls,'integer')
+        self.assertRaises(NoMatchError,cls,'doubleprecision')
+
+class test_Length_Selector(NumpyTestCase): # R425
+
+    def check_length_selector(self):
+        cls = Length_Selector
+        a = cls('( len = *)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(LEN = *)')
+        assert_equal(repr(a),"Length_Selector('(', Type_Param_Value('*'), ')')")
+
+        a = cls('*2,')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'*2')
+
+class test_Char_Length(NumpyTestCase): # R426
+
+    def check_char_length(self):
+        cls = Char_Length
+        a = cls('(1)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(1)')
+        assert_equal(repr(a),"Char_Length('(', Int_Literal_Constant('1', None), ')')")
+
+        a = cls('1')
+        assert isinstance(a,Int_Literal_Constant),`a`
+        assert_equal(str(a),'1')
+
+        a = cls('(*)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(*)')
+
+        a = cls('(:)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(:)')
+
+class test_Char_Literal_Constant(NumpyTestCase): # R427
+
+    def check_char_literal_constant(self):
+        cls = Char_Literal_Constant
+        a = cls('NIH_"DO"')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'NIH_"DO"')
+        assert_equal(repr(a),'Char_Literal_Constant(\'"DO"\', \'NIH\')')
+
+        a = cls("'DO'")
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),"'DO'")
+        assert_equal(repr(a),'Char_Literal_Constant("\'DO\'", None)')
+
+        a = cls("'DON''T'")
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),"'DON''T'")
+
+        a = cls('"DON\'T"')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'"DON\'T"')
+
+        a = cls('""')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'""')
+
+        a = cls("''")
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),"''")
+
+        a = cls('"hey ha(ada)\t"')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'"hey ha(ada)\t"')
+
+class test_Logical_Literal_Constant(NumpyTestCase): # R428
+
+    def check_logical_literal_constant(self):
+        cls = Logical_Literal_Constant
+        a = cls('.TRUE.')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.TRUE.')
+        assert_equal(repr(a),"%s('.TRUE.', None)" % (cls.__name__))
+
+        a = cls('.True.')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.TRUE.')
+
+        a = cls('.FALSE.')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.FALSE.')
+
+        a = cls('.TRUE._HA')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.TRUE._HA')
+
+class test_Derived_Type_Stmt(NumpyTestCase): # R430
+
+    def check_simple(self):
+        cls = Derived_Type_Stmt
+        a = cls('type a')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'TYPE(foo)')
-        assert_equal(repr(a), "Declaration_Type_Spec('TYPE', Type_Name('foo'))")
+        assert_equal(str(a),'TYPE :: a')
+        assert_equal(repr(a),"Derived_Type_Stmt(None, Type_Name('a'), None)")
 
-class test_Type_Declaration_Stmt(NumpyTestCase):
+        a = cls('type ::a(b,c)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'TYPE :: a(b, c)')
 
+        a = cls('type, private, abstract::a(b,c)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'TYPE, PRIVATE, ABSTRACT :: a(b, c)')
+
+class test_Type_Name(NumpyTestCase): # C423
+
     def check_simple(self):
+        cls = Type_Name
+        a = cls('a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a')
+        assert_equal(repr(a),"Type_Name('a')")
+
+class test_Type_Attr_Spec(NumpyTestCase): # R431
+
+    def check_simple(self):
+        cls = Type_Attr_Spec
+        a = cls('abstract')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'ABSTRACT')
+        assert_equal(repr(a),"Type_Attr_Spec('ABSTRACT', None)")
+
+        a = cls('bind (c )')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'BIND(C)')
+
+        a = cls('extends(a)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'EXTENDS(a)')
+
+        a = cls('private')
+        assert isinstance(a, Access_Spec),`a`
+        assert_equal(str(a),'PRIVATE')
+
+
+class test_End_Type_Stmt(NumpyTestCase): # R433
+
+    def check_simple(self):
+        cls = End_Type_Stmt
+        a = cls('end type')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END TYPE')
+        assert_equal(repr(a),"End_Type_Stmt('TYPE', None)")
+
+        a = cls('end type  a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END TYPE a')
+
+class test_Sequence_Stmt(NumpyTestCase): # R434
+
+    def check_simple(self):
+        cls = Sequence_Stmt
+        a = cls('sequence')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'SEQUENCE')
+        assert_equal(repr(a),"Sequence_Stmt('SEQUENCE')")
+
+class test_Type_Param_Def_Stmt(NumpyTestCase): # R435
+
+    def check_simple(self):
+        cls = Type_Param_Def_Stmt
+        a = cls('integer ,kind :: a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER, KIND :: a')
+        assert_equal(repr(a),"Type_Param_Def_Stmt(None, Type_Param_Attr_Spec('KIND'), Name('a'))")
+
+        a = cls('integer*2 ,len :: a=3, b=2+c')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER*2, LEN :: a = 3, b = 2 + c')
+
+class test_Type_Param_Decl(NumpyTestCase): # R436
+
+    def check_simple(self):
+        cls = Type_Param_Decl
+        a = cls('a=2')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a = 2')
+        assert_equal(repr(a),"Type_Param_Decl(Name('a'), '=', Int_Literal_Constant('2', None))")
+
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Type_Param_Attr_Spec(NumpyTestCase): # R437
+
+    def check_simple(self):
+        cls = Type_Param_Attr_Spec
+        a = cls('kind')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'KIND')
+        assert_equal(repr(a),"Type_Param_Attr_Spec('KIND')")
+
+        a = cls('len')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'LEN')
+
+class test_Component_Attr_Spec(NumpyTestCase): # R441
+
+    def check_simple(self):
+        cls = Component_Attr_Spec
+        a = cls('pointer')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'POINTER')
+        assert_equal(repr(a),"Component_Attr_Spec('POINTER')")
+
+        a = cls('allocatable')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'ALLOCATABLE')
+
+        a = cls('dimension(a)')
+        assert isinstance(a, Dimension_Component_Attr_Spec),`a`
+        assert_equal(str(a),'DIMENSION(a)')
+
+        a = cls('private')
+        assert isinstance(a, Access_Spec),`a`
+        assert_equal(str(a),'PRIVATE')
+
+class test_Component_Decl(NumpyTestCase): # R442
+
+    def check_simple(self):
+        cls = Component_Decl
+        a = cls('a(1)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)')
+        assert_equal(repr(a),"Component_Decl(Name('a'), Explicit_Shape_Spec(None, Int_Literal_Constant('1', None)), None, None)")
+
+        a = cls('a(1)*(3)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3)')
+
+        a = cls('a(1)*(3) = 2')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3) = 2')
+
+        a = cls('a(1) => NULL')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1) => NULL')
+
+class test_Derived_Type_Spec(NumpyTestCase): # R455
+
+    def check_simple(self):
+        cls = Derived_Type_Spec
+        a = cls('a(b)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a(b)')
+        assert_equal(repr(a),"Derived_Type_Spec(Type_Name('a'), Name('b'))")
+
+        a = cls('a(b,c,g=1)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a(b, c, g = 1)')
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+        a = cls('a()')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a()')
+
+class test_Type_Param_Spec(NumpyTestCase): # R456
+
+    def check_type_param_spec(self):
+        cls = Type_Param_Spec
+        a = cls('a=1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a = 1')
+        assert_equal(repr(a),"Type_Param_Spec(Name('a'), Int_Literal_Constant('1', None))")
+
+        a = cls('k=a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a')
+
+        a = cls('k=:')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = :')
+
+class test_Type_Param_Spec_List(NumpyTestCase): # R456-list
+
+    def check_type_param_spec_list(self):
+        cls = Type_Param_Spec_List
+
+        a = cls('a,b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a, b')
+        assert_equal(repr(a),"Type_Param_Spec_List(',', (Name('a'), Name('b')))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+
+        a = cls('k=a,c,g=1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a, c, g = 1')
+
+class test_Structure_Constructor_2(NumpyTestCase): # R457.b
+
+    def check_simple(self):
+        cls = Structure_Constructor_2
+        a = cls('k=a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a')
+        assert_equal(repr(a),"Structure_Constructor_2(Name('k'), Name('a'))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Structure_Constructor(NumpyTestCase): # R457
+
+    def check_structure_constructor(self):
+        cls = Structure_Constructor
+        a = cls('t()')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'t()')
+        assert_equal(repr(a),"Structure_Constructor(Type_Name('t'), None)")
+
+        a = cls('t(s=1, a)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'t(s = 1, a)')
+
+        a = cls('a=k')
+        assert isinstance(a,Structure_Constructor_2),`a`
+        assert_equal(str(a),'a = k')
+        assert_equal(repr(a),"Structure_Constructor_2(Name('a'), Name('k'))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+    
+class test_Component_Spec(NumpyTestCase): # R458
+
+    def check_simple(self):
+        cls = Component_Spec
+        a = cls('k=a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a')
+        assert_equal(repr(a),"Component_Spec(Name('k'), Name('a'))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+        a = cls('a % b')
+        assert isinstance(a, Proc_Component_Ref),`a`
+        assert_equal(str(a),'a % b')
+
+        a = cls('s =a % b')
+        assert isinstance(a, Component_Spec),`a`
+        assert_equal(str(a),'s = a % b')
+
+class test_Component_Spec_List(NumpyTestCase): # R458-list
+
+    def check_simple(self):
+        cls = Component_Spec_List
+        a = cls('k=a, b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a, b')
+        assert_equal(repr(a),"Component_Spec_List(',', (Component_Spec(Name('k'), Name('a')), Name('b')))")
+
+        a = cls('k=a, c')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a, c')
+
+class test_Array_Constructor(NumpyTestCase): # R465
+
+    def check_simple(self):
+        cls = Array_Constructor
+        a = cls('(/a/)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(/a/)')
+        assert_equal(repr(a),"Array_Constructor('(/', Name('a'), '/)')")
+
+        a = cls('[a]')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'[a]')
+        assert_equal(repr(a),"Array_Constructor('[', Name('a'), ']')")
+
+        a = cls('[integer::a]')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'[INTEGER :: a]')
+
+        a = cls('[integer::a,b]')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'[INTEGER :: a, b]')
+
+class test_Ac_Spec(NumpyTestCase): # R466
+
+    def check_ac_spec(self):
+        cls = Ac_Spec
+        a = cls('integer ::')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'INTEGER ::')
+        assert_equal(repr(a),"Ac_Spec(Intrinsic_Type_Spec('INTEGER', None), None)")
+
+        a = cls('integer :: a,b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'INTEGER :: a, b')
+
+        a = cls('a,b')
+        assert isinstance(a,Ac_Value_List),`a`
+        assert_equal(str(a),'a, b')
+
+        a = cls('integer :: a, (a, b, n = 1, 5)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'INTEGER :: a, (a, b, n = 1, 5)')
+
+class test_Ac_Value_List(NumpyTestCase): # R469-list
+
+    def check_ac_value_list(self):
+        cls = Ac_Value_List
+        a = cls('a, b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a, b')
+        assert_equal(repr(a),"Ac_Value_List(',', (Name('a'), Name('b')))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Ac_Implied_Do(NumpyTestCase): # R470
+    
+    def check_ac_implied_do(self):
+        cls = Ac_Implied_Do
+        a = cls('( a, b, n = 1, 5 )')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(a, b, n = 1, 5)')
+        assert_equal(repr(a),"Ac_Implied_Do(Ac_Value_List(',', (Name('a'), Name('b'))), Ac_Implied_Do_Control(Name('n'), [Int_Literal_Constant('1', None), Int_Literal_Constant('5', None)]))")
+
+class test_Ac_Implied_Do_Control(NumpyTestCase): # R471
+
+    def check_ac_implied_do_control(self):
+        cls = Ac_Implied_Do_Control
+        a = cls('n = 3, 5')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'n = 3, 5')
+        assert_equal(repr(a),"Ac_Implied_Do_Control(Name('n'), [Int_Literal_Constant('3', None), Int_Literal_Constant('5', None)])")
+
+        a = cls('n = 3+1, 5, 1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'n = 3 + 1, 5, 1')
+
+###############################################################################
+############################### SECTION  5 ####################################
+###############################################################################
+
+class test_Type_Declaration_Stmt(NumpyTestCase): # R501
+
+    def check_simple(self):
         cls = Type_Declaration_Stmt
         a = cls('integer a')
         assert isinstance(a, cls),`a`
@@ -42,22 +845,33 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a), 'INTEGER, DIMENSION(2) :: a*3')
 
-class test_Access_Spec(NumpyTestCase):
+        a = cls('real a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'REAL :: a')
+        assert_equal(repr(a), "Type_Declaration_Stmt(Intrinsic_Type_Spec('REAL', None), None, Entity_Decl(Name('a'), None, None, None))")
 
-    def check_simple(self):
-        cls = Access_Spec
-        a = cls('private')
+        a = cls('REAL A( LDA, * ), B( LDB, * )')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'PRIVATE')
-        assert_equal(repr(a), "Access_Spec('PRIVATE')")
 
-        a = cls('public')
+        a = cls('DOUBLE PRECISION   ALPHA, BETA')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'PUBLIC')
 
-class test_Attr_Spec(NumpyTestCase):
+class test_Declaration_Type_Spec(NumpyTestCase): # R502
 
     def check_simple(self):
+        cls = Declaration_Type_Spec
+        a = cls('Integer*2')
+        assert isinstance(a, Intrinsic_Type_Spec),`a`
+        assert_equal(str(a), 'INTEGER*2')
+        
+        a = cls('type(foo)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a), 'TYPE(foo)')
+        assert_equal(repr(a), "Declaration_Type_Spec('TYPE', Type_Name('foo'))")
+
+class test_Attr_Spec(NumpyTestCase): # R503
+
+    def check_simple(self):
         cls = Attr_Spec
         a = cls('allocatable')
         assert isinstance(a, cls),`a`
@@ -67,16 +881,16 @@
         assert isinstance(a, Dimension_Attr_Spec),`a`
         assert_equal(str(a),'DIMENSION(a)')
 
-class test_Dimension_Attr_Spec(NumpyTestCase):
+class test_Dimension_Attr_Spec(NumpyTestCase): # R503.d
 
     def check_simple(self):
         cls = Dimension_Attr_Spec
         a = cls('dimension(a)')
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'DIMENSION(a)')
-        assert_equal(repr(a),"Dimension_Attr_Spec('DIMENSION', Name('a'))")
+        assert_equal(repr(a),"Dimension_Attr_Spec('DIMENSION', Explicit_Shape_Spec(None, Name('a')))")
 
-class test_Intent_Attr_Spec(NumpyTestCase):
+class test_Intent_Attr_Spec(NumpyTestCase): # R503.f
 
     def check_simple(self):
         cls = Intent_Attr_Spec
@@ -85,9 +899,39 @@
         assert_equal(str(a),'INTENT(IN)')
         assert_equal(repr(a),"Intent_Attr_Spec('INTENT', Intent_Spec('IN'))")
 
-class test_Language_Binding_Spec(NumpyTestCase):
+class test_Entity_Decl(NumpyTestCase): # 504
 
     def check_simple(self):
+        cls = Entity_Decl
+        a = cls('a(1)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)')
+        assert_equal(repr(a),"Entity_Decl(Name('a'), Explicit_Shape_Spec(None, Int_Literal_Constant('1', None)), None, None)")
+
+        a = cls('a(1)*(3)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3)')
+
+        a = cls('a(1)*(3) = 2')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(1)*(3) = 2')
+
+class test_Access_Spec(NumpyTestCase): # R508
+
+    def check_simple(self):
+        cls = Access_Spec
+        a = cls('private')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PRIVATE')
+        assert_equal(repr(a),"Access_Spec('PRIVATE')")
+
+        a = cls('public')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PUBLIC')
+
+class test_Language_Binding_Spec(NumpyTestCase): # R509
+
+    def check_simple(self):
         cls = Language_Binding_Spec
         a = cls('bind(c)')
         assert isinstance(a, cls),`a`
@@ -98,26 +942,955 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'BIND(C, NAME = "hey")')
 
-class test_Entity_Decl(NumpyTestCase):
+class test_Explicit_Shape_Spec(NumpyTestCase): # R511
 
     def check_simple(self):
-        cls = Entity_Decl
-        a = cls('a(1)')
+        cls = Explicit_Shape_Spec
+        a = cls('a:b')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)')
-        assert_equal(repr(a),"Entity_Decl(Name('a'), Int_Literal_Constant('1', None), None, None)")
+        assert_equal(str(a),'a : b')
+        assert_equal(repr(a),"Explicit_Shape_Spec(Name('a'), Name('b'))")
 
-        a = cls('a(1)*(3)')
+        a = cls('a')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)*(3)')
+        assert_equal(str(a),'a')
 
-        a = cls('a(1)*(3) = 2')
+class test_Upper_Bound(NumpyTestCase): # R513
+    
+    def check_simple(self):
+        cls = Upper_Bound
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+        self.assertRaises(NoMatchError,cls,'*')
+
+class test_Assumed_Shape_Spec(NumpyTestCase): # R514
+
+    def check_simple(self):
+        cls = Assumed_Shape_Spec
+        a = cls(':')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)*(3) = 2')
+        assert_equal(str(a),':')
+        assert_equal(repr(a),'Assumed_Shape_Spec(None, None)')
 
-class test_Prefix_Spec(NumpyTestCase):
+        a = cls('a :')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a :')
 
+class test_Deferred_Shape_Spec(NumpyTestCase): # R515
+
     def check_simple(self):
+        cls = Deferred_Shape_Spec
+        a = cls(':')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),':')
+        assert_equal(repr(a),'Deferred_Shape_Spec(None, None)')
+
+
+class test_Assumed_Size_Spec(NumpyTestCase): # R516
+
+    def check_simple(self):
+        cls = Assumed_Size_Spec
+        a = cls('*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'*')
+        assert_equal(repr(a),'Assumed_Size_Spec(None, None)')
+
+        a = cls('1:*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'1 : *')
+
+        a = cls('a,1:*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a, 1 : *')
+
+        a = cls('a:b,1:*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a : b, 1 : *')
+
+
+class test_Parameter_Stmt(NumpyTestCase): # R538
+
+    def check_simple(self):
+        cls = Parameter_Stmt
+        a = cls('parameter(a=1)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PARAMETER(a = 1)')
+        assert_equal(repr(a),"Parameter_Stmt('PARAMETER', Named_Constant_Def(Name('a'), Int_Literal_Constant('1', None)))")
+
+        a = cls('parameter(a=1, b=a+2)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PARAMETER(a = 1, b = a + 2)')
+
+        a = cls('PARAMETER        ( ONE = 1.0D+0, ZERO = 0.0D+0 )')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PARAMETER(ONE = 1.0D+0, ZERO = 0.0D+0)')
+        
+class test_Named_Constant_Def(NumpyTestCase): # R539
+
+    def check_simple(self):
+        cls = Named_Constant_Def
+        a = cls('a=1')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a = 1')
+        assert_equal(repr(a),"Named_Constant_Def(Name('a'), Int_Literal_Constant('1', None))")
+
+class test_Pointer_Decl(NumpyTestCase): # R541
+
+    def check_simple(self):
+        cls = Pointer_Decl
+        a = cls('a(:)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(:)')
+        assert_equal(repr(a),"Pointer_Decl(Name('a'), Deferred_Shape_Spec(None, None))")
+
+        a = cls('a(:,:)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(:, :)')
+
+class test_Implicit_Stmt(NumpyTestCase): # R549
+
+    def check_simple(self):
+        cls = Implicit_Stmt
+        a = cls('implicitnone')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'IMPLICIT NONE')
+        assert_equal(repr(a),"Implicit_Stmt('IMPLICIT NONE', None)")
+
+        a = cls('implicit real(a-d), double precision(r-t,x), type(a) (y-z)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'IMPLICIT REAL(A - D), DOUBLE PRECISION(R - T, X), TYPE(a)(Y - Z)')
+
+class test_Implicit_Spec(NumpyTestCase): # R550
+
+    def check_simple(self):
+        cls = Implicit_Spec
+        a = cls('integer (a-z)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER(A - Z)')
+        assert_equal(repr(a),"Implicit_Spec(Intrinsic_Type_Spec('INTEGER', None), Letter_Spec('A', 'Z'))")
+
+        a = cls('double  complex (r,d-g)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'DOUBLE COMPLEX(R, D - G)')
+
+class test_Letter_Spec(NumpyTestCase): # R551
+
+    def check_simple(self):
+        cls = Letter_Spec
+        a = cls('a-z')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'A - Z')
+        assert_equal(repr(a),"Letter_Spec('A', 'Z')")
+
+        a = cls('d')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'D')
+
+class test_Equivalence_Stmt(NumpyTestCase): # R554
+
+    def check_simple(self):
+        cls = Equivalence_Stmt
+        a = cls('equivalence (a, b ,z)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'EQUIVALENCE(a, b, z)')
+        assert_equal(repr(a),"Equivalence_Stmt('EQUIVALENCE', Equivalence_Set(Name('a'), Equivalence_Object_List(',', (Name('b'), Name('z')))))")
+
+        a = cls('equivalence (a, b ,z),(b,l)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'EQUIVALENCE(a, b, z), (b, l)')
+
+class test_Common_Stmt(NumpyTestCase): # R557
+
+    def check_simple(self):
+        cls = Common_Stmt
+        a = cls('common a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'COMMON // a')
+        assert_equal(repr(a),"Common_Stmt([(None, Name('a'))])")
+
+        a = cls('common // a,b')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'COMMON // a, b')
+
+        a = cls('common /name/ a,b')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'COMMON /name/ a, b')
+
+        a = cls('common /name/ a,b(4,5) // c, /ljuks/ g(2)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'COMMON /name/ a, b(4, 5) // c /ljuks/ g(2)')
+
+class test_Common_Block_Object(NumpyTestCase): # R558
+
+    def check_simple(self):
+        cls = Common_Block_Object
+        a = cls('a(2)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(2)')
+        assert_equal(repr(a),"Common_Block_Object(Name('a'), Explicit_Shape_Spec(None, Int_Literal_Constant('2', None)))")
+
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+
+###############################################################################
+############################### SECTION  6 ####################################
+###############################################################################
+
+class test_Substring(NumpyTestCase): # R609
+    
+    def check_simple(self):
+        cls = Substring
+        a = cls('a(:)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(:)')
+        assert_equal(repr(a),"Substring(Name('a'), Substring_Range(None, None))")
+
+        a = cls('a(1:2)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a(1 : 2)')
+        assert_equal(repr(a),"Substring(Name('a'), Substring_Range(Int_Literal_Constant('1', None), Int_Literal_Constant('2', None)))")
+
+
+class test_Substring_Range(NumpyTestCase): # R611
+    
+    def check_simple(self):
+        cls = Substring_Range
+        a = cls(':')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),':')
+        assert_equal(repr(a),"Substring_Range(None, None)")
+
+        a = cls('a+1:')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a + 1 :')
+
+        a = cls('a+1: c/foo(g)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a + 1 : c / foo(g)')
+
+        a = cls('a:b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a : b')
+        assert_equal(repr(a),"Substring_Range(Name('a'), Name('b'))")
+
+        a = cls('a:')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a :')
+
+        a = cls(':b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),': b')
+
+
+class test_Data_Ref(NumpyTestCase): # R612
+
+    def check_data_ref(self):
+        cls = Data_Ref
+        a = cls('a%b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a % b')
+        assert_equal(repr(a),"Data_Ref('%', (Name('a'), Name('b')))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Part_Ref(NumpyTestCase): # R613
+
+    def check_part_ref(self):
+        cls = Part_Ref
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Type_Param_Inquiry(NumpyTestCase): # R615
+    
+    def check_simple(self):
+        cls = Type_Param_Inquiry
+        a = cls('a % b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a % b')
+        assert_equal(repr(a),"Type_Param_Inquiry(Name('a'), '%', Name('b'))")
+
+
+class test_Array_Section(NumpyTestCase): # R617
+
+    def check_array_section(self):
+        cls = Array_Section
+        a = cls('a(:)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a(:)')
+        assert_equal(repr(a),"Array_Section(Name('a'), Substring_Range(None, None))")
+
+        a = cls('a(2:)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a(2 :)')
+
+
+class test_Section_Subscript(NumpyTestCase): # R619
+
+    def check_simple(self):
+        cls = Section_Subscript
+
+        a = cls('1:2')
+        assert isinstance(a, Subscript_Triplet),`a`
+        assert_equal(str(a),'1 : 2')
+
+        a = cls('zzz')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'zzz')
+        
+class test_Section_Subscript_List(NumpyTestCase): # R619-list
+
+    def check_simple(self):
+        cls = Section_Subscript_List
+        a = cls('a,2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a, 2')
+        assert_equal(repr(a),"Section_Subscript_List(',', (Name('a'), Int_Literal_Constant('2', None)))")
+
+        a = cls('::1')
+        assert isinstance(a,Subscript_Triplet),`a`
+        assert_equal(str(a),': : 1')
+
+        a = cls('::1, 3')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),': : 1, 3')
+
+class test_Subscript_Triplet(NumpyTestCase): # R620
+
+    def check_simple(self):
+        cls = Subscript_Triplet
+        a = cls('a:b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a : b')
+        assert_equal(repr(a),"Subscript_Triplet(Name('a'), Name('b'), None)")
+
+        a = cls('a:b:1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a : b : 1')
+
+        a = cls(':')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),':')
+
+        a = cls('::5')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),': : 5')
+
+        a = cls(':5')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),': 5')
+
+        a = cls('a+1 :')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a + 1 :')
+
+class test_Alloc_Opt(NumpyTestCase): # R624
+    
+    def check_simple(self):
+        cls = Alloc_Opt
+        a = cls('stat=a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'STAT = a')
+        assert_equal(repr(a),"Alloc_Opt('STAT', Name('a'))")
+
+class test_Nullify_Stmt(NumpyTestCase): # R633
+    
+    def check_simple(self):
+        cls = Nullify_Stmt
+        a = cls('nullify (a)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'NULLIFY(a)')
+        assert_equal(repr(a),"Nullify_Stmt('NULLIFY', Name('a'))")
+
+        a = cls('nullify (a,c)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'NULLIFY(a, c)')
+
+###############################################################################
+############################### SECTION  7 ####################################
+###############################################################################
+
+class test_Primary(NumpyTestCase): # R701
+
+    def check_simple(self):
+        cls = Primary
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+        a = cls('(a)')
+        assert isinstance(a,Parenthesis),`a`
+        assert_equal(str(a),'(a)')
+
+        a = cls('1')
+        assert isinstance(a,Int_Literal_Constant),`a`
+        assert_equal(str(a),'1')
+
+        a = cls('1.')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'1.')
+
+        a = cls('(1, n)')
+        assert isinstance(a,Complex_Literal_Constant),`a`
+        assert_equal(str(a),'(1, n)')
+
+        a = cls('.true.')
+        assert isinstance(a,Logical_Literal_Constant),`a`
+        assert_equal(str(a),'.TRUE.')
+
+        a = cls('"hey a()c"')
+        assert isinstance(a,Char_Literal_Constant),`a`
+        assert_equal(str(a),'"hey a()c"')
+
+        a = cls('b"0101"')
+        assert isinstance(a,Binary_Constant),`a`
+        assert_equal(str(a),'B"0101"')
+
+        a = cls('o"0107"')
+        assert isinstance(a,Octal_Constant),`a`
+        assert_equal(str(a),'O"0107"')
+
+        a = cls('z"a107"')
+        assert isinstance(a,Hex_Constant),`a`
+        assert_equal(str(a),'Z"A107"')
+
+        a = cls('a % b')
+        assert isinstance(a,Data_Ref),`a`
+        assert_equal(str(a),'a % b')
+
+        a = cls('a(:)')
+        assert isinstance(a,Array_Section),`a`
+        assert_equal(str(a),'a(:)')
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+class test_Parenthesis(NumpyTestCase): # R701.h
+
+    def check_simple(self):
+        cls = Parenthesis
+        a  = cls('(a)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(a)')
+        assert_equal(repr(a),"Parenthesis('(', Name('a'), ')')")
+
+        a  = cls('(a+1)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(a + 1)')
+
+        a  = cls('((a))')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'((a))')
+
+        a  = cls('(a+(a+c))')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(a + (a + c))')
+
+class test_Level_1_Expr(NumpyTestCase): # R702
+
+    def check_simple(self):
+        cls = Level_1_Expr
+        a = cls('.hey. a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.HEY. a')
+        assert_equal(repr(a),"Level_1_Expr('.HEY.', Name('a'))")
+
+        self.assertRaises(NoMatchError,cls,'.not. a')
+
+class test_Mult_Operand(NumpyTestCase): # R704
+
+    def check_simple(self):
+        cls = Mult_Operand
+        a = cls('a**b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a ** b')
+        assert_equal(repr(a),"Mult_Operand(Name('a'), '**', Name('b'))")
+
+        a = cls('a**2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a ** 2')
+
+        a = cls('(a+b)**2')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'(a + b) ** 2')
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+class test_Add_Operand(NumpyTestCase): # R705
+
+    def check_simple(self):
+        cls = Add_Operand
+        a = cls('a*b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a * b')
+        assert_equal(repr(a),"Add_Operand(Name('a'), '*', Name('b'))")
+
+        a = cls('a/b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a / b')
+
+        a = cls('a**b')
+        assert isinstance(a,Mult_Operand),`a`
+        assert_equal(str(a),'a ** b')
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+class test_Level_2_Expr(NumpyTestCase): # R706
+
+    def check_simple(self):
+        cls = Level_2_Expr
+        a = cls('a+b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a + b')
+        assert_equal(repr(a),"Level_2_Expr(Name('a'), '+', Name('b'))")
+
+        a = cls('a-b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a - b')
+
+        a = cls('a+b+c')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a + b + c')
+
+        a = cls('+a')
+        assert isinstance(a,Level_2_Unary_Expr),`a`
+        assert_equal(str(a),'+ a')
+
+        a = cls('+1')
+        assert isinstance(a,Level_2_Unary_Expr),`a`
+        assert_equal(str(a),'+ 1')
+
+        a = cls('+a+b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+ a + b')
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+
+class test_Level_2_Unary_Expr(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Level_2_Unary_Expr
+        a = cls('+a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+ a')
+        assert_equal(repr(a),"Level_2_Unary_Expr('+', Name('a'))")
+
+        a = cls('-a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'- a')
+
+        a = cls('+1')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'+ 1')
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+
+class test_Level_3_Expr(NumpyTestCase): # R710
+
+    def check_simple(self):
+        cls = Level_3_Expr
+        a = cls('a//b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a // b')
+        assert_equal(repr(a),"Level_3_Expr(Name('a'), '//', Name('b'))")
+
+        a = cls('"a"//"b"')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'"a" // "b"')
+
+class test_Level_4_Expr(NumpyTestCase): # R712
+
+    def check_simple(self):
+        cls = Level_4_Expr
+        a = cls('a.eq.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .EQ. b')
+        assert_equal(repr(a),"Level_4_Expr(Name('a'), '.EQ.', Name('b'))")
+
+        a = cls('a.ne.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .NE. b')
+
+        a = cls('a.lt.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .LT. b')
+
+        a = cls('a.gt.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .GT. b')
+
+        a = cls('a.ge.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .GE. b')
+
+        a = cls('a==b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a == b')
+
+        a = cls('a/=b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a /= b')
+
+        a = cls('a<b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a < b')
+
+        a = cls('a<=b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a <= b')
+
+        a = cls('a>=b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a >= b')
+
+        a = cls('a>b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a > b')
+
+class test_And_Operand(NumpyTestCase): # R714
+
+    def check_simple(self):
+        cls = And_Operand
+        a = cls('.not.a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'.NOT. a')
+        assert_equal(repr(a),"And_Operand('.NOT.', Name('a'))")
+
+class test_Or_Operand(NumpyTestCase): # R715
+
+    def check_simple(self):
+        cls = Or_Operand
+        a = cls('a.and.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .AND. b')
+        assert_equal(repr(a),"Or_Operand(Name('a'), '.AND.', Name('b'))")
+
+
+class test_Equiv_Operand(NumpyTestCase): # R716
+
+    def check_simple(self):
+        cls = Equiv_Operand
+        a = cls('a.or.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .OR. b')
+        assert_equal(repr(a),"Equiv_Operand(Name('a'), '.OR.', Name('b'))")
+
+
+class test_Level_5_Expr(NumpyTestCase): # R717
+
+    def check_simple(self):
+        cls = Level_5_Expr
+        a = cls('a.eqv.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .EQV. b')
+        assert_equal(repr(a),"Level_5_Expr(Name('a'), '.EQV.', Name('b'))")
+
+        a = cls('a.neqv.b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .NEQV. b')
+
+        a = cls('a.eq.b')
+        assert isinstance(a,Level_4_Expr),`a`
+        assert_equal(str(a),'a .EQ. b')
+
+class test_Expr(NumpyTestCase): # R722
+
+    def check_simple(self):
+        cls = Expr
+        a = cls('a .op. b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a .OP. b')
+        assert_equal(repr(a),"Expr(Name('a'), '.OP.', Name('b'))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+        a = cls('3.e2')
+        assert isinstance(a,Real_Literal_Constant),`a`
+
+        a = cls('0.0E-1')
+        assert isinstance(a,Real_Literal_Constant),`a`
+        assert_equal(str(a),'0.0E-1')
+
+        self.assertRaises(NoMatchError,Scalar_Int_Expr,'a,b')
+
+class test_Assignment_Stmt(NumpyTestCase): # R734
+    
+    def check_simple(self):
+        cls = Assignment_Stmt
+        a = cls('a = b')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a = b')
+        assert_equal(repr(a),"Assignment_Stmt(Name('a'), '=', Name('b'))")
+
+        a = cls('a(3:4) = b+c')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a(3 : 4) = b + c')
+
+        a = cls('a%c = b+c')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'a % c = b + c')
+
+class test_Proc_Component_Ref(NumpyTestCase): # R741
+
+    def check_proc_component_ref(self):
+        cls = Proc_Component_Ref
+        a = cls('a % b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a % b')
+        assert_equal(repr(a),"Proc_Component_Ref(Name('a'), '%', Name('b'))")
+
+###############################################################################
+############################### SECTION  8 ####################################
+###############################################################################
+
+class test_Continue_Stmt(NumpyTestCase): # R848
+
+    def check_simple(self):
+        cls = Continue_Stmt
+        a = cls('continue')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'CONTINUE')
+        assert_equal(repr(a),"Continue_Stmt('CONTINUE')")
+
+###############################################################################
+############################### SECTION  9 ####################################
+###############################################################################
+
+class test_Io_Unit(NumpyTestCase): # R901
+
+    def check_simple(self):
+        cls = Io_Unit
+        a = cls('*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'*')
+
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Write_Stmt(NumpyTestCase): # R911
+
+    def check_simple(self):
+        cls = Write_Stmt
+        a = cls('write (123)"hey"')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'WRITE(UNIT = 123) "hey"')
+        assert_equal(repr(a),'Write_Stmt(Io_Control_Spec_List(\',\', (Io_Control_Spec(\'UNIT\', Int_Literal_Constant(\'123\', None)),)), Char_Literal_Constant(\'"hey"\', None))')
+
+class test_Print_Stmt(NumpyTestCase): # R912
+
+    def check_simple(self):
+        cls = Print_Stmt
+        a = cls('print 123')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PRINT 123')
+        assert_equal(repr(a),"Print_Stmt(Label('123'), None)")
+
+        a = cls('print *,"a=",a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PRINT *, "a=", a')
+
+class test_Io_Control_Spec(NumpyTestCase): # R913
+
+    def check_simple(self):
+        cls = Io_Control_Spec
+        a = cls('end=123')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END = 123')
+        assert_equal(repr(a),"Io_Control_Spec('END', Label('123'))")
+
+class test_Io_Control_Spec_List(NumpyTestCase): # R913-list
+
+    def check_simple(self):
+        cls = Io_Control_Spec_List
+        a = cls('end=123')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'END = 123')
+        assert_equal(repr(a),"Io_Control_Spec_List(',', (Io_Control_Spec('END', Label('123')),))")
+
+        a = cls('123')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'UNIT = 123')
+
+        a = cls('123,*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'UNIT = 123, FMT = *')
+
+        a = cls('123,fmt=a')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'UNIT = 123, FMT = a')
+
+        if 0:
+            # see todo note in Io_Control_Spec_List
+            a = cls('123,a')
+            assert isinstance(a, cls),`a`
+            assert_equal(str(a),'UNIT = 123, NML = a')
+        
+class test_Format(NumpyTestCase): # R914
+
+    def check_simple(self):
+        cls = Format
+        a = cls('*')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'*')
+        assert_equal(repr(a),"Format('*')")
+
+        a = cls('a')
+        assert isinstance(a, Name),`a`
+        assert_equal(str(a),'a')
+
+        a = cls('123')
+        assert isinstance(a, Label),`a`
+        assert_equal(str(a),'123')
+
+class test_Wait_Stmt(NumpyTestCase): # R921
+
+    def check_simple(self):
+        cls = Wait_Stmt
+        a = cls('wait (123)')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'WAIT(UNIT = 123)')
+
+class test_Wait_Spec(NumpyTestCase): # R922
+
+    def check_simple(self):
+        cls = Wait_Spec
+        a = cls('123')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'UNIT = 123')
+        assert_equal(repr(a),"Wait_Spec('UNIT', Int_Literal_Constant('123', None))")
+
+        a = cls('err=1')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'ERR = 1')
+
+###############################################################################
+############################### SECTION 10 ####################################
+###############################################################################
+
+
+###############################################################################
+############################### SECTION 11 ####################################
+###############################################################################
+
+class test_Module_Nature(NumpyTestCase): # R1110
+
+    def check_simple(self):
+        cls = Module_Nature
+        a = cls('intrinsic')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTRINSIC')
+        assert_equal(repr(a),"Module_Nature('INTRINSIC')")
+
+        a = cls('non_intrinsic')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'NON_INTRINSIC')
+
+###############################################################################
+############################### SECTION 12 ####################################
+###############################################################################
+
+class test_Function_Reference(NumpyTestCase): # R1217
+
+    def check_simple(self):
+        cls = Function_Reference
+        a = cls('f()')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'f()')
+        assert_equal(repr(a),"Function_Reference(Name('f'), None)")
+
+        a = cls('f(2,k=1,a)')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'f(2, k = 1, a)')
+
+
+class test_Procedure_Designator(NumpyTestCase): # R1219
+
+    def check_procedure_designator(self):
+        cls = Procedure_Designator
+        a = cls('a%b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a % b')
+        assert_equal(repr(a),"Procedure_Designator(Name('a'), '%', Name('b'))")
+
+class test_Actual_Arg_Spec(NumpyTestCase): # R1220
+
+    def check_simple(self):
+        cls = Actual_Arg_Spec
+        a = cls('k=a')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'k = a')
+        assert_equal(repr(a),"Actual_Arg_Spec(Name('k'), Name('a'))")
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Actual_Arg_Spec_List(NumpyTestCase):
+
+    def check_simple(self):
+        cls = Actual_Arg_Spec_List
+        a = cls('a,b')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'a, b')
+        assert_equal(repr(a),"Actual_Arg_Spec_List(',', (Name('a'), Name('b')))")
+
+        a = cls('a = k')
+        assert isinstance(a,Actual_Arg_Spec),`a`
+        assert_equal(str(a),'a = k')
+
+        a = cls('a = k,b')
+        assert isinstance(a,Actual_Arg_Spec_List),`a`
+        assert_equal(str(a),'a = k, b')
+
+        a = cls('a')
+        assert isinstance(a,Name),`a`
+        assert_equal(str(a),'a')
+
+class test_Alt_Return_Spec(NumpyTestCase): # R1222
+
+    def check_alt_return_spec(self):
+        cls = Alt_Return_Spec
+        a = cls('* 123')
+        assert isinstance(a,cls),`a`
+        assert_equal(str(a),'*123')
+        assert_equal(repr(a),"Alt_Return_Spec('123')")
+
+class test_Prefix(NumpyTestCase): # R1227
+
+    def check_simple(self):
+        cls = Prefix
+        a = cls('pure  recursive')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'PURE RECURSIVE')
+        assert_equal(repr(a), "Prefix(' ', (Prefix_Spec('PURE'), Prefix_Spec('RECURSIVE')))")
+
+        a = cls('integer * 2 pure')
+        assert isinstance(a, cls),`a`
+        assert_equal(str(a),'INTEGER*2 PURE')
+
+class test_Prefix_Spec(NumpyTestCase): # R1228
+
+    def check_simple(self):
         cls = Prefix_Spec
         a = cls('pure')
         assert isinstance(a, cls),`a`
@@ -136,20 +1909,29 @@
         assert isinstance(a, Intrinsic_Type_Spec),`a`
         assert_equal(str(a),'INTEGER*2')
 
-class test_Prefix(NumpyTestCase):
+class test_Subroutine_Subprogram(NumpyTestCase): # R1231
 
     def check_simple(self):
-        cls = Prefix
-        a = cls('pure  recursive')
+        from api import get_reader
+        reader = get_reader('''\
+      subroutine foo
+      end subroutine foo''')
+        cls = Subroutine_Subprogram
+        a = cls(reader)
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'PURE RECURSIVE')
-        assert_equal(repr(a), "Prefix(' ', (Prefix_Spec('PURE'), Prefix_Spec('RECURSIVE')))")
+        assert_equal(str(a),'SUBROUTINE foo\nEND SUBROUTINE foo')
+        assert_equal(repr(a),"Subroutine_Subprogram(Subroutine_Stmt(None, Name('foo'), None, None), End_Subroutine_Stmt('SUBROUTINE', Name('foo')))")
 
-        a = cls('integer * 2 pure')
+        reader = get_reader('''\
+      subroutine foo
+        integer a
+      end subroutine foo''')
+        cls = Subroutine_Subprogram
+        a = cls(reader)
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'INTEGER*2 PURE')
+        assert_equal(str(a),'SUBROUTINE foo\n  INTEGER :: a\nEND SUBROUTINE foo')
 
-class test_Subroutine_Stmt(NumpyTestCase):
+class test_Subroutine_Stmt(NumpyTestCase): # R1232
 
     def check_simple(self):
         cls = Subroutine_Stmt
@@ -170,7 +1952,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'SUBROUTINE foo BIND(C)')
 
-class test_End_Subroutine_Stmt(NumpyTestCase):
+class test_End_Subroutine_Stmt(NumpyTestCase): # R1234
 
     def check_simple(self):
         cls = End_Subroutine_Stmt
@@ -187,39 +1969,48 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'END SUBROUTINE')
 
-class test_Specification_Part(NumpyTestCase):
+class test_Return_Stmt(NumpyTestCase): # R1236
 
     def check_simple(self):
-        from api import get_reader
-        reader = get_reader('''\
-      integer a''')
-        cls = Specification_Part
-        a = cls(reader)
+        cls = Return_Stmt
+        a = cls('return')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'INTEGER :: a')
-        assert_equal(repr(a), "Specification_Part(Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None)))")
+        assert_equal(str(a), 'RETURN')
+        assert_equal(repr(a), 'Return_Stmt(None)')
 
-class test_Subroutine_Subprogram(NumpyTestCase):
+class test_Contains(NumpyTestCase): # R1237
 
     def check_simple(self):
-        from api import get_reader
-        reader = get_reader('''\
-      subroutine foo
-      end subroutine foo''')
-        cls = Subroutine_Subprogram
-        a = cls(reader)
+        cls = Contains_Stmt
+        a = cls('Contains')
         assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo\nEND SUBROUTINE foo')
-        assert_equal(repr(a),"Subroutine_Subprogram(Subroutine_Stmt(None, Name('foo'), None, None), End_Subroutine_Stmt('SUBROUTINE', Name('foo')))")
+        assert_equal(str(a),'CONTAINS')
+        assert_equal(repr(a),"Contains_Stmt('CONTAINS')")
 
-        reader = get_reader('''\
-      subroutine foo
-        integer a
-      end subroutine foo''')
-        cls = Subroutine_Subprogram
-        a = cls(reader)
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo\nINTEGER :: a\nEND SUBROUTINE foo')
+if 1:
+    for name in dir():
+        obj = eval(name)
+        if not isinstance(obj, ClassType): continue
+        if not issubclass(obj, Base): continue
+        clsname = obj.__name__
+        if clsname.endswith('Base'): continue
+        subclass_names = obj.__dict__.get('subclass_names',None)
+        use_names = obj.__dict__.get('use_names',None)
+        if not use_names: continue
+        match = obj.__dict__.get('match',None)
+        try:
+            test_cls = eval('test_%s' % (clsname))
+        except NameError:
+            test_cls = None
+        if match is None:
+            if test_cls is None:
+                print '%s needs match implementation and tests' % (clsname)
+            else:
+                print '%s needs match implementation' % (clsname)
+        else:
+            if test_cls is None:
+                print '%s needs tests' % (clsname)
+        continue
 
 
 if __name__ == "__main__":

Deleted: trunk/numpy/f2py/lib/parser/test_expressions.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_expressions.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/test_expressions.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -1,1118 +0,0 @@
-
-from numpy.testing import *
-
-from Fortran2003 import *
-
-class test_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Expr
-        a = cls('a .op. b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .OP. b')
-        assert_equal(repr(a),"Expr(Name('a'), '.OP.', Name('b'))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Substring(NumpyTestCase):
-
-    def check_substring(self):
-        cls = Substring
-        a = cls('a(1:2)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a(1 : 2)')
-        assert_equal(repr(a),"Substring(Name('a'), Substring_Range(Int_Literal_Constant('1', None), Int_Literal_Constant('2', None)))")
-
-class test_Part_Ref(NumpyTestCase):
-
-    def check_part_ref(self):
-        cls = Part_Ref
-        a = cls('a')
-        assert isinstance(a, Name),`a`
-        assert_equal(str(a),'a')
-        
-class test_Kind_Selector(NumpyTestCase):
-
-    def check_kind_selector(self):
-        cls = Kind_Selector
-        a = cls('(1)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(KIND = 1)')
-        assert_equal(repr(a),"Kind_Selector('(', Int_Literal_Constant('1', None), ')')")
-
-        a = cls('(kind=1+2)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(KIND = 1 + 2)')
-
-        a = cls('* 1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'*1')
-
-class test_Type_Param_Value(NumpyTestCase):
-
-    def check_type_param_value(self):
-        cls = Type_Param_Value
-        a = cls('*')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'*')
-        assert_equal(repr(a),"Type_Param_Value('*')")
-
-        a = cls(':')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),':')
-
-        a = cls('1+2')
-        assert isinstance(a,Level_2_Expr),`a`
-        assert_equal(str(a),'1 + 2')
-
-class test_Char_Length(NumpyTestCase):
-
-    def check_char_length(self):
-        cls = Char_Length
-        a = cls('(1)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(1)')
-        assert_equal(repr(a),"Char_Length('(', Int_Literal_Constant('1', None), ')')")
-
-        a = cls('1')
-        assert isinstance(a,Int_Literal_Constant),`a`
-        assert_equal(str(a),'1')
-
-        a = cls('(*)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(*)')
-
-        a = cls('(:)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(:)')
-
-class test_Length_Selector(NumpyTestCase):
-
-    def check_length_selector(self):
-        cls = Length_Selector
-        a = cls('( len = *)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(LEN = *)')
-        assert_equal(repr(a),"Length_Selector('(', Type_Param_Value('*'), ')')")
-
-        a = cls('*2,')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'*2')
-
-class test_Char_Selector(NumpyTestCase):
-
-    def check_char_selector(self):
-        cls = Char_Selector
-        a = cls('(len=2, kind=8)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(LEN = 2, KIND = 8)')
-        assert_equal(repr(a),"Char_Selector(Int_Literal_Constant('2', None), Int_Literal_Constant('8', None))")
-
-
-        a = cls('(2, kind=8)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(LEN = 2, KIND = 8)')
-
-        a = cls('(2, 8)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(LEN = 2, KIND = 8)')
-        
-        a = cls('(kind=8)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(KIND = 8)')
-
-        a = cls('(kind=8,len=2)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(LEN = 2, KIND = 8)')
-
-class test_Intrinsic_Type_Spec(NumpyTestCase):
-
-    def check_intrinsic_type_spec(self):
-        cls = Intrinsic_Type_Spec
-        a = cls('INTEGER')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'INTEGER')
-        assert_equal(repr(a), "Intrinsic_Type_Spec('INTEGER', None)")
-
-        a = cls('Integer*2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'INTEGER*2')
-
-        a = cls('real*2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'REAL*2')
-
-        a = cls('logical*2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'LOGICAL*2')
-
-        a = cls('complex*2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'COMPLEX*2')
-
-        a = cls('character*2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'CHARACTER*2')
-
-        a = cls('double complex')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'DOUBLE COMPLEX')
-
-        a = cls('double precision')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'DOUBLE PRECISION')
-
-class test_Type_Param_Spec(NumpyTestCase):
-
-    def check_type_param_spec(self):
-        cls = Type_Param_Spec
-        a = cls('a=1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a = 1')
-        assert_equal(repr(a),"Type_Param_Spec(Name('a'), '=', Int_Literal_Constant('1', None))")
-
-        a = cls('k=a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a')
-
-        a = cls('k=:')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = :')
-
-class test_Type_Param_Spec_List(NumpyTestCase):
-
-    def check_type_param_spec_list(self):
-        cls = Type_Param_Spec_List
-
-        a = cls('a,b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a, b')
-        assert_equal(repr(a),"Type_Param_Spec_List(',', (Name('a'), Name('b')))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-
-        a = cls('k=a,c,g=1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a, c, g = 1')
-
-class test_Type_Param_Inquiry(NumpyTestCase):
-    
-    def check_simple(self):
-        cls = Type_Param_Inquiry
-        a = cls('a % b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a % b')
-        assert_equal(repr(a),"Type_Param_Inquiry(Name('a'), '%', Name('b'))")
-
-class test_Function_Reference(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Function_Reference
-        a = cls('f()')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'f()')
-        assert_equal(repr(a),"Function_Reference(Name('f'), None)")
-
-        a = cls('f(2,k=1,a)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'f(2, k = 1, a)')
-
-class test_Alt_Return_Spec(NumpyTestCase):
-
-    def check_alt_return_spec(self):
-        cls = Alt_Return_Spec
-        a = cls('* 123')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'*123')
-        assert_equal(repr(a),"Alt_Return_Spec('123')")
-
-class test_Substring_Range(NumpyTestCase):
-
-    def check_substring_range(self):
-        cls = Substring_Range
-        a = cls('a:b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a : b')
-        assert_equal(repr(a),"Substring_Range(Name('a'), Name('b'))")
-
-        a = cls('a:')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a :')
-
-        a = cls(':b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),': b')
-
-        a = cls(':')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),':')
-
-class test_Array_Section(NumpyTestCase):
-
-    def check_array_section(self):
-        cls = Array_Section
-        a = cls('a(:)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a(:)')
-        assert_equal(repr(a),"Array_Section(Name('a'), Substring_Range(None, None))")
-
-        a = cls('a(2:)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a(2 :)')
-
-class test_Procedure_Designator(NumpyTestCase):
-
-    def check_procedure_designator(self):
-        cls = Procedure_Designator
-        a = cls('a%b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a % b')
-        assert_equal(repr(a),"Procedure_Designator(Name('a'), '%', Name('b'))")
-
-class test_Data_Ref(NumpyTestCase):
-
-    def check_data_ref(self):
-        cls = Data_Ref
-        a = cls('a%b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a % b')
-        assert_equal(repr(a),"Data_Ref('%', (Name('a'), Name('b')))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Proc_Component_Ref(NumpyTestCase):
-
-    def check_proc_component_ref(self):
-        cls = Proc_Component_Ref
-        a = cls('a % b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a % b')
-        assert_equal(repr(a),"Proc_Component_Ref(Name('a'), '%', Name('b'))")
-
-class test_Structure_Constructor(NumpyTestCase):
-
-    def check_structure_constructor(self):
-        cls = Structure_Constructor
-        a = cls('t()')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'t()')
-        assert_equal(repr(a),"Structure_Constructor(Type_Name('t'), None)")
-
-        a = cls('t(s=1, a)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'t(s = 1, a)')
-
-        a = cls('a=k')
-        assert isinstance(a,Structure_Constructor_2),`a`
-        assert_equal(str(a),'a = k')
-        assert_equal(repr(a),"Structure_Constructor_2(Name('a'), '=', Name('k'))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-    
-class test_Ac_Implied_Do_Control(NumpyTestCase):
-
-    def check_ac_implied_do_control(self):
-        cls = Ac_Implied_Do_Control
-        a = cls('n = 3, 5')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'n = 3, 5')
-        assert_equal(repr(a),"Ac_Implied_Do_Control(Name('n'), [Int_Literal_Constant('3', None), Int_Literal_Constant('5', None)])")
-
-        a = cls('n = 3+1, 5, 1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'n = 3 + 1, 5, 1')
-
-class test_Ac_Value_List(NumpyTestCase):
-
-    def check_ac_value_list(self):
-        cls = Ac_Value_List
-        a = cls('a, b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a, b')
-        assert_equal(repr(a),"Ac_Value_List(',', (Name('a'), Name('b')))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Ac_Implied_Do(NumpyTestCase):
-    
-    def check_ac_implied_do(self):
-        cls = Ac_Implied_Do
-        a = cls('( a, b, n = 1, 5 )')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(a, b, n = 1, 5)')
-        assert_equal(repr(a),"Ac_Implied_Do(Ac_Value_List(',', (Name('a'), Name('b'))), Ac_Implied_Do_Control(Name('n'), [Int_Literal_Constant('1', None), Int_Literal_Constant('5', None)]))")
-
-class test_Ac_Spec(NumpyTestCase):
-
-    def check_ac_spec(self):
-        cls = Ac_Spec
-        a = cls('integer ::')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'INTEGER ::')
-        assert_equal(repr(a),"Ac_Spec(Intrinsic_Type_Spec('INTEGER', None), None)")
-
-        a = cls('integer :: a,b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'INTEGER :: a, b')
-
-        a = cls('a,b')
-        assert isinstance(a,Ac_Value_List),`a`
-        assert_equal(str(a),'a, b')
-
-        a = cls('integer :: a, (a, b, n = 1, 5)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'INTEGER :: a, (a, b, n = 1, 5)')
-
-class test_Name(NumpyTestCase):
-
-    def check_name(self):
-        a = Name('a')
-        assert isinstance(a,Name),`a`
-        a = Name('a2')
-        assert isinstance(a,Name),`a`
-        a = Designator('a')
-        assert isinstance(a,Name),`a`
-        a = Constant('a')
-        assert isinstance(a,Name),`a`
-        a = Expr('a')
-        assert isinstance(a,Name),`a`
-
-class test_Int_Literal_Constant(NumpyTestCase):
-
-    def check_int_literal_constant(self):
-        cls = Int_Literal_Constant
-        a = cls('1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1')
-        assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
-
-        a = cls('21_2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'21_2')
-        assert_equal(repr(a),"%s('21', '2')" % (cls.__name__))
-
-        a = cls('21_SHORT')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'21_SHORT')
-
-        a = cls('21_short')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'21_short')
-
-        a = cls('1976354279568241_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1976354279568241_8')
-
-class test_Signed_Int_Literal_Constant(NumpyTestCase):
-
-    def check_int_literal_constant(self):
-        cls = Signed_Int_Literal_Constant
-        a = cls('1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1')
-        assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
-
-        a = cls('+ 21_2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+ 21_2')
-        assert_equal(repr(a),"%s('+ 21', '2')" % (cls.__name__))
-
-        a = cls('-21_SHORT')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'-21_SHORT')
-
-        a = cls('21_short')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'21_short')
-
-        a = cls('+1976354279568241_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+1976354279568241_8')
-
-class test_Real_Literal_Constant(NumpyTestCase):
-
-    def check_real_literal_constant(self):
-        cls = Real_Literal_Constant
-        a = cls('12.78')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'12.78')
-        assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
-
-        a = cls('12.78_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'12.78_8')
-        assert_equal(repr(a),"%s('12.78', '8')" % (cls.__name__))
-
-        a = cls('12.')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'12.')
-
-        a = cls('1.6E3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E3')
-
-        a = cls('1.6E3_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E3_8')
-
-        a = cls('1.6D3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6D3')
-
-        a = cls('1.6E-3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E-3')
-        a = cls('1.6E+3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E+3')
-
-        a = cls('3E4')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'3E4')
-
-        a = cls('.123')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.123')
-
-        a = cls('1.6E-3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E-3')
-
-        a = cls('10.9E7_QUAD')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'10.9E7_QUAD')
-
-        a = cls('10.9e-17_quad')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'10.9E-17_quad')
-
-class test_Signed_Real_Literal_Constant(NumpyTestCase):
-
-    def check_signed_real_literal_constant(self):
-        cls = Signed_Real_Literal_Constant
-        a = cls('12.78')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'12.78')
-        assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
-
-        a = cls('+12.78_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+12.78_8')
-        assert_equal(repr(a),"%s('+12.78', '8')" % (cls.__name__))
-
-        a = cls('- 12.')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'- 12.')
-
-        a = cls('1.6E3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E3')
-
-        a = cls('+1.6E3_8')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+1.6E3_8')
-
-        a = cls('1.6D3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6D3')
-
-        a = cls('-1.6E-3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'-1.6E-3')
-        a = cls('1.6E+3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'1.6E+3')
-
-        a = cls('3E4')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'3E4')
-
-        a = cls('.123')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.123')
-
-        a = cls('+1.6E-3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+1.6E-3')
-
-        a = cls('10.9E7_QUAD')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'10.9E7_QUAD')
-
-        a = cls('-10.9e-17_quad')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'-10.9E-17_quad')
-
-
-class test_Complex_Literal_Constant(NumpyTestCase):
-
-    def check_complex_literal_constant(self):
-        cls = Complex_Literal_Constant
-        a = cls('(1.0, -1.0)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(1.0, -1.0)')
-        assert_equal(repr(a),"Complex_Literal_Constant(Signed_Real_Literal_Constant('1.0', None), Signed_Real_Literal_Constant('-1.0', None))")
-
-        a = cls('(3,3.1E6)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(3, 3.1E6)')
-
-        a = cls('(4.0_4, 3.6E7_8)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(4.0_4, 3.6E7_8)')
-
-        a = cls('( 0., PI)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(0., PI)')
-
-class test_Char_Literal_Constant(NumpyTestCase):
-
-    def check_char_literal_constant(self):
-        cls = Char_Literal_Constant
-        a = cls('NIH_"DO"')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'NIH_"DO"')
-        assert_equal(repr(a),'Char_Literal_Constant(\'"DO"\', \'NIH\')')
-
-        a = cls("'DO'")
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),"'DO'")
-        assert_equal(repr(a),'Char_Literal_Constant("\'DO\'", None)')
-
-        a = cls("'DON''T'")
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),"'DON''T'")
-
-        a = cls('"DON\'T"')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'"DON\'T"')
-
-        a = cls('""')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'""')
-
-        a = cls("''")
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),"''")
-
-        a = cls('"hey ha(ada)\t"')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'"hey ha(ada)\t"')
-
-class test_Logical_Literal_Constant(NumpyTestCase):
-
-    def check_logical_literal_constant(self):
-        cls = Logical_Literal_Constant
-        a = cls('.TRUE.')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.TRUE.')
-        assert_equal(repr(a),"%s('.TRUE.', None)" % (cls.__name__))
-
-        a = cls('.True.')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.TRUE.')
-
-        a = cls('.FALSE.')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.FALSE.')
-
-        a = cls('.TRUE._HA')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.TRUE._HA')
-
-class test_Binary_Constant(NumpyTestCase):
-
-    def check_boz_literal_constant(self):
-        cls = Boz_Literal_Constant
-        bcls = Binary_Constant
-        a = cls('B"01"')
-        assert isinstance(a,bcls),`a`
-        assert_equal(str(a),'B"01"')
-        assert_equal(repr(a),"%s('B\"01\"')" % (bcls.__name__))
-
-class test_Octal_Constant(NumpyTestCase):
-
-    def check_boz_literal_constant(self):
-        cls = Boz_Literal_Constant
-        ocls = Octal_Constant
-        a = cls('O"017"')
-        assert isinstance(a,ocls),`a`
-        assert_equal(str(a),'O"017"')
-        assert_equal(repr(a),"%s('O\"017\"')" % (ocls.__name__))
-
-class test_Hex_Constant(NumpyTestCase):
-
-    def check_boz_literal_constant(self):
-        cls = Boz_Literal_Constant
-        zcls = Hex_Constant
-        a = cls('Z"01A"')
-        assert isinstance(a,zcls),`a`
-        assert_equal(str(a),'Z"01A"')
-        assert_equal(repr(a),"%s('Z\"01A\"')" % (zcls.__name__))
-
-class test_Subscript_Triplet(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Subscript_Triplet
-        a = cls('a:b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a : b')
-        assert_equal(repr(a),"Subscript_Triplet(Name('a'), Name('b'), None)")
-
-        a = cls('a:b:1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a : b : 1')
-
-        a = cls(':')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),':')
-
-        a = cls('::5')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),': : 5')
-
-        a = cls(':5')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),': 5')
-
-        a = cls('a+1 :')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a + 1 :')
-
-class test_Section_Subscript(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Section_Subscript
-
-        a = cls('1:2')
-        assert isinstance(a, Subscript_Triplet),`a`
-        assert_equal(str(a),'1 : 2')
-
-        a = cls('zzz')
-        assert isinstance(a, Name),`a`
-        assert_equal(str(a),'zzz')
-        
-class test_Section_Subscript_List(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Section_Subscript_List
-        a = cls('a,2')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a, 2')
-        assert_equal(repr(a),"Section_Subscript_List(',', (Name('a'), Int_Literal_Constant('2', None)))")
-
-        a = cls('::1')
-        assert isinstance(a,Subscript_Triplet),`a`
-        assert_equal(str(a),': : 1')
-
-        a = cls('::1, 3')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),': : 1, 3')
-
-class test_Derived_Type_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Derived_Type_Spec
-        a = cls('a(b)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a(b)')
-        assert_equal(repr(a),"Derived_Type_Spec(Type_Name('a'), Name('b'))")
-
-        a = cls('a(b,c,g=1)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a(b, c, g = 1)')
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-        a = cls('a()')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a()')
-
-class test_Type_Name(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Type_Name
-        a = cls('a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a')
-        assert_equal(repr(a),"Type_Name('a')")
-
-        self.assertRaises(NoMatchError,cls,'integer')
-        self.assertRaises(NoMatchError,cls,'doubleprecision')
-
-class test_Actual_Arg_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Actual_Arg_Spec
-        a = cls('k=a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a')
-        assert_equal(repr(a),"Actual_Arg_Spec(Name('k'), '=', Name('a'))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Actual_Arg_Spec_List(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Actual_Arg_Spec_List
-        a = cls('a,b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a, b')
-        assert_equal(repr(a),"Actual_Arg_Spec_List(',', (Name('a'), Name('b')))")
-
-        a = cls('a = k')
-        assert isinstance(a,Actual_Arg_Spec),`a`
-        assert_equal(str(a),'a = k')
-
-        a = cls('a = k,b')
-        assert isinstance(a,Actual_Arg_Spec_List),`a`
-        assert_equal(str(a),'a = k, b')
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Component_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Component_Spec
-        a = cls('k=a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a')
-        assert_equal(repr(a),"Component_Spec(Name('k'), '=', Name('a'))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-        a = cls('a % b')
-        assert isinstance(a, Proc_Component_Ref),`a`
-        assert_equal(str(a),'a % b')
-
-        a = cls('s =a % b')
-        assert isinstance(a, Component_Spec),`a`
-        assert_equal(str(a),'s = a % b')
-
-class test_Component_Spec_List(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Component_Spec_List
-        a = cls('k=a, b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a, b')
-        assert_equal(repr(a),"Component_Spec_List(',', (Component_Spec(Name('k'), '=', Name('a')), Name('b')))")
-
-        a = cls('k=a, c')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a, c')
-
-class test_Structure_Constructor_2(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Structure_Constructor_2
-        a = cls('k=a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'k = a')
-        assert_equal(repr(a),"Structure_Constructor_2(Name('k'), '=', Name('a'))")
-
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-class test_Array_Constructor(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Array_Constructor
-        a = cls('(/a/)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(/a/)')
-        assert_equal(repr(a),"Array_Constructor('(/', Name('a'), '/)')")
-
-        a = cls('[a]')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'[a]')
-        assert_equal(repr(a),"Array_Constructor('[', Name('a'), ']')")
-
-        a = cls('[integer::a]')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'[INTEGER :: a]')
-
-        a = cls('[integer::a,b]')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'[INTEGER :: a, b]')
-
-class test_Parenthesis(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Parenthesis
-        a  = cls('(a)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(a)')
-        assert_equal(repr(a),"Parenthesis('(', Name('a'), ')')")
-
-        a  = cls('(a+1)')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(a + 1)')
-
-        a  = cls('((a))')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'((a))')
-
-        a  = cls('(a+(a+c))')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'(a + (a + c))')
-
-class test_Level_1_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_1_Expr
-        a = cls('.hey. a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.HEY. a')
-        assert_equal(repr(a),"Level_1_Expr('.HEY.', Name('a'))")
-
-        self.assertRaises(NoMatchError,cls,'.not. a')
-
-class test_Level_2_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_2_Expr
-        a = cls('a+b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a + b')
-        assert_equal(repr(a),"Level_2_Expr(Name('a'), '+', Name('b'))")
-
-        a = cls('a-b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a - b')
-
-        a = cls('a+b+c')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a + b + c')
-
-        a = cls('+a')
-        assert isinstance(a,Level_2_Unary_Expr),`a`
-        assert_equal(str(a),'+ a')
-
-        a = cls('+1')
-        assert isinstance(a,Level_2_Unary_Expr),`a`
-        assert_equal(str(a),'+ 1')
-
-        a = cls('+a+b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+ a + b')
-
-class test_Level_2_Unary_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_2_Unary_Expr
-        a = cls('+a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+ a')
-        assert_equal(repr(a),"Level_2_Unary_Expr('+', Name('a'))")
-
-        a = cls('-a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'- a')
-
-        a = cls('+1')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'+ 1')
-
-class test_Level_3_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_3_Expr
-        a = cls('a//b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a // b')
-        assert_equal(repr(a),"Level_3_Expr(Name('a'), '//', Name('b'))")
-
-        a = cls('"a"//"b"')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'"a" // "b"')
-
-class test_Level_4_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_4_Expr
-        a = cls('a.eq.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .EQ. b')
-        assert_equal(repr(a),"Level_4_Expr(Name('a'), '.EQ.', Name('b'))")
-
-        a = cls('a.ne.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .NE. b')
-
-        a = cls('a.lt.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .LT. b')
-
-        a = cls('a.gt.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .GT. b')
-
-        a = cls('a.ge.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .GE. b')
-
-        a = cls('a==b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a == b')
-
-        a = cls('a/=b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a /= b')
-
-        a = cls('a<b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a < b')
-
-        a = cls('a<=b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a <= b')
-
-        a = cls('a>=b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a >= b')
-
-        a = cls('a>b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a > b')
-
-class test_Level_5_Expr(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Level_5_Expr
-        a = cls('a.eqv.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .EQV. b')
-        assert_equal(repr(a),"Level_5_Expr(Name('a'), '.EQV.', Name('b'))")
-
-        a = cls('a.neqv.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .NEQV. b')
-
-        a = cls('a.eq.b')
-        assert isinstance(a,Level_4_Expr),`a`
-        assert_equal(str(a),'a .EQ. b')
-
-class test_Mult_Operand(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Mult_Operand
-        a = cls('a**b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a ** b')
-        assert_equal(repr(a),"Mult_Operand(Name('a'), '**', Name('b'))")
-
-class test_Add_Operand(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Add_Operand
-        a = cls('a*b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a * b')
-        assert_equal(repr(a),"Add_Operand(Name('a'), '*', Name('b'))")
-
-        a = cls('a/b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a / b')
-
-class test_Equiv_Operand(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Equiv_Operand
-        a = cls('a.or.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .OR. b')
-        assert_equal(repr(a),"Equiv_Operand(Name('a'), '.OR.', Name('b'))")
-
-class test_Or_Operand(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Or_Operand
-        a = cls('a.and.b')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a .AND. b')
-        assert_equal(repr(a),"Or_Operand(Name('a'), '.AND.', Name('b'))")
-
-class test_And_Operand(NumpyTestCase):
-
-    def check_simple(self):
-        cls = And_Operand
-        a = cls('.not.a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'.NOT. a')
-        assert_equal(repr(a),"And_Operand('.NOT.', Name('a'))")
-
-class test_Primary(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Primary
-        a = cls('a')
-        assert isinstance(a,Name),`a`
-        assert_equal(str(a),'a')
-
-        a = cls('(a)')
-        assert isinstance(a,Parenthesis),`a`
-        assert_equal(str(a),'(a)')
-
-        a = cls('1')
-        assert isinstance(a,Int_Literal_Constant),`a`
-        assert_equal(str(a),'1')
-
-        a = cls('1.')
-        assert isinstance(a,Real_Literal_Constant),`a`
-        assert_equal(str(a),'1.')
-
-        a = cls('(1, n)')
-        assert isinstance(a,Complex_Literal_Constant),`a`
-        assert_equal(str(a),'(1, n)')
-
-        a = cls('.true.')
-        assert isinstance(a,Logical_Literal_Constant),`a`
-        assert_equal(str(a),'.TRUE.')
-
-        a = cls('"hey a()c"')
-        assert isinstance(a,Char_Literal_Constant),`a`
-        assert_equal(str(a),'"hey a()c"')
-
-        a = cls('b"0101"')
-        assert isinstance(a,Binary_Constant),`a`
-        assert_equal(str(a),'B"0101"')
-
-        a = cls('o"0107"')
-        assert isinstance(a,Octal_Constant),`a`
-        assert_equal(str(a),'O"0107"')
-
-        a = cls('z"a107"')
-        assert isinstance(a,Hex_Constant),`a`
-        assert_equal(str(a),'Z"A107"')
-
-        a = cls('a % b')
-        assert isinstance(a,Data_Ref),`a`
-        assert_equal(str(a),'a % b')
-
-        a = cls('a(:)')
-        assert isinstance(a,Array_Section),`a`
-        assert_equal(str(a),'a(:)')
-
-        
-        
-if __name__ == "__main__":
-    NumpyTest().run()

Deleted: trunk/numpy/f2py/lib/parser/test_statements2.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_statements2.py	2006-11-02 16:12:34 UTC (rev 3426)
+++ trunk/numpy/f2py/lib/parser/test_statements2.py	2006-11-03 21:57:11 UTC (rev 3427)
@@ -1,212 +0,0 @@
-from numpy.testing import *
-
-from Fortran2003 import *
-
-class test_Declaration_Type_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Declaration_Type_Spec
-        a = cls('Integer*2')
-        assert isinstance(a, Intrinsic_Type_Spec),`a`
-        assert_equal(str(a), 'INTEGER*2')
-        
-        a = cls('type(foo)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'TYPE(foo)')
-        assert_equal(repr(a), "Declaration_Type_Spec('TYPE', Type_Name('foo'))")
-
-class test_Type_Declaration_Stmt(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Type_Declaration_Stmt
-        a = cls('integer a')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'INTEGER :: a')
-        assert_equal(repr(a), "Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None))")
-
-        a = cls('integer ,dimension(2):: a*3')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'INTEGER, DIMENSION(2) :: a*3')
-
-class test_Access_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Access_Spec
-        a = cls('private')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'PRIVATE')
-        assert_equal(repr(a), "Access_Spec('PRIVATE')")
-
-        a = cls('public')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'PUBLIC')
-
-class test_Attr_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Attr_Spec
-        a = cls('allocatable')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a), 'ALLOCATABLE')
-
-        a = cls('dimension(a)')
-        assert isinstance(a, Dimension_Attr_Spec),`a`
-        assert_equal(str(a),'DIMENSION(a)')
-
-class test_Dimension_Attr_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Dimension_Attr_Spec
-        a = cls('dimension(a)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'DIMENSION(a)')
-        assert_equal(repr(a),"Dimension_Attr_Spec('DIMENSION', Name('a'))")
-
-class test_Intent_Attr_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Intent_Attr_Spec
-        a = cls('intent(in)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'INTENT(IN)')
-        assert_equal(repr(a),"Intent_Attr_Spec('INTENT', Intent_Spec('IN'))")
-
-class test_Language_Binding_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Language_Binding_Spec
-        a = cls('bind(c)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'BIND(C)')
-        assert_equal(repr(a),'Language_Binding_Spec(None)')
-
-        a = cls('bind(c, name="hey")')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'BIND(C, NAME = "hey")')
-
-class test_Entity_Decl(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Entity_Decl
-        a = cls('a(1)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)')
-        assert_equal(repr(a),"Entity_Decl(Name('a'), Int_Literal_Constant('1', None), None, None)")
-
-        a = cls('a(1)*(3)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)*(3)')
-
-        a = cls('a(1)*(3) = 2')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'a(1)*(3) = 2')
-
-class test_Prefix_Spec(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Prefix_Spec
-        a = cls('pure')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'PURE')
-        assert_equal(repr(a),"Prefix_Spec('PURE')")
-
-        a = cls('elemental')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'ELEMENTAL')
-
-        a = cls('recursive')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'RECURSIVE')
-
-        a = cls('integer * 2')
-        assert isinstance(a, Intrinsic_Type_Spec),`a`
-        assert_equal(str(a),'INTEGER*2')
-
-class test_Prefix(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Prefix
-        a = cls('pure  recursive')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'PURE RECURSIVE')
-        assert_equal(repr(a), "Prefix(' ', (Prefix_Spec('PURE'), Prefix_Spec('RECURSIVE')))")
-
-        a = cls('integer * 2 pure')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'INTEGER*2 PURE')
-
-class test_Subroutine_Stmt(NumpyTestCase):
-
-    def check_simple(self):
-        cls = Subroutine_Stmt
-        a = cls('subroutine foo')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo')
-        assert_equal(repr(a),"Subroutine_Stmt(None, Name('foo'), None, None)")
-
-        a = cls('pure subroutine foo')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'PURE SUBROUTINE foo')
-
-        a = cls('pure subroutine foo(a,b)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'PURE SUBROUTINE foo(a, b)')
-
-        a = cls('subroutine foo() bind(c)')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo BIND(C)')
-
-class test_End_Subroutine_Stmt(NumpyTestCase):
-
-    def check_simple(self):
-        cls = End_Subroutine_Stmt
-        a = cls('end subroutine foo')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'END SUBROUTINE foo')
-        assert_equal(repr(a),"End_Subroutine_Stmt('SUBROUTINE', Name('foo'))")
-
-        a = cls('end')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'END SUBROUTINE')
-
-        a = cls('endsubroutine')
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'END SUBROUTINE')
-
-class test_Specification_Part(NumpyTestCase):
-
-    def check_simple(self):
-        from api import get_reader
-        reader = get_reader('''\
-      integer a''')
-        cls = Specification_Part
-        a = cls(reader)
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'INTEGER :: a')
-        assert_equal(repr(a), "Specification_Part(Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None)))")
-
-class test_Subroutine_Subprogram(NumpyTestCase):
-
-    def check_simple(self):
-        from api import get_reader
-        reader = get_reader('''\
-      subroutine foo
-      end subroutine foo''')
-        cls = Subroutine_Subprogram
-        a = cls(reader)
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo\nEND SUBROUTINE foo')
-        assert_equal(repr(a),"Subroutine_Subprogram(Subroutine_Stmt(None, Name('foo'), None, None), End_Subroutine_Stmt('SUBROUTINE', Name('foo')))")
-
-        reader = get_reader('''\
-      subroutine foo
-        integer a
-      end subroutine foo''')
-        cls = Subroutine_Subprogram
-        a = cls(reader)
-        assert isinstance(a, cls),`a`
-        assert_equal(str(a),'SUBROUTINE foo\nINTEGER :: a\nEND SUBROUTINE foo')
-
-
-if __name__ == "__main__":
-    NumpyTest().run()



From numpy-svn at scipy.org  Fri Nov  3 20:47:40 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  3 Nov 2006 19:47:40 -0600 (CST)
Subject: [Numpy-svn] r3428 - in trunk/numpy/core: . src
Message-ID: <20061104014740.7B40FCF4018@new.scipy.org>

Author: oliphant
Date: 2006-11-03 19:47:36 -0600 (Fri, 03 Nov 2006)
New Revision: 3428

Modified:
   trunk/numpy/core/_internal.py
   trunk/numpy/core/src/arraymethods.c
Log:
Allow order keyword to sort for sorting record arrays.

Modified: trunk/numpy/core/_internal.py
===================================================================
--- trunk/numpy/core/_internal.py	2006-11-03 21:57:11 UTC (rev 3427)
+++ trunk/numpy/core/_internal.py	2006-11-04 01:47:36 UTC (rev 3428)
@@ -267,3 +267,21 @@
     shape = property(get_shape, None, doc="c-types shape")
     strides = property(get_strides, None, doc="c-types strides")
     _as_parameter_ = property(get_as_parameter, None, doc="_as parameter_")
+
+
+# Given a datatype and an order object
+#  return a new names tuple
+#  with the order indicated
+def _newnames(datatype, order):
+    oldnames = datatype.names
+    nameslist = list(oldnames)
+    if isinstance(order, str):
+        order = [order]
+    if isinstance(order, (list, tuple)):
+        for name in order:
+            try:
+                nameslist.remove(name)
+            except ValueError:
+                raise ValueError, "unknown field name: %s" % (name,)
+        return tuple(list(order) + nameslist)
+    raise ValueError, "unsupported order value: %s" % (order,)

Modified: trunk/numpy/core/src/arraymethods.c
===================================================================
--- trunk/numpy/core/src/arraymethods.c	2006-11-03 21:57:11 UTC (rev 3427)
+++ trunk/numpy/core/src/arraymethods.c	2006-11-04 01:47:36 UTC (rev 3428)
@@ -852,14 +852,38 @@
 	int axis=-1;
 	int val;
 	PyArray_SORTKIND which=PyArray_QUICKSORT;
-	static char *kwlist[] = {"axis", "kind", NULL};
+        PyObject *order=NULL;
+        PyArray_Descr *saved=NULL;
+        PyArray_Descr *newd;
+        static char *kwlist[] = {"axis", "kind", "order", NULL};
+        
+        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&O", kwlist, &axis,
+                                         PyArray_SortkindConverter, &which,
+                                         &order))
+                return NULL;
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&", kwlist, &axis,
-					 PyArray_SortkindConverter, &which))
-		return NULL;
+        if (order != NULL) {
+                PyObject *new_name;
+                saved = self->descr;
+                if (saved->names == NULL) {
+                        PyErr_SetString(PyExc_ValueError, "Cannot specify " \
+                                        "order with no fields.");
+                        return NULL;
+                }
+                new_name = PyObject_CallMethod(_numpy_internal, "_newnames",
+                                               "OO", saved, order);
+                if (new_name == NULL) return NULL;
+                newd = PyArray_DescrNew(saved);
+                newd->names = new_name;
+                self->descr = newd;
+        }
 
-	val = PyArray_Sort(self, axis, which);
-	if (val < 0) return NULL;
+        val = PyArray_Sort(self, axis, which);
+        if (order != NULL) {
+                Py_XDECREF(self->descr);
+                self->descr = saved;
+        }
+        if (val < 0) return NULL;
 	Py_INCREF(Py_None);
 	return Py_None;
 }



From numpy-svn at scipy.org  Sat Nov  4 16:17:33 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  4 Nov 2006 15:17:33 -0600 (CST)
Subject: [Numpy-svn] r3429 - trunk/numpy/core
Message-ID: <20061104211733.3932839C121@new.scipy.org>

Author: oliphant
Date: 2006-11-04 15:17:24 -0600 (Sat, 04 Nov 2006)
New Revision: 3429

Modified:
   trunk/numpy/core/records.py
Log:
Fix auto-naming in records.py

Modified: trunk/numpy/core/records.py
===================================================================
--- trunk/numpy/core/records.py	2006-11-04 01:47:36 UTC (rev 3428)
+++ trunk/numpy/core/records.py	2006-11-04 21:17:24 UTC (rev 3429)
@@ -82,11 +82,12 @@
         else:
             self._names = []
 
-        # if the names are not specified, they will be assigned as "f1, f2,..."
-        # if not enough names are specified, they will be assigned as "f[n+1],
-        # f[n+2],..." etc. where n is the number of specified names..."
-        self._names += ['f%d' % i for i in range(len(self._names)+1,
-                                                 self._nfields+1)]
+        # if the names are not specified, they will be assigned as
+        #  "f0, f1, f2,..."
+        # if not enough names are specified, they will be assigned as "f[n],
+        # f[n+1],..." etc. where n is the number of specified names..."
+        self._names += ['f%d' % i for i in range(len(self._names),
+                                                 self._nfields)]
         # check for redundant names
         _dup = find_duplicate(self._names)
         if _dup:



From numpy-svn at scipy.org  Sat Nov  4 16:19:29 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  4 Nov 2006 15:19:29 -0600 (CST)
Subject: [Numpy-svn] r3430 - trunk/numpy/distutils/command
Message-ID: <20061104211929.1A23339C04B@new.scipy.org>

Author: stefan
Date: 2006-11-04 15:19:03 -0600 (Sat, 04 Nov 2006)
New Revision: 3430

Modified:
   trunk/numpy/distutils/command/build_ext.py
Log:
Fix typo.


Modified: trunk/numpy/distutils/command/build_ext.py
===================================================================
--- trunk/numpy/distutils/command/build_ext.py	2006-11-04 21:17:24 UTC (rev 3429)
+++ trunk/numpy/distutils/command/build_ext.py	2006-11-04 21:19:03 UTC (rev 3430)
@@ -357,7 +357,7 @@
         # make g77-compiled static libs available to MSVC
         lib_added = False
         for lib in self.fcompiler.libraries:
-            if not lib.startswtih('msvcr'):
+            if not lib.startswith('msvcr'):
                 c_libraries.append(lib)
                 p = combine_paths(f_lib_dirs, 'lib' + lib + '.a')
                 if p:



From numpy-svn at scipy.org  Sun Nov  5 18:10:48 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun,  5 Nov 2006 17:10:48 -0600 (CST)
Subject: [Numpy-svn] r3431 - trunk/numpy/core/tests
Message-ID: <20061105231048.95D0A39C09B@new.scipy.org>

Author: stefan
Date: 2006-11-05 17:10:29 -0600 (Sun, 05 Nov 2006)
New Revision: 3431

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Add test for ticket #372. Whitespace cleanup.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-04 21:19:03 UTC (rev 3430)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-05 23:10:29 UTC (rev 3431)
@@ -85,11 +85,11 @@
     def check_noncontiguous_fill(self,level=rlevel):
         """Ticket #58."""
         a = N.zeros((5,3))
-	b = a[:,:2,]
+        b = a[:,:2,]
         def rs():
             b.shape = (10,)
         self.failUnlessRaises(AttributeError,rs)
-        
+
     def check_bool(self,level=rlevel):
         """Ticket #60"""
         x = N.bool_(1)
@@ -128,7 +128,7 @@
     def check_kron_matrix(self,level=rlevel):
         """Ticket #71"""
         x = N.matrix('[1 0; 1 0]')
-        assert_equal(type(N.kron(x,x)),type(x))        
+        assert_equal(type(N.kron(x,x)),type(x))
 
     def check_scalar_compare(self,level=rlevel):
         """Ticket #72"""
@@ -334,14 +334,14 @@
     def check_unique_zero_sized(self,level=rlevel):
         """Ticket #205"""
         assert_array_equal([], N.unique(N.array([])))
-        
+
     def check_chararray_rstrip(self,level=rlevel):
         """Ticket #222"""
         x = N.chararray((1,),5)
         x[0] = 'a   '
         x = x.rstrip()
         assert_equal(x[0], 'a')
-        
+
     def check_object_array_shape(self,level=rlevel):
         """Ticket #239"""
         assert_equal(N.array([[1,2],3,4],dtype=object).shape, (3,))
@@ -350,14 +350,14 @@
         assert_equal(N.array([],dtype=object).shape, (0,))
         assert_equal(N.array([[],[],[]],dtype=object).shape, (3,0))
         assert_equal(N.array([[3,4],[5,6],None],dtype=object).shape, (3,))
-        
+
     def check_mem_around(self,level=rlevel):
         """Ticket #243"""
         x = N.zeros((1,))
         y = [0]
         decimal = 6
         N.around(abs(x-y),decimal) <= 10.0**(-decimal)
-        
+
     def check_character_array_strip(self,level=rlevel):
         """Ticket #246"""
         x = N.char.array(("x","x ","x  "))
@@ -367,12 +367,12 @@
         """Lexsort memory error"""
         v = N.array([1,2,3,4,5,6,7,8,9,10])
         assert_equal(N.lexsort(v),0)
-        
+
     def check_pickle_dtype(self,level=rlevel):
         """Ticket #251"""
         import pickle
         pickle.dumps(N.float)
-        
+
     def check_masked_array_multiply(self,level=rlevel):
         """Ticket #254"""
         a = N.ma.zeros((4,1))
@@ -391,16 +391,16 @@
     def check_object_array_from_list(self, level=rlevel):
         """Ticket #270"""
         a = N.array([1,'A',None])
-        
+
     def check_masked_array_repeat(self, level=rlevel):
         """Ticket #271"""
         N.ma.array([1],mask=False).repeat(10)
-        
+
     def check_multiple_assign(self, level=rlevel):
         """Ticket #273"""
         a = N.zeros((3,1),int)
         a[[1,2]] = 1
-        
+
     def check_empty_array_type(self, level=rlevel):
         assert_equal(N.array([]).dtype, N.zeros(0).dtype)
 
@@ -424,7 +424,7 @@
                  'ptp', 'cumprod', 'prod', 'std', 'var', 'mean',
                  'round', 'min', 'max', 'argsort', 'sort']
         funcs2 = ['compress', 'take', 'repeat']
-        
+
         for func in funcs1:
             arr = N.random.rand(8,7)
             arr2 = arr.copy()
@@ -453,17 +453,17 @@
                 res1 = getattr(arr1, func)(arr2)
             res2 = getattr(N, func)(arr1, arr2)
             assert abs(res1-res2).max() < 1e-8, func
-        
+
     def check_mem_lexsort_strings(self, level=rlevel):
         """Ticket #298"""
         lst = ['abc','cde','fgh']
         N.lexsort((lst,))
-        
+
     def check_fancy_index(self, level=rlevel):
         """Ticket #302"""
         x = N.array([1,2])[N.array([0])]
         assert_equal(x.shape,(1,))
-        
+
     def check_recarray_copy(self, level=rlevel):
         """Ticket #312"""
         dt = [('x',N.int16),('y',N.float64)]
@@ -471,66 +471,66 @@
         rb = N.rec.array(ra, dtype=dt)
         rb['x'] = 2.
         assert ra['x'] != rb['x']
-        
+
     def check_rec_fromarray(self, level=rlevel):
         """Ticket #322"""
         x1 = N.array([[1,2],[3,4],[5,6]])
         x2 = N.array(['a','dd','xyz'])
         x3 = N.array([1.1,2,3])
         N.rec.fromarrays([x1,x2,x3], formats="(2,)i4,a3,f8")
-        
+
     def check_object_array_assign(self, level=rlevel):
         x = N.empty((2,2),object)
         x.flat[2] = (1,2,3)
         assert_equal(x.flat[2],(1,2,3))
-        
+
     def check_ndmin_float64(self, level=rlevel):
         """Ticket #324"""
-        x = N.array([1,2,3],dtype=N.float64)        
-        assert_equal(N.array(x,dtype=N.float32,ndmin=2).ndim,2)        
+        x = N.array([1,2,3],dtype=N.float64)
+        assert_equal(N.array(x,dtype=N.float32,ndmin=2).ndim,2)
         assert_equal(N.array(x,dtype=N.float64,ndmin=2).ndim,2)
-        
+
     def check_mem_vectorise(self, level=rlevel):
         """Ticket #325"""
         vt = N.vectorize(lambda *args: args)
         vt(N.zeros((1,2,1)), N.zeros((2,1,1)), N.zeros((1,1,2)))
-        vt(N.zeros((1,2,1)), N.zeros((2,1,1)), N.zeros((1,1,2)), N.zeros((2,2)))                
-        
+        vt(N.zeros((1,2,1)), N.zeros((2,1,1)), N.zeros((1,1,2)), N.zeros((2,2)))
+
     def check_mem_axis_minimization(self, level=rlevel):
         """Ticket #327"""
         data = N.arange(5)
         data = N.add.outer(data,data)
-        
+
     def check_mem_float_imag(self, level=rlevel):
         """Ticket #330"""
         N.float64(1.0).imag
-        
+
     def check_dtype_tuple(self, level=rlevel):
         """Ticket #334"""
         assert N.dtype('i4') == N.dtype(('i4',()))
-        
+
     def check_dtype_posttuple(self, level=rlevel):
         """Ticket #335"""
         N.dtype([('col1', '()i4')])
-        
+
     def check_mgrid_single_element(self, level=rlevel):
         """Ticket #339"""
         assert_array_equal(N.mgrid[0:0:1j],[0])
         assert_array_equal(N.mgrid[0:0],[])
-        
+
     def check_numeric_carray_compare(self, level=rlevel):
         """Ticket #341"""
-        assert_equal(N.array([ 'X' ], 'c'),'X')        
-        
+        assert_equal(N.array([ 'X' ], 'c'),'X')
+
     def check_string_array_size(self, level=rlevel):
         """Ticket #342"""
         self.failUnlessRaises(ValueError,
                               N.array,[['X'],['X','X','X']],'|S1')
-                              
+
     def check_dtype_repr(self, level=rlevel):
         """Ticket #344"""
         dt1=N.dtype(('uint32', 2))
-        dt2=N.dtype(('uint32', (2,)))        
+        dt2=N.dtype(('uint32', (2,)))
         assert_equal(dt1.__repr__(), dt2.__repr__())
 
     def check_reshape_order(self, level=rlevel):
@@ -555,6 +555,16 @@
     def check_object_argmax(self, level=rlevel):
         a = N.array([1,2,3],dtype=object)
         assert a.argmax() == 2
-                
+
+    def check_recarray_fields(self, level=rlevel):
+        """Ticket #372"""
+        dt = N.dtype([('f0',"i4"),('f1',"i4")])
+        for a in [N.array([(1,2),(3,4)],"i4,i4"),
+                  N.rec.array([(1,2),(3,4)],"i4,i4"),
+                  N.rec.array([(1,2),(3,4)]),
+                  N.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
+                  N.rec.fromarrays([(1,2),(3,4)])]:
+            assert_equal(a.dtype,dt)
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Mon Nov  6 16:21:03 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon,  6 Nov 2006 15:21:03 -0600 (CST)
Subject: [Numpy-svn] r3432 - trunk/numpy
Message-ID: <20061106212103.850B339C0D2@new.scipy.org>

Author: stefan
Date: 2006-11-06 15:20:46 -0600 (Mon, 06 Nov 2006)
New Revision: 3432

Modified:
   trunk/numpy/ctypeslib.py
Log:
Only raise ctypes version warning on load_library. Whitespace cleanup.


Modified: trunk/numpy/ctypeslib.py
===================================================================
--- trunk/numpy/ctypeslib.py	2006-11-05 23:10:29 UTC (rev 3431)
+++ trunk/numpy/ctypeslib.py	2006-11-06 21:20:46 UTC (rev 3432)
@@ -7,10 +7,6 @@
 
 try:
     import ctypes
-    if ctypes.__version__ < '1.0.1':
-        import warnings
-        warnings.warn("All features of ctypes interface may not work with " \
-                      "ctypes < 1.0.1")
 except ImportError:
     ctypes = None
 
@@ -24,9 +20,13 @@
     import numpy.core._internal as nic
     c_intp = nic._getintp_ctype()
     del nic
-    
+
     # Adapted from Albert Strasheim
     def load_library(libname, loader_path):
+        if ctypes.__version__ < '1.0.1':
+            import warnings
+            warnings.warn("All features of ctypes interface may not work " \
+                          "with ctypes < 1.0.1")
         if '.' not in libname:
             if sys.platform == 'win32':
                 libname = '%s.dll' % libname
@@ -51,7 +51,7 @@
         num += _flagdict[val]
     return num
 
-_flagnames = ['C_CONTIGUOUS', 'F_CONTIGUOUS', 'ALIGNED', 'WRITEABLE', 
+_flagnames = ['C_CONTIGUOUS', 'F_CONTIGUOUS', 'ALIGNED', 'WRITEABLE',
               'OWNDATA', 'UPDATEIFCOPY']
 def _flags_fromnum(num):
     res = []
@@ -88,28 +88,28 @@
 _pointer_type_cache = {}
 def ndpointer(dtype=None, ndim=None, shape=None, flags=None):
     """Array-checking restype/argtypes.
-    
+
     An ndpointer instance is used to describe an ndarray in restypes
     and argtypes specifications.  This approach is more flexible than
     using, for example,
-    
+
     POINTER(c_double)
-    
+
     since several restrictions can be specified, which are verified
     upon calling the ctypes function.  These include data type
     (dtype), number of dimensions (ndim), shape and flags (e.g.
     'C_CONTIGUOUS' or 'F_CONTIGUOUS').  If a given array does not satisfy the
     specified restrictions, a TypeError is raised.
-    
+
     Example:
-        
+
         clib.somefunc.argtypes = [ndpointer(dtype=float64,
                                             ndim=1,
                                             flags='C_CONTIGUOUS')]
         clib.somefunc(array([1,2,3],dtype=float64))
 
     """
-    
+
     if dtype is not None:
         dtype = _dtype(dtype)
     num = None



From numpy-svn at scipy.org  Sat Nov 11 07:22:12 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 11 Nov 2006 06:22:12 -0600 (CST)
Subject: [Numpy-svn] r3433 - trunk/numpy/lib
Message-ID: <20061111122212.54D4739C048@new.scipy.org>

Author: rkern
Date: 2006-11-11 06:22:10 -0600 (Sat, 11 Nov 2006)
New Revision: 3433

Modified:
   trunk/numpy/lib/function_base.py
Log:
Coerce to floating point arrays in cov to avoid errors when integer arrays are passed.

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2006-11-06 21:20:46 UTC (rev 3432)
+++ trunk/numpy/lib/function_base.py	2006-11-11 12:22:10 UTC (rev 3433)
@@ -859,7 +859,7 @@
                           for x, c in zip(self.ufunc(*args), self.otypes)])
         return _res
 
-def cov(m,y=None, rowvar=1, bias=0):
+def cov(m, y=None, rowvar=1, bias=0):
     """Estimate the covariance matrix.
 
     If m is a vector, return the variance.  For matrices return the
@@ -876,7 +876,7 @@
     is a variable and the observations are in the rows.
     """
 
-    X = array(m,ndmin=2)
+    X = array(m, ndmin=2, dtype=float)
     if X.shape[0] == 1:
         rowvar = 1
     if rowvar:
@@ -888,7 +888,7 @@
 
 
     if y is not None:
-        y = array(y,copy=False,ndmin=2)
+        y = array(y, copy=False, ndmin=2, dtype=float)
         X = concatenate((X,y),axis)
 
     X -= X.mean(axis=1-axis)[tup]
@@ -903,9 +903,9 @@
         fact = N-1.0
 
     if not rowvar:
-        return (dot(X.transpose(), X.conj()) / fact).squeeze()
+        return (dot(X.T, X.conj()) / fact).squeeze()
     else:
-        return (dot(X,X.transpose().conj())/fact).squeeze()
+        return (dot(X, X.T.conj()) / fact).squeeze()
 
 def corrcoef(x, y=None, rowvar=1, bias=0):
     """The correlation coefficients



From numpy-svn at scipy.org  Sat Nov 11 17:32:44 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 11 Nov 2006 16:32:44 -0600 (CST)
Subject: [Numpy-svn] r3434 - trunk/numpy/linalg
Message-ID: <20061111223244.C7A4039C02D@new.scipy.org>

Author: charris
Date: 2006-11-11 16:32:42 -0600 (Sat, 11 Nov 2006)
New Revision: 3434

Modified:
   trunk/numpy/linalg/lapack_litemodule.c
Log:
Fix typo in lapack_litemodule.c

Modified: trunk/numpy/linalg/lapack_litemodule.c
===================================================================
--- trunk/numpy/linalg/lapack_litemodule.c	2006-11-11 12:22:10 UTC (rev 3433)
+++ trunk/numpy/linalg/lapack_litemodule.c	2006-11-11 22:32:42 UTC (rev 3434)
@@ -459,7 +459,7 @@
                     nwork = MAX(work0,3*mn*mn +                 \
                                 MAX(mx,4*mn*(mn+1))+500);
                     break;
-            defaul:
+            default:
                     nwork = work0;
             }
             *DDATA(work) = (double) nwork;



From numpy-svn at scipy.org  Sat Nov 11 18:10:00 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 11 Nov 2006 17:10:00 -0600 (CST)
Subject: [Numpy-svn] r3435 - trunk/numpy/linalg
Message-ID: <20061111231000.DF16E39C010@new.scipy.org>

Author: charris
Date: 2006-11-11 17:09:59 -0600 (Sat, 11 Nov 2006)
New Revision: 3435

Modified:
   trunk/numpy/linalg/lapack_litemodule.c
Log:
Fix bogus unitialized variable warning by removing unneeded variable. Cleanup whitespace.

Modified: trunk/numpy/linalg/lapack_litemodule.c
===================================================================
--- trunk/numpy/linalg/lapack_litemodule.c	2006-11-11 22:32:42 UTC (rev 3434)
+++ trunk/numpy/linalg/lapack_litemodule.c	2006-11-11 23:09:59 UTC (rev 3435)
@@ -85,11 +85,11 @@
                           int *lwork, int *info);
 
 extern int FNAME(dorgqr)(int *m, int *n, int *k, double a[], int *lda,
-                          double tau[], double work[], 
+                          double tau[], double work[],
                           int *lwork, int *info);
 
 extern int FNAME(zungqr)(int *m, int *n, int *k, f2c_doublecomplex a[],
-                          int *lda, f2c_doublecomplex tau[], 
+                          int *lda, f2c_doublecomplex tau[],
                           f2c_doublecomplex work[], int *lwork, int *info);
 
 static PyObject *LapackError;
@@ -370,7 +370,7 @@
             FNAME(dgelsd)(&m,&n,&nrhs,DDATA(a),&lda,DDATA(b),&ldb,
                           DDATA(s),&rcond,&rank,DDATA(work),&lwork,
                           IDATA(iwork),&info);
-    
+
     return Py_BuildValue("{s:i,s:i,s:i,s:i,s:i,s:i,s:d,s:i,s:i,s:i}","dgelsd_",
                          lapack_lite_status__,"m",m,"n",n,"nrhs",nrhs,
                          "lda",lda,"ldb",ldb,"rcond",rcond,"rank",rank,
@@ -443,26 +443,25 @@
                too small.
                Change it to the maximum of the minimum and the optimal.
             */
-            long nwork, work0 = (long) *DDATA(work);
+            long work0 = (long) *DDATA(work);
             int mn = MIN(m,n);
             int mx = MAX(m,n);
+
             switch(jobz){
             case 'N':
-                    nwork = MAX(work0,3*mn + MAX(mx,6*mn)+500);
+                    work0 = MAX(work0,3*mn + MAX(mx,6*mn)+500);
                     break;
             case 'O':
-                    nwork = MAX(work0,3*mn*mn +                 \
+                    work0 = MAX(work0,3*mn*mn +                 \
                                 MAX(mx,5*mn*mn+4*mn+500));
                     break;
             case 'S':
             case 'A':
-                    nwork = MAX(work0,3*mn*mn +                 \
+                    work0 = MAX(work0,3*mn*mn +                 \
                                 MAX(mx,4*mn*(mn+1))+500);
                     break;
-            default:
-                    nwork = work0;
             }
-            *DDATA(work) = (double) nwork;
+            *DDATA(work) = (double) work0;
     }
     return Py_BuildValue("{s:i,s:c,s:i,s:i,s:i,s:i,s:i,s:i,s:i}","dgesdd_",
                          lapack_lite_status__,"jobz",jobz,"m",m,"n",n,
@@ -529,7 +528,7 @@
         TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dgeqrf"));
 
         lapack_lite_status__ = \
-                FNAME(dgeqrf)(&m, &n, DDATA(a), &lda, DDATA(tau), 
+                FNAME(dgeqrf)(&m, &n, DDATA(a), &lda, DDATA(tau),
                               DDATA(work), &lwork, &info);
 
         return Py_BuildValue("{s:l,s:l,s:l,s:l,s:l,s:l}","dgeqrf_",
@@ -546,7 +545,7 @@
         PyObject *a, *tau, *work;
         int lda;
         int info;
-        
+
         TRY(PyArg_ParseTuple(args,"lllOlOOll",  &m, &n, &k, &a, &lda, &tau, &work, &lwork, &info));
         TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dorgqr"));
         TRY(check_object(tau,PyArray_DOUBLE,"tau","PyArray_DOUBLE","dorgqr"));
@@ -755,7 +754,7 @@
         PyObject *a, *tau, *work;
         int lda;
         int info;
-        
+
         TRY(PyArg_ParseTuple(args,"llOlOOll",&m,&n,&a,&lda,&tau,&work,&lwork,&info));
 
 /* check objects and convert to right storage order */
@@ -765,7 +764,7 @@
 
         lapack_lite_status__ = \
         FNAME(zgeqrf)(&m, &n, ZDATA(a), &lda, ZDATA(tau), ZDATA(work), &lwork, &info);
-        
+
         return Py_BuildValue("{s:l,s:l,s:l,s:l,s:l,s:l}","zgeqrf_",lapack_lite_status__,"m",m,"n",n,"lda",lda,"lwork",lwork,"info",info);
 }
 
@@ -786,9 +785,9 @@
 
 
         lapack_lite_status__ = \
-        FNAME(zungqr)(&m, &n, &k, ZDATA(a), &lda, ZDATA(tau), ZDATA(work), 
+        FNAME(zungqr)(&m, &n, &k, ZDATA(a), &lda, ZDATA(tau), ZDATA(work),
                       &lwork, &info);
-        
+
         return Py_BuildValue("{s:l,s:l}","zungqr_",lapack_lite_status__,
                              "info",info);
 }
@@ -821,7 +820,7 @@
 
 static char lapack_lite_module_documentation[] = "";
 
-DL_EXPORT(void) 
+DL_EXPORT(void)
 initlapack_lite(void)
 {
     PyObject *m,*d;



From numpy-svn at scipy.org  Mon Nov 13 16:49:50 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 13 Nov 2006 15:49:50 -0600 (CST)
Subject: [Numpy-svn] r3436 - trunk/numpy
Message-ID: <20061113214950.A3F9D39C0A6@new.scipy.org>

Author: stefan
Date: 2006-11-13 15:49:43 -0600 (Mon, 13 Nov 2006)
New Revision: 3436

Modified:
   trunk/numpy/add_newdocs.py
Log:
Expose fromiter's docstring.


Modified: trunk/numpy/add_newdocs.py
===================================================================
--- trunk/numpy/add_newdocs.py	2006-11-11 23:09:59 UTC (rev 3435)
+++ trunk/numpy/add_newdocs.py	2006-11-13 21:49:43 UTC (rev 3436)
@@ -208,7 +208,7 @@
 
     """)
 
-add_newdoc('numpy.core.multiarray','fromstring',
+add_newdoc('numpy.core.multiarray','fromiter',
     """fromiter(iterable, dtype, count=-1)
 
     Return a new 1d array initialized from iterable. If count is



From numpy-svn at scipy.org  Thu Nov 16 18:59:22 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 16 Nov 2006 17:59:22 -0600 (CST)
Subject: [Numpy-svn] r3437 - trunk/numpy/core/src
Message-ID: <20061116235922.20E0D39C077@new.scipy.org>

Author: oliphant
Date: 2006-11-16 17:59:19 -0600 (Thu, 16 Nov 2006)
New Revision: 3437

Modified:
   trunk/numpy/core/src/arrayobject.c
Log:
Used an adapted setArrayFromSequence from numarray to increase speed of Assign_Array dramatically

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2006-11-13 21:49:43 UTC (rev 3436)
+++ trunk/numpy/core/src/arrayobject.c	2006-11-16 23:59:19 UTC (rev 3437)
@@ -7088,30 +7088,56 @@
         return outtype;
 }
 
+/* adapted from Numarray */
+static int 
+setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, intp offset)
+{
+        Py_ssize_t i, slen = PySequence_Length(s);
+        int res = 0;
+
+        if (dim > a->nd) {
+                PyErr_Format(PyExc_ValueError,
+                             "setArrayFromSequence: sequence/array dimensions mismatch.");
+                return -1;
+        }
+
+        if (slen != a->dimensions[dim]) {
+                PyErr_Format(PyExc_ValueError,
+                             "setArrayFromSequence: sequence/array shape mismatch.");
+                return -1;
+        }
+
+        for(i=0; i<slen; i++) {
+                PyObject *o = PySequence_GetItem(s, i);
+                if ((a->nd - dim) > 1) {
+                        res = setArrayFromSequence(a, o, dim+1, offset);
+                }
+                else {
+                        res = a->descr->f->setitem(o, (a->data + offset), a);
+                }
+                Py_DECREF(o);
+                if (res < 0) return res;
+                offset += a->strides[dim];
+        }
+        return 0;
+}
+
+
 static int
 Assign_Array(PyArrayObject *self, PyObject *v)
 {
-        PyObject *e;
-        int l, r;
-
         if (!PySequence_Check(v)) {
                 PyErr_SetString(PyExc_ValueError,
                                 "assignment from non-sequence");
                 return -1;
         }
+        if (self->nd == 0) {
+                PyErr_SetString(PyExc_ValueError,
+                                "assignment to 0-d array");
+                return -1;
+        }
 
-        l=PyObject_Length(v);
-        if(l < 0) return -1;
-
-        while(--l >= 0)
-                {
-                        e=PySequence_GetItem(v,l);
-                        if (e == NULL) return -1;
-                        r = PySequence_SetItem((PyObject*)self,l,e);
-                        Py_DECREF(e);
-                        if(r == -1) return -1;
-                }
-        return 0;
+        return setArrayFromSequence(self, v, 0, 0);
 }
 
 /* "Array Scalars don't call this code" */



From numpy-svn at scipy.org  Thu Nov 16 19:05:45 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 16 Nov 2006 18:05:45 -0600 (CST)
Subject: [Numpy-svn] r3438 - / trunk/numpy/f2py/lib
Message-ID: <20061117000545.2D42139C077@new.scipy.org>

Author: rkern
Date: 2006-11-16 18:05:37 -0600 (Thu, 16 Nov 2006)
New Revision: 3438

Added:
   f2py-research/
Removed:
   trunk/numpy/f2py/lib/research/
Log:
Moving the research/ directory out of the trunk as it takes up space in the source distribution without being useful for users.


Copied: f2py-research (from rev 3437, trunk/numpy/f2py/lib/research)



From numpy-svn at scipy.org  Thu Nov 16 19:28:52 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 16 Nov 2006 18:28:52 -0600 (CST)
Subject: [Numpy-svn] r3439 - trunk/numpy/core/src
Message-ID: <20061117002852.3747C39C077@new.scipy.org>

Author: oliphant
Date: 2006-11-16 18:28:50 -0600 (Thu, 16 Nov 2006)
New Revision: 3439

Modified:
   trunk/numpy/core/src/ufuncobject.c
Log:
Applied tecki's patch for ufunc's involving objects

Modified: trunk/numpy/core/src/ufuncobject.c
===================================================================
--- trunk/numpy/core/src/ufuncobject.c	2006-11-17 00:05:37 UTC (rev 3438)
+++ trunk/numpy/core/src/ufuncobject.c	2006-11-17 00:28:50 UTC (rev 3439)
@@ -1961,7 +1961,7 @@
 				for (i=0; i<self->nargs; i++) {
 					if (loop->cast[i]) {
 						if (steps[i] == 0) {
-							Py_XDECREF(*((PyObject **)castbuf[i]));
+							Py_CLEAR(*((PyObject **)castbuf[i]));
 						}
 						else {
 							int size = loop->bufsize;
@@ -1972,7 +1972,7 @@
 								size = loop->leftover;
 
 							for (j=0; j<size; j++) {
-								Py_XDECREF(*objptr);
+								Py_CLEAR(*objptr);
 								objptr += 1;
 							}
 						}



From numpy-svn at scipy.org  Thu Nov 16 19:33:30 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 16 Nov 2006 18:33:30 -0600 (CST)
Subject: [Numpy-svn] r3440 - trunk/numpy/core
Message-ID: <20061117003330.97E7739C010@new.scipy.org>

Author: oliphant
Date: 2006-11-16 18:33:28 -0600 (Thu, 16 Nov 2006)
New Revision: 3440

Modified:
   trunk/numpy/core/numeric.py
Log:
Add docstring to correlate.

Modified: trunk/numpy/core/numeric.py
===================================================================
--- trunk/numpy/core/numeric.py	2006-11-17 00:28:50 UTC (rev 3439)
+++ trunk/numpy/core/numeric.py	2006-11-17 00:33:28 UTC (rev 3440)
@@ -207,6 +207,10 @@
     return mode
 
 def correlate(a,v,mode='valid'):
+    """Return the discrete, linear correlation of 1-D sequences
+    a and v; mode can be 0 (valid), 1 (same), or 2 (full)
+    to specify the size of the resulting sequence
+    """
     mode = _mode_from_name(mode)
     return multiarray.correlate(a,v,mode)
 



From numpy-svn at scipy.org  Thu Nov 16 19:45:41 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 16 Nov 2006 18:45:41 -0600 (CST)
Subject: [Numpy-svn] r3441 - in trunk/numpy: core/src numarray/numpy
Message-ID: <20061117004541.E0DCD39C010@new.scipy.org>

Author: oliphant
Date: 2006-11-16 18:45:36 -0600 (Thu, 16 Nov 2006)
New Revision: 3441

Modified:
   trunk/numpy/core/src/scalarmathmodule.c.src
   trunk/numpy/numarray/numpy/arraybase.h
Log:
Fix some compiler errors.

Modified: trunk/numpy/core/src/scalarmathmodule.c.src
===================================================================
--- trunk/numpy/core/src/scalarmathmodule.c.src	2006-11-17 00:33:28 UTC (rev 3440)
+++ trunk/numpy/core/src/scalarmathmodule.c.src	2006-11-17 00:45:36 UTC (rev 3441)
@@ -156,6 +156,10 @@
 }
 /**end repeat**/
 
+#ifndef SIZEOF_BYTE
+#define SIZEOF_BYTE 1
+#endif
+
 /**begin repeat
    #name=byte,ubyte,short,ushort,int,uint,long,ulong#
    #big=(int,uint)*2,(longlong,ulonglong)*2#

Modified: trunk/numpy/numarray/numpy/arraybase.h
===================================================================
--- trunk/numpy/numarray/numpy/arraybase.h	2006-11-17 00:33:28 UTC (rev 3440)
+++ trunk/numpy/numarray/numpy/arraybase.h	2006-11-17 00:45:36 UTC (rev 3441)
@@ -37,7 +37,7 @@
   tObject=PyArray_OBJECT,        /* placeholder... does nothing */
   tMaxType=PyArray_NTYPES,
   tDefault = tFloat64,
-#if BITSOF_LONG == 64
+#if NPY_BITSOF_LONG == 64
   tLong = tInt64,
 #else
   tLong = tInt32,



From numpy-svn at scipy.org  Fri Nov 17 06:01:43 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 05:01:43 -0600 (CST)
Subject: [Numpy-svn] r3442 - trunk/numpy/core/tests
Message-ID: <20061117110143.651DA39C00E@new.scipy.org>

Author: stefan
Date: 2006-11-17 05:01:35 -0600 (Fri, 17 Nov 2006)
New Revision: 3442

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Test for ticket #378.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-17 00:45:36 UTC (rev 3441)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-17 11:01:35 UTC (rev 3442)
@@ -565,6 +565,24 @@
                   N.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
                   N.rec.fromarrays([(1,2),(3,4)])]:
             assert_equal(a.dtype,dt)
+            
+    def check_refcount(self, level=rlevel):
+        """Ticket #378"""
+        import sys        
+        
+        a = N.arange(100*100).reshape([100,100])
+        b = a
+        
+        i = 1
+        
+        def p(x,y): return 123
+        v = N.vectorize(p)
+        
+        rc = sys.getrefcount(i)
+        for j in range(15):
+            d = v(a,b)
+        assert(sys.getrefcount(i) >= rc)
+        
 
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Fri Nov 17 13:45:19 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 12:45:19 -0600 (CST)
Subject: [Numpy-svn] r3443 - in trunk/numpy/core: blasdot src
Message-ID: <20061117184519.0283339C07F@new.scipy.org>

Author: oliphant
Date: 2006-11-17 12:45:17 -0600 (Fri, 17 Nov 2006)
New Revision: 3443

Modified:
   trunk/numpy/core/blasdot/_dotblas.c
   trunk/numpy/core/src/arrayobject.c
Log:
Fix reference count problem with dtypes in vdot

Modified: trunk/numpy/core/blasdot/_dotblas.c
===================================================================
--- trunk/numpy/core/blasdot/_dotblas.c	2006-11-17 11:01:35 UTC (rev 3442)
+++ trunk/numpy/core/blasdot/_dotblas.c	2006-11-17 18:45:17 UTC (rev 3443)
@@ -979,11 +979,11 @@
     typenum = PyArray_ObjectType(op2, typenum);
     
     type = PyArray_DescrFromType(typenum);
-    
+    Py_INCREF(type);   
     ap1 = (PyArrayObject *)PyArray_FromAny(op1, type, 0, 0, 0, NULL);
-    if (ap1==NULL) goto fail;
+    if (ap1==NULL) {Py_DECREF(type); goto fail;}
     op1 = PyArray_Flatten(ap1, 0);
-    if (op1==NULL) goto fail;
+    if (op1==NULL) {Py_DECREF(type); goto fail;}
     Py_DECREF(ap1);
     ap1 = (PyArrayObject *)op1;
     

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2006-11-17 11:01:35 UTC (rev 3442)
+++ trunk/numpy/core/src/arrayobject.c	2006-11-17 18:45:17 UTC (rev 3443)
@@ -10614,6 +10614,7 @@
                         "an attempt was made to deallocate %d (%c) ***\n", 
                         self->type_num, self->type);
                 Py_INCREF(self);
+                Py_INCREF(self);
                 return;
         }
         Py_XDECREF(self->typeobj);



From numpy-svn at scipy.org  Fri Nov 17 14:28:59 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 13:28:59 -0600 (CST)
Subject: [Numpy-svn] r3444 - trunk/numpy/core/src
Message-ID: <20061117192859.632AF39C058@new.scipy.org>

Author: oliphant
Date: 2006-11-17 13:28:56 -0600 (Fri, 17 Nov 2006)
New Revision: 3444

Modified:
   trunk/numpy/core/src/multiarraymodule.c
Log:
Understand ctypes basic types and structures.

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2006-11-17 18:45:17 UTC (rev 3443)
+++ trunk/numpy/core/src/multiarraymodule.c	2006-11-17 19:28:56 UTC (rev 3444)
@@ -41,9 +41,28 @@
 	if (dtypedescr) {
 		ret = PyArray_DescrConverter(dtypedescr, &new);
 		Py_DECREF(dtypedescr);
-		if (ret) return new;
+		if (ret == PY_SUCCEED) return new;
 		PyErr_Clear();
 	}
+        /* Understand basic ctypes */
+        dtypedescr = PyObject_GetAttrString(obj, "_type_");
+        PyErr_Clear();
+        if (dtypedescr) {
+                ret = PyArray_DescrConverter(dtypedescr, &new);
+                Py_DECREF(dtypedescr);
+                if (ret == PY_SUCCEED) return new;
+                PyErr_Clear();
+        }
+        /* Understand ctypes structures --
+           bit-fields are not supported */
+        dtypedescr = PyObject_GetAttrString(obj, "_fields_");
+        PyErr_Clear();
+        if (dtypedescr) {
+                ret = PyArray_DescrConverter(dtypedescr, &new);
+                Py_DECREF(dtypedescr);
+                if (ret == PY_SUCCEED) return new;
+                PyErr_Clear();
+        }
 	return NULL;
 }
 



From numpy-svn at scipy.org  Fri Nov 17 14:39:04 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 13:39:04 -0600 (CST)
Subject: [Numpy-svn] r3445 - trunk/numpy/core/src
Message-ID: <20061117193904.4E69139C058@new.scipy.org>

Author: oliphant
Date: 2006-11-17 13:39:02 -0600 (Fri, 17 Nov 2006)
New Revision: 3445

Modified:
   trunk/numpy/core/src/multiarraymodule.c
Log:
Understand array's of ctypes types.

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2006-11-17 19:28:56 UTC (rev 3444)
+++ trunk/numpy/core/src/multiarraymodule.c	2006-11-17 19:39:02 UTC (rev 3445)
@@ -50,8 +50,24 @@
         if (dtypedescr) {
                 ret = PyArray_DescrConverter(dtypedescr, &new);
                 Py_DECREF(dtypedescr);
-                if (ret == PY_SUCCEED) return new;
+                if (ret == PY_SUCCEED) {
+                        PyObject *length;
+                        length = PyObject_GetAttrString(obj, "_length_");
+                        PyErr_Clear();
+                        if (length) { /* derived type */
+                                PyObject *newtup;
+                                PyArray_Descr *derived;
+                                newtup = Py_BuildValue("NO", new, length);
+                                ret = PyArray_DescrConverter(newtup, &derived);
+                                Py_DECREF(newtup);
+                                if (ret == PY_SUCCEED) return derived;
+                                PyErr_Clear();
+                                return NULL;
+                        }
+                        return new;
+                }
                 PyErr_Clear();
+                return NULL;
         }
         /* Understand ctypes structures --
            bit-fields are not supported */



From numpy-svn at scipy.org  Fri Nov 17 15:17:32 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 14:17:32 -0600 (CST)
Subject: [Numpy-svn] r3446 - trunk/numpy/core/src
Message-ID: <20061117201732.38BDF39C013@new.scipy.org>

Author: oliphant
Date: 2006-11-17 14:17:30 -0600 (Fri, 17 Nov 2006)
New Revision: 3446

Modified:
   trunk/numpy/core/src/arrayobject.c
Log:
Allow data-type objects to be 'repeated' using '*' like ctypes.

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2006-11-17 19:39:02 UTC (rev 3445)
+++ trunk/numpy/core/src/arrayobject.c	2006-11-17 20:17:30 UTC (rev 3446)
@@ -4027,7 +4027,7 @@
 #if PY_VERSION_HEX >= 0x02050000
         (lenfunc)array_length,          /*sq_length*/
         (binaryfunc)NULL,               /* sq_concat is handled by nb_add*/
-        (ssizeargfunc)NULL,
+        (ssizeargfunc)NULL,             
         (ssizeargfunc)array_item_nice,
         (ssizessizeargfunc)array_slice,
         (ssizeobjargproc)array_ass_item,               /*sq_ass_item*/
@@ -10976,7 +10976,6 @@
 }
 
 /* returns 1 if this data-type has an object portion
-
    used when setting the state because hasobject is not stored.
  */
 static int
@@ -11397,6 +11396,26 @@
 }
 
 static PyObject *
+descr_repeat(PyObject *self, Py_ssize_t length)
+{
+        PyObject *tup;
+        PyArray_Descr *new;
+        if (length < 0)
+                return PyErr_Format(PyExc_ValueError,
+#if (PY_VERSION_HEX < 0x02050000)
+                                    "Array length must be >= 0, not %d",
+#else
+                                    "Array length must be >= 0, not %zd",
+#endif
+                                    length);
+        tup = Py_BuildValue("O" NPY_SSIZE_T_PYFMT, self, length);
+        if (tup == NULL) return NULL;
+        PyArray_DescrConverter(tup, &new);
+        Py_DECREF(tup);
+        return (PyObject *)new;
+}
+
+static PyObject *
 descr_subscript(PyArray_Descr *self, PyObject *op)
 {
 
@@ -11449,6 +11468,12 @@
         return NULL;
 }
 
+static PySequenceMethods descr_as_sequence = {
+        descr_length,
+        (binaryfunc)NULL,
+        descr_repeat,
+};
+
 static PyMappingMethods descr_as_mapping = {
         descr_length,                       /*mp_length*/
         (binaryfunc)descr_subscript,        /*mp_subscript*/
@@ -11472,7 +11497,7 @@
         0,                                      /* tp_compare */
         (reprfunc)arraydescr_repr,              /* tp_repr */
         0,                                      /* tp_as_number */
-        0,                                      /* tp_as_sequence */
+        &descr_as_sequence,                     /* tp_as_sequence */
         &descr_as_mapping,                      /* tp_as_mapping */
         0,                                      /* tp_hash */
         0,                                      /* tp_call */



From numpy-svn at scipy.org  Fri Nov 17 15:40:56 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 17 Nov 2006 14:40:56 -0600 (CST)
Subject: [Numpy-svn] r3447 - trunk/numpy/core/src
Message-ID: <20061117204056.4FC0539C19B@new.scipy.org>

Author: oliphant
Date: 2006-11-17 14:40:54 -0600 (Fri, 17 Nov 2006)
New Revision: 3447

Modified:
   trunk/numpy/core/src/arrayobject.c
   trunk/numpy/core/src/multiarraymodule.c
Log:
Allow array_descriptor format to also use alignment.  Force objects with _fields_ attribute to use alignment (ctypes case).

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2006-11-17 20:17:30 UTC (rev 3446)
+++ trunk/numpy/core/src/arrayobject.c	2006-11-17 20:40:54 UTC (rev 3447)
@@ -10865,10 +10865,6 @@
         {NULL, NULL, NULL, NULL},
 };
 
-static PyArray_Descr *_convert_from_dict(PyObject *obj, int align);
-static PyArray_Descr *_convert_from_commastring(PyObject *obj, int align);
-static PyArray_Descr *_convert_from_array_descr(PyObject *obj);
-
 static PyObject *
 arraydescr_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 {

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2006-11-17 20:17:30 UTC (rev 3446)
+++ trunk/numpy/core/src/multiarraymodule.c	2006-11-17 20:40:54 UTC (rev 3447)
@@ -70,11 +70,12 @@
                 return NULL;
         }
         /* Understand ctypes structures --
-           bit-fields are not supported */
+           bit-fields are not supported 
+           automatically aligns */
         dtypedescr = PyObject_GetAttrString(obj, "_fields_");
         PyErr_Clear();
         if (dtypedescr) {
-                ret = PyArray_DescrConverter(dtypedescr, &new);
+                ret = PyArray_DescrAlignConverter(dtypedescr, &new);
                 Py_DECREF(dtypedescr);
                 if (ret == PY_SUCCEED) return new;
                 PyErr_Clear();
@@ -4475,7 +4476,7 @@
  shape parameter).
 */
 static PyArray_Descr *
-_convert_from_array_descr(PyObject *obj)
+_convert_from_array_descr(PyObject *obj, int align)
 {
 	int n, i, totalsize;
 	int ret;
@@ -4485,6 +4486,7 @@
 	PyArray_Descr *new;
 	PyArray_Descr *conv;
         int dtypeflags=0;
+        int maxalign = 0;
 
 
 	n = PyList_GET_SIZE(obj);
@@ -4545,6 +4547,13 @@
                 dtypeflags |= (conv->hasobject & NPY_FROM_FIELDS);
 		tup = PyTuple_New((title == NULL ? 2 : 3));
 		PyTuple_SET_ITEM(tup, 0, (PyObject *)conv);
+                if (align) {
+			int _align;
+			_align = conv->alignment;
+			if (_align > 1) totalsize =			\
+				((totalsize + _align - 1)/_align)*_align;
+			maxalign = MAX(maxalign, _align);
+                }
 		PyTuple_SET_ITEM(tup, 1, PyInt_FromLong((long) totalsize));
 
 		/* Title can be "meta-data".  Only insert it
@@ -4565,6 +4574,10 @@
         new->names = nameslist;
 	new->elsize = totalsize;
         new->hasobject=dtypeflags;
+	if (maxalign > 1) {
+		totalsize = ((totalsize+maxalign-1)/maxalign)*maxalign;
+	}
+	if (align) new->alignment = maxalign;        
 	return new;
 
  fail:
@@ -4577,9 +4590,6 @@
 /* a list specifying a data-type can just be
    a list of formats.  The names for the fields
    will default to f0, f1, f2, and so forth.
-
-   or it can be an array_descr format string -- in which case
-   align must be 0.
 */
 
 static PyArray_Descr *
@@ -4927,8 +4937,12 @@
         if PyDict_Check(obj) {
                 *at =  _convert_from_dict(obj, 1);
         }
-        else if PyString_Check(obj)
+        else if PyString_Check(obj) {
                 *at = _convert_from_commastring(obj, 1);
+        }
+        else if PyList_Check(obj) {
+                *at = _convert_from_array_descr(obj, 1);
+        }
         else {
                 return PyArray_DescrConverter(obj, at);
         }
@@ -4952,8 +4966,12 @@
         if PyDict_Check(obj) {
                 *at =  _convert_from_dict(obj, 1);
         }
-        else if PyString_Check(obj)
+        else if PyString_Check(obj) {
                 *at = _convert_from_commastring(obj, 1);
+        }
+        else if PyList_Check(obj) {
+                *at = _convert_from_array_descr(obj, 1);
+        }
         else {
                 return PyArray_DescrConverter2(obj, at);
         }
@@ -5114,7 +5132,7 @@
 	}
 	/* or a list */
 	else if (PyList_Check(obj)) {
-		*at = _convert_from_array_descr(obj);
+		*at = _convert_from_array_descr(obj,0);
 		if (*at == NULL) {
 			if (PyErr_Occurred()) return PY_FAIL;
 			goto fail;



From numpy-svn at scipy.org  Sat Nov 18 09:53:50 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 18 Nov 2006 08:53:50 -0600 (CST)
Subject: [Numpy-svn] r3448 - trunk/numpy/core/src
Message-ID: <20061118145350.2092339C1FB@new.scipy.org>

Author: oliphant
Date: 2006-11-18 08:53:47 -0600 (Sat, 18 Nov 2006)
New Revision: 3448

Modified:
   trunk/numpy/core/src/ufuncobject.c
Log:
Remove Py_CLEAR and set ptr to NULL manually

Modified: trunk/numpy/core/src/ufuncobject.c
===================================================================
--- trunk/numpy/core/src/ufuncobject.c	2006-11-17 20:40:54 UTC (rev 3447)
+++ trunk/numpy/core/src/ufuncobject.c	2006-11-18 14:53:47 UTC (rev 3448)
@@ -1961,7 +1961,7 @@
 				for (i=0; i<self->nargs; i++) {
 					if (loop->cast[i]) {
 						if (steps[i] == 0) {
-							Py_CLEAR(*((PyObject **)castbuf[i]));
+							Py_XDECREF(*((PyObject **)castbuf[i]));
 						}
 						else {
 							int size = loop->bufsize;
@@ -1972,7 +1972,8 @@
 								size = loop->leftover;
 
 							for (j=0; j<size; j++) {
-								Py_CLEAR(*objptr);
+								Py_XDECREF(*objptr);
+								*objptr = NULL;
 								objptr += 1;
 							}
 						}



From numpy-svn at scipy.org  Sun Nov 19 15:52:58 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 19 Nov 2006 14:52:58 -0600 (CST)
Subject: [Numpy-svn] r3449 - trunk/numpy/core/tests
Message-ID: <20061119205258.A95BE39C08D@new.scipy.org>

Author: stefan
Date: 2006-11-19 14:52:52 -0600 (Sun, 19 Nov 2006)
New Revision: 3449

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Test refcount for changeset #3443.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-18 14:53:47 UTC (rev 3448)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-19 20:52:52 UTC (rev 3449)
@@ -1,6 +1,7 @@
 from numpy.testing import *
 from StringIO import StringIO
 import pickle
+import sys
 
 set_local_path()
 import numpy as N
@@ -8,6 +9,19 @@
 
 rlevel = 1
 
+def assert_valid_refcount(op):
+    a = N.arange(100 * 100)
+    b = N.arange(100*100).reshape(100, 100)
+    c = b
+
+    i = 1
+
+    rc = sys.getrefcount(i)
+    for j in range(15):
+        d = op(b,c)
+
+    assert(sys.getrefcount(i) >= rc)
+
 class test_regression(NumpyTestCase):
     def check_invalid_round(self,level=rlevel):
         """Ticket #3"""
@@ -565,24 +579,16 @@
                   N.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
                   N.rec.fromarrays([(1,2),(3,4)])]:
             assert_equal(a.dtype,dt)
-            
-    def check_refcount(self, level=rlevel):
+
+    def check_refcount_vectorize(self, level=rlevel):
         """Ticket #378"""
-        import sys        
-        
-        a = N.arange(100*100).reshape([100,100])
-        b = a
-        
-        i = 1
-        
         def p(x,y): return 123
         v = N.vectorize(p)
-        
-        rc = sys.getrefcount(i)
-        for j in range(15):
-            d = v(a,b)
-        assert(sys.getrefcount(i) >= rc)
-        
+        assert_valid_refcount(v)
 
+    def check_refcount_vdot(self, level=rlevel):
+        """Changeset #3443"""
+        assert_valid_refcount(N.vdot)
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Sun Nov 19 15:57:00 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 19 Nov 2006 14:57:00 -0600 (CST)
Subject: [Numpy-svn] r3450 - trunk/numpy/distutils
Message-ID: <20061119205700.EAB9A39C0EF@new.scipy.org>

Author: pearu
Date: 2006-11-19 14:56:57 -0600 (Sun, 19 Nov 2006)
New Revision: 3450

Modified:
   trunk/numpy/distutils/core.py
Log:
Skip interactive mode when using script_args argument.

Modified: trunk/numpy/distutils/core.py
===================================================================
--- trunk/numpy/distutils/core.py	2006-11-19 20:52:52 UTC (rev 3449)
+++ trunk/numpy/distutils/core.py	2006-11-19 20:56:57 UTC (rev 3450)
@@ -103,7 +103,7 @@
 
 def setup(**attr):
 
-    if len(sys.argv)<=1:
+    if len(sys.argv)<=1 and not attr.get('script_args',[]):
         from interactive import interactive_sys_argv
         import atexit
         atexit.register(_exit_interactive_session)



From numpy-svn at scipy.org  Sun Nov 19 21:27:30 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 19 Nov 2006 20:27:30 -0600 (CST)
Subject: [Numpy-svn] r3451 - trunk/numpy/core/include/numpy
Message-ID: <20061120022730.1C05239C0E2@new.scipy.org>

Author: charris
Date: 2006-11-19 20:27:26 -0600 (Sun, 19 Nov 2006)
New Revision: 3451

Modified:
   trunk/numpy/core/include/numpy/arrayscalars.h
   trunk/numpy/core/include/numpy/ndarrayobject.h
   trunk/numpy/core/include/numpy/npy_interrupt.h
   trunk/numpy/core/include/numpy/oldnumeric.h
   trunk/numpy/core/include/numpy/ufuncobject.h
Log:
Parenthesize some arguments in macros. Cleanup whitespace. Fixes ticket #383

Modified: trunk/numpy/core/include/numpy/arrayscalars.h
===================================================================
--- trunk/numpy/core/include/numpy/arrayscalars.h	2006-11-19 20:56:57 UTC (rev 3450)
+++ trunk/numpy/core/include/numpy/arrayscalars.h	2006-11-20 02:27:26 UTC (rev 3451)
@@ -127,7 +127,7 @@
 /* Macros
      Py<Cls><bitsize>ScalarObject
      Py<Cls><bitsize>ArrType_Type
-   are defined in ndarrayobject.h 
+   are defined in ndarrayobject.h
 */
 
 #define PyArrayScalar_False ((PyObject *)(&(_PyArrayScalar_BoolValues[0])))

Modified: trunk/numpy/core/include/numpy/ndarrayobject.h
===================================================================
--- trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-19 20:56:57 UTC (rev 3450)
+++ trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-20 02:27:26 UTC (rev 3451)
@@ -209,7 +209,7 @@
         NPY_COMPLEX_SCALAR,
         NPY_OBJECT_SCALAR,
 } NPY_SCALARKIND;
-#define NPY_NSCALARKINDS NPY_OBJECT_SCALAR+1
+#define NPY_NSCALARKINDS (NPY_OBJECT_SCALAR+1)
 
 typedef enum {
         NPY_ANYORDER=-1,
@@ -285,7 +285,7 @@
 #define NPY_SIZEOF_DOUBLE SIZEOF_DOUBLE
 #define NPY_SIZEOF_LONGDOUBLE SIZEOF_LONG_DOUBLE
 #define NPY_SIZEOF_LONGLONG SIZEOF_LONG_LONG
-#define NPY_BITSOF_BOOL sizeof(npy_bool)*CHAR_BIT
+#define NPY_BITSOF_BOOL (sizeof(npy_bool)*CHAR_BIT)
 #define NPY_BITSOF_CHAR CHAR_BIT
 #define NPY_BITSOF_SHORT (SIZEOF_SHORT*CHAR_BIT)
 #define NPY_BITSOF_INT (SIZEOF_INT*CHAR_BIT)
@@ -929,7 +929,7 @@
     typedef int Py_ssize_t;
     #define PY_SSIZE_T_MAX INT_MAX
     #define PY_SSIZE_T_MIN INT_MIN
-  #endif 
+  #endif
 #define NPY_SSIZE_T_PYFMT "i"
 #undef PyIndex_Check
 #define constchar const char
@@ -1116,27 +1116,27 @@
 #define NPY_LIST_PICKLE     0x02  /* Convert to list for pickling */
 #define NPY_ITEM_IS_POINTER 0x04  /* The item is a POINTER  */
 
-#define NPY_NEEDS_INIT      0x08  /* memory needs to be initialized 
+#define NPY_NEEDS_INIT      0x08  /* memory needs to be initialized
                                      for this data-type */
 
-#define NPY_NEEDS_PYAPI     0x10  /* operations need Python C-API 
+#define NPY_NEEDS_PYAPI     0x10  /* operations need Python C-API
                                      so don't give-up thread. */
 
-#define NPY_USE_GETITEM     0x20  /* Use f.getitem when extracting elements 
+#define NPY_USE_GETITEM     0x20  /* Use f.getitem when extracting elements
                                      of this data-type */
 
 #define NPY_USE_SETITEM     0x40  /* Use f.setitem when setting creating
                                      0-d array from this data-type.
                                   */
 
-/* These are inherited for global data-type if any data-types in the field 
+/* These are inherited for global data-type if any data-types in the field
    have them */
 #define NPY_FROM_FIELDS     (NPY_NEEDS_INIT | NPY_LIST_PICKLE | NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI)
-                                     
+
 #define NPY_OBJECT_DTYPE_FLAGS (NPY_LIST_PICKLE | NPY_USE_GETITEM | NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | NPY_NEEDS_INIT | NPY_NEEDS_PYAPI)
 
 #define PyDataType_FLAGCHK(dtype, flag) \
-        ((dtype->hasobject & flag) == flag)
+        ((dtype->hasobject & (flag)) == (flag))
 #define PyDataType_REFCHK(dtype) \
         PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)
 
@@ -1151,7 +1151,7 @@
         char type;              /* unique-character representing this type */
         char byteorder;         /* '>' (big), '<' (little), '|'
                                    (not-applicable), or '=' (native). */
-        char hasobject;         /* non-zero if it has object arrays 
+        char hasobject;         /* non-zero if it has object arrays
                                    in fields */
         int type_num;          /* number representing this type */
         int elsize;             /* element size for this type */
@@ -1276,21 +1276,21 @@
 #define NPY_ARR_HAS_DESCR  0x0800
 
 
-#define NPY_BEHAVED NPY_ALIGNED | NPY_WRITEABLE
-#define NPY_BEHAVED_NS NPY_ALIGNED | NPY_WRITEABLE | NPY_NOTSWAPPED
-#define NPY_CARRAY NPY_CONTIGUOUS | NPY_BEHAVED
-#define NPY_CARRAY_RO NPY_CONTIGUOUS | NPY_ALIGNED
-#define NPY_FARRAY NPY_FORTRAN | NPY_BEHAVED
-#define NPY_FARRAY_RO NPY_FORTRAN | NPY_ALIGNED
+#define NPY_BEHAVED (NPY_ALIGNED | NPY_WRITEABLE)
+#define NPY_BEHAVED_NS (NPY_ALIGNED | NPY_WRITEABLE | NPY_NOTSWAPPED)
+#define NPY_CARRAY (NPY_CONTIGUOUS | NPY_BEHAVED)
+#define NPY_CARRAY_RO (NPY_CONTIGUOUS | NPY_ALIGNED)
+#define NPY_FARRAY (NPY_FORTRAN | NPY_BEHAVED)
+#define NPY_FARRAY_RO (NPY_FORTRAN | NPY_ALIGNED)
 #define NPY_DEFAULT NPY_CARRAY
 #define NPY_IN_ARRAY NPY_CARRAY_RO
 #define NPY_OUT_ARRAY NPY_CARRAY
-#define NPY_INOUT_ARRAY NPY_CARRAY | NPY_UPDATEIFCOPY
+#define NPY_INOUT_ARRAY (NPY_CARRAY | NPY_UPDATEIFCOPY)
 #define NPY_IN_FARRAY NPY_FARRAY_RO
 #define NPY_OUT_FARRAY NPY_FARRAY
-#define NPY_INOUT_FARRAY NPY_FARRAY | NPY_UPDATEIFCOPY
+#define NPY_INOUT_FARRAY (NPY_FARRAY | NPY_UPDATEIFCOPY)
 
-#define NPY_UPDATE_ALL NPY_CONTIGUOUS | NPY_FORTRAN | NPY_ALIGNED
+#define NPY_UPDATE_ALL (NPY_CONTIGUOUS | NPY_FORTRAN | NPY_ALIGNED)
 
 
 /* Size of internal buffers used for alignment */
@@ -1407,7 +1407,7 @@
                         }                                               \
                 }                                                       \
         }
-                                
+
 #define PyArray_ITER_NEXT(it) {                                     \
         (it)->index++;                                            \
         if ((it)->nd_m1 == 0) {                                   \
@@ -1473,7 +1473,7 @@
                 }                                                       \
 }
 
-#define PyArray_ITER_DATA(it) ((PyArrayIterObject *)it)->dataptr
+#define PyArray_ITER_DATA(it) (((PyArrayIterObject *)(it))->dataptr)
 
 
 /*
@@ -1528,13 +1528,13 @@
         }
 
 #define PyArray_MultiIter_DATA(multi, i)                        \
-        (((PyArrayMultiIterObject *)multi)->iters[i]->dataptr)
+        (((PyArrayMultiIterObject *)(multi))->iters[i]->dataptr)
 
 #define PyArray_MultiIter_SIZE(multi)                   \
-        ((PyArrayMultiIterObject *)multi)->size
+        ((PyArrayMultiIterObject *)(multi))->size
 
 #define PyArray_MultiIter_NEXTi(multi, i)                               \
-        PyArray_ITER_NEXT(((PyArrayMultiIterObject *)multi)->iters[i])
+        PyArray_ITER_NEXT(((PyArrayMultiIterObject *)(multi))->iters[i])
 
 /* Store the information needed for fancy-indexing over an array */
 
@@ -1600,52 +1600,52 @@
 #define PyArray_ITEMSIZE(obj) (((PyArrayObject *)(obj))->descr->elsize)
 #define PyArray_TYPE(obj) (((PyArrayObject *)(obj))->descr->type_num)
 #define PyArray_GETITEM(obj,itemptr)                    \
-        ((PyArrayObject *)(obj))->descr->f->getitem((char *)itemptr,    \
-                                                 (PyArrayObject *)obj);
+        ((PyArrayObject *)(obj))->descr->f->getitem((char *)(itemptr),    \
+                                                 (PyArrayObject *)(obj));
 #define PyArray_SETITEM(obj,itemptr,v)                                  \
-        ((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)v,      \
+        ((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)(v),      \
                                                     (char *)(itemptr),  \
                                                     (PyArrayObject *)(obj));
 
 
-#define PyTypeNum_ISBOOL(type) (type == NPY_BOOL)
-#define PyTypeNum_ISUNSIGNED(type) ((type == NPY_UBYTE) || \
-                                 (type == NPY_USHORT) || \
-                                 (type == NPY_UINT) ||  \
-                                 (type == NPY_ULONG) || \
-                                 (type == NPY_ULONGLONG))
+#define PyTypeNum_ISBOOL(type) ((type) == NPY_BOOL)
+#define PyTypeNum_ISUNSIGNED(type) (((type) == NPY_UBYTE) || \
+                                 ((type) == NPY_USHORT) || \
+                                 ((type) == NPY_UINT) ||  \
+                                 ((type) == NPY_ULONG) || \
+                                 ((type) == NPY_ULONGLONG))
 
-#define PyTypeNum_ISSIGNED(type) ((type == NPY_BYTE) || \
-                               (type == NPY_SHORT) ||   \
-                               (type == NPY_INT) ||     \
-                               (type == NPY_LONG) ||    \
-                               (type == NPY_LONGLONG))
+#define PyTypeNum_ISSIGNED(type) (((type) == NPY_BYTE) || \
+                               ((type) == NPY_SHORT) ||   \
+                               ((type) == NPY_INT) ||     \
+                               ((type) == NPY_LONG) ||    \
+                               ((type) == NPY_LONGLONG))
 
-#define PyTypeNum_ISINTEGER(type) ((type >= NPY_BYTE) &&        \
-                                (type <= NPY_ULONGLONG))
+#define PyTypeNum_ISINTEGER(type) (((type) >= NPY_BYTE) &&        \
+                                ((type) <= NPY_ULONGLONG))
 
-#define PyTypeNum_ISFLOAT(type) ((type >= NPY_FLOAT) &&  \
-                              (type <= NPY_LONGDOUBLE))
+#define PyTypeNum_ISFLOAT(type) (((type) >= NPY_FLOAT) &&  \
+                              ((type) <= NPY_LONGDOUBLE))
 
-#define PyTypeNum_ISNUMBER(type) (type <= NPY_CLONGDOUBLE)
+#define PyTypeNum_ISNUMBER(type) ((type) <= NPY_CLONGDOUBLE)
 
-#define PyTypeNum_ISSTRING(type) ((type == NPY_STRING) ||       \
-                                  (type == NPY_UNICODE))
+#define PyTypeNum_ISSTRING(type) (((type) == NPY_STRING) ||       \
+                                  ((type) == NPY_UNICODE))
 
-#define PyTypeNum_ISCOMPLEX(type) ((type >= NPY_CFLOAT) &&      \
-                                (type <= NPY_CLONGDOUBLE))
+#define PyTypeNum_ISCOMPLEX(type) (((type) >= NPY_CFLOAT) &&      \
+                                ((type) <= NPY_CLONGDOUBLE))
 
-#define PyTypeNum_ISPYTHON(type) ((type == NPY_LONG) || \
-                                  (type == NPY_DOUBLE) ||       \
-                                  (type == NPY_CDOUBLE) ||      \
-                                  (type == NPY_BOOL) || \
-                                  (type == NPY_OBJECT ))
+#define PyTypeNum_ISPYTHON(type) (((type) == NPY_LONG) || \
+                                  ((type) == NPY_DOUBLE) ||       \
+                                  ((type) == NPY_CDOUBLE) ||      \
+                                  ((type) == NPY_BOOL) || \
+                                  ((type) == NPY_OBJECT ))
 
-#define PyTypeNum_ISFLEXIBLE(type) ((type>=NPY_STRING) && \
-                                    (type<=NPY_VOID))
+#define PyTypeNum_ISFLEXIBLE(type) (((type) >=NPY_STRING) && \
+                                    ((type) <=NPY_VOID))
 
-#define PyTypeNum_ISUSERDEF(type) ((type >= NPY_USERDEF) && \
-                                   (type < NPY_USERDEF+\
+#define PyTypeNum_ISUSERDEF(type) (((type) >= NPY_USERDEF) && \
+                                   ((type) < NPY_USERDEF+\
                                     NPY_NUMUSERTYPES))
 
 #define PyTypeNum_ISEXTENDED(type) (PyTypeNum_ISFLEXIBLE(type) ||  \
@@ -1655,19 +1655,19 @@
 
 
 #define PyDataType_ISBOOL(obj) PyTypeNum_ISBOOL(_PyADt(obj))
-#define PyDataType_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISSIGNED(obj) PyTypeNum_ISSIGNED(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISINTEGER(obj) PyTypeNum_ISINTEGER(((PyArray_Descr*)obj)->type_num )
-#define PyDataType_ISFLOAT(obj) PyTypeNum_ISFLOAT(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISNUMBER(obj) PyTypeNum_ISNUMBER(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISSTRING(obj) PyTypeNum_ISSTRING(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISPYTHON(obj) PyTypeNum_ISPYTHON(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_ISOBJECT(obj) PyTypeNum_ISOBJECT(((PyArray_Descr*)obj)->type_num)
-#define PyDataType_HASFIELDS(obj) (((PyArray_Descr *)obj)->names != NULL)
+#define PyDataType_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISSIGNED(obj) PyTypeNum_ISSIGNED(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISINTEGER(obj) PyTypeNum_ISINTEGER(((PyArray_Descr*)(obj))->type_num )
+#define PyDataType_ISFLOAT(obj) PyTypeNum_ISFLOAT(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISNUMBER(obj) PyTypeNum_ISNUMBER(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISSTRING(obj) PyTypeNum_ISSTRING(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISPYTHON(obj) PyTypeNum_ISPYTHON(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_ISOBJECT(obj) PyTypeNum_ISOBJECT(((PyArray_Descr*)(obj))->type_num)
+#define PyDataType_HASFIELDS(obj) (((PyArray_Descr *)(obj))->names != NULL)
 
 #define PyArray_ISBOOL(obj) PyTypeNum_ISBOOL(PyArray_TYPE(obj))
 #define PyArray_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(PyArray_TYPE(obj))
@@ -1752,7 +1752,7 @@
 #define PyArray_DescrCheck(op) ((op)->ob_type == &PyArrayDescr_Type)
 
 #define PyArray_Check(op) ((op)->ob_type == &PyArray_Type ||            \
-                           PyObject_TypeCheck((op), &PyArray_Type))
+                           PyObject_TypeCheck(op, &PyArray_Type))
 #define PyArray_CheckExact(op) ((op)->ob_type == &PyArray_Type)
 #define PyArray_HasArrayInterfaceType(op, type, context, out)              \
         ((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \
@@ -1764,7 +1764,7 @@
 
 #define PyArray_IsZeroDim(op) (PyArray_Check(op) && (PyArray_NDIM(op) == 0))
 #define PyArray_IsScalar(obj, cls)                              \
-        (PyObject_TypeCheck((obj), &Py##cls##ArrType_Type))
+        (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
 #define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \
                                 PyArray_IsZeroDim(m))
 #define PyArray_IsPythonNumber(obj) \
@@ -1778,7 +1778,7 @@
 #define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \
                                      PyArray_CheckScalar(obj))
 
-#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? Py_INCREF(m), m : \
+#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? Py_INCREF(m), (m) : \
                                   (PyArrayObject *)(PyArray_Copy(m)))
 
 #define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \
@@ -1804,11 +1804,11 @@
 #define PyArray_EMPTY(m, dims, type, fortran) \
         PyArray_Empty(m, dims, PyArray_DescrFromType(type), fortran)
 
-#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), (val), PyArray_NBYTES(obj))
+#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, PyArray_NBYTES(obj))
 
 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
 #define NPY_REFCOUNT PyArray_REFCOUNT
-#define NPY_MAX_ELSIZE 2*SIZEOF_LONGDOUBLE
+#define NPY_MAX_ELSIZE (2*SIZEOF_LONGDOUBLE)
 
 #define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)   \
         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
@@ -1837,22 +1837,22 @@
 */
 
 #define PyArray_GETPTR1(obj, i) (void *)(PyArray_BYTES(obj) +           \
-                                         i*PyArray_STRIDES(obj)[0])
+                                         (i)*PyArray_STRIDES(obj)[0])
 
 #define PyArray_GETPTR2(obj, i, j) (void *)(PyArray_BYTES(obj) +        \
-                                            i*PyArray_STRIDES(obj)[0] + \
-                                            j*PyArray_STRIDES(obj)[1])
+                                            (i)*PyArray_STRIDES(obj)[0] + \
+                                            (j)*PyArray_STRIDES(obj)[1])
 
 #define PyArray_GETPTR3(obj, i, j, k) (void *)(PyArray_BYTES(obj) +     \
-                                               i*PyArray_STRIDES(obj)[0] + \
-                                               j*PyArray_STRIDES(obj)[1] + \
-                                               k*PyArray_STRIDES(obj)[2]) \
+                                               (i)*PyArray_STRIDES(obj)[0] + \
+                                               (j)*PyArray_STRIDES(obj)[1] + \
+                                               (k)*PyArray_STRIDES(obj)[2]) \
 
 #define PyArray_GETPTR4(obj, i, j, k, l) (void *)(PyArray_BYTES(obj) +  \
-                                                  i*PyArray_STRIDES(obj)[0] + \
-                                                  j*PyArray_STRIDES(obj)[1] + \
-                                                  k*PyArray_STRIDES(obj)[2] + \
-                                                  l*PyArray_STRIDES(obj)[3])
+                                                  (i)*PyArray_STRIDES(obj)[0] + \
+                                                  (j)*PyArray_STRIDES(obj)[1] + \
+                                                  (k)*PyArray_STRIDES(obj)[2] + \
+                                                  (l)*PyArray_STRIDES(obj)[3])
 
 #define PyArray_XDECREF_ERR(obj) \
         if (obj && (PyArray_FLAGS(obj) & NPY_UPDATEIFCOPY)) {      \

Modified: trunk/numpy/core/include/numpy/npy_interrupt.h
===================================================================
--- trunk/numpy/core/include/numpy/npy_interrupt.h	2006-11-19 20:56:57 UTC (rev 3450)
+++ trunk/numpy/core/include/numpy/npy_interrupt.h	2006-11-20 02:27:26 UTC (rev 3451)
@@ -1,8 +1,8 @@
 
-/* Signal handling: 
+/* Signal handling:
 
 This header file defines macros that allow your code to handle
-interrupts received during processing.  Interrupts that 
+interrupts received during processing.  Interrupts that
 could reasonably be handled:
 
 SIGINT, SIGABRT, SIGALRM, SIGSEGV
@@ -10,7 +10,7 @@
 ****Warning***************
 
 Do not allow code that creates temporary memory or increases reference
-counts of Python objects to be interrupted unless you handle it 
+counts of Python objects to be interrupted unless you handle it
 differently.
 
 **************************
@@ -18,11 +18,11 @@
 The mechanism for handling interrupts is conceptually simple:
 
   - replace the signal handler with our own home-grown version
-     and store the old one.  
+     and store the old one.
   - run the code to be interrupted -- if an interrupt occurs
      the handler should basically just cause a return to the
-     calling function for finish work. 
-  - restore the old signal handler 
+     calling function for finish work.
+  - restore the old signal handler
 
 Of course, every code that allows interrupts must account for
 returning via the interrupt and handle clean-up correctly.  But,
@@ -30,54 +30,54 @@
 factors.
 
  1) platform portability (i.e. Microsoft says not to use longjmp
-     to return from signal handling.  They have a __try  and __except 
+     to return from signal handling.  They have a __try  and __except
      extension to C instead but what about mingw?).
 
  2) how to handle threads: apparently whether signals are delivered to
     every thread of the process or the "invoking" thread is platform
-    dependent. --- we don't handle threads for now. 
- 
+    dependent. --- we don't handle threads for now.
+
  3) do we need to worry about re-entrance.  For now, assume the
-    code will not call-back into itself. 
+    code will not call-back into itself.
 
 Ideas:
 
  1) Start by implementing an approach that works on platforms that
-    can use setjmp and longjmp functionality and does nothing 
-    on other platforms.  
+    can use setjmp and longjmp functionality and does nothing
+    on other platforms.
 
  2) Ignore threads --- i.e. do not mix interrupt handling and threads
 
  3) Add a default signal_handler function to the C-API but have the rest
-    use macros. 
+    use macros.
 
 
 Simple Interface:
 
 
-In your C-extension: around a block of code you want to be interruptable 
-with a SIGINT 
+In your C-extension: around a block of code you want to be interruptable
+with a SIGINT
 
 NPY_SIGINT_ON
 [code]
 NPY_SIGINT_OFF
 
-In order for this to work correctly, the 
+In order for this to work correctly, the
 [code] block must not allocate any memory or alter the reference count of any
 Python objects.  In other words [code] must be interruptible so that continuation
 after NPY_SIGINT_OFF will only be "missing some computations"
 
-Interrupt handling does not work well with threads. 
+Interrupt handling does not work well with threads.
 
 */
 
-/* Add signal handling macros 
-   Make the global variable and signal handler part of the C-API 
+/* Add signal handling macros
+   Make the global variable and signal handler part of the C-API
 */
 
 #ifndef NPY_INTERRUPT_H
 #define NPY_INTERRUPT_H
-           
+
 #ifndef NPY_NO_SIGNAL
 
 #include <setjmp.h>
@@ -96,19 +96,19 @@
 #define SIGJMP_BUF sigjmp_buf
 
 #endif
-           
+
 #    define NPY_SIGINT_ON {                                             \
                    PyOS_sighandler_t _npy_sig_save;                     \
                    _npy_sig_save = PyOS_setsig(SIGINT, _PyArray_SigintHandler); \
                    if (SIGSETJMP(*((SIGJMP_BUF *)_PyArray_GetSigintBuf()), \
                                  1) == 0) {                             \
-                           
+
 #    define NPY_SIGINT_OFF }                                      \
         PyOS_setsig(SIGINT, _npy_sig_save);                       \
         }
-           
+
 #else /* NPY_NO_SIGNAL  */
-           
+
 #  define NPY_SIGINT_ON
 #  define NPY_SIGINT_OFF
 

Modified: trunk/numpy/core/include/numpy/oldnumeric.h
===================================================================
--- trunk/numpy/core/include/numpy/oldnumeric.h	2006-11-19 20:56:57 UTC (rev 3450)
+++ trunk/numpy/core/include/numpy/oldnumeric.h	2006-11-20 02:27:26 UTC (rev 3451)
@@ -21,4 +21,3 @@
 
 #undef import_array
 #define import_array() { if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); } }
-

Modified: trunk/numpy/core/include/numpy/ufuncobject.h
===================================================================
--- trunk/numpy/core/include/numpy/ufuncobject.h	2006-11-19 20:56:57 UTC (rev 3450)
+++ trunk/numpy/core/include/numpy/ufuncobject.h	2006-11-20 02:27:26 UTC (rev 3451)
@@ -57,7 +57,7 @@
 #define UFUNC_ERR_DEFAULT2                               \
         (UFUNC_ERR_PRINT << UFUNC_SHIFT_DIVIDEBYZERO) +  \
         (UFUNC_ERR_PRINT << UFUNC_SHIFT_OVERFLOW) +      \
-        (UFUNC_ERR_PRINT << UFUNC_SHIFT_INVALID)        
+        (UFUNC_ERR_PRINT << UFUNC_SHIFT_INVALID)
 
 	/* Only internal -- not exported, yet*/
 typedef struct {
@@ -211,7 +211,7 @@
 #include "__ufunc_api.h"
 
 #define UFUNC_PYVALS_NAME "UFUNC_PYVALS"
-        
+
 #define UFUNC_CHECK_ERROR(arg)                                          \
 	if (((arg)->obj && PyErr_Occurred()) ||                         \
             ((arg)->errormask &&                                        \



From numpy-svn at scipy.org  Mon Nov 20 02:01:50 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 20 Nov 2006 01:01:50 -0600 (CST)
Subject: [Numpy-svn] r3452 - trunk/numpy/fft
Message-ID: <20061120070150.E155539C23E@new.scipy.org>

Author: stefan
Date: 2006-11-20 01:01:35 -0600 (Mon, 20 Nov 2006)
New Revision: 3452

Modified:
   trunk/numpy/fft/fftpack.py
Log:
Refuse to compute FFT for invalid number of data points.


Modified: trunk/numpy/fft/fftpack.py
===================================================================
--- trunk/numpy/fft/fftpack.py	2006-11-20 02:27:26 UTC (rev 3451)
+++ trunk/numpy/fft/fftpack.py	2006-11-20 07:01:35 UTC (rev 3452)
@@ -36,6 +36,8 @@
     a = asarray(a)
 
     if n == None: n = a.shape[axis]
+    
+    if n < 1: raise ValueError("Invalid number of FFT data points (%d) specified." % n)
 
     try:
         wsave = fft_cache[n]



From numpy-svn at scipy.org  Mon Nov 20 02:07:07 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 20 Nov 2006 01:07:07 -0600 (CST)
Subject: [Numpy-svn] r3453 - trunk/numpy/fft/tests
Message-ID: <20061120070707.11F8539C126@new.scipy.org>

Author: stefan
Date: 2006-11-20 01:06:48 -0600 (Mon, 20 Nov 2006)
New Revision: 3453

Added:
   trunk/numpy/fft/tests/test_fftpack.py
Log:
Add test for fftpack.


Added: trunk/numpy/fft/tests/test_fftpack.py
===================================================================
--- trunk/numpy/fft/tests/test_fftpack.py	2006-11-20 07:01:35 UTC (rev 3452)
+++ trunk/numpy/fft/tests/test_fftpack.py	2006-11-20 07:06:48 UTC (rev 3453)
@@ -0,0 +1,12 @@
+import sys
+from numpy.testing import *
+set_package_path()
+from numpy.fft import *
+restore_path()
+
+class test_fftshift(NumpyTestCase):
+    def check_fft_n(self):
+        self.failUnlessRaises(ValueError,fft,[1,2,3],0)
+
+if __name__ == "__main__":
+    NumpyTest().run()



From numpy-svn at scipy.org  Mon Nov 20 02:25:12 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 20 Nov 2006 01:25:12 -0600 (CST)
Subject: [Numpy-svn] r3454 - trunk/numpy/core
Message-ID: <20061120072512.3ACAB39C01D@new.scipy.org>

Author: stefan
Date: 2006-11-20 01:24:53 -0600 (Mon, 20 Nov 2006)
New Revision: 3454

Modified:
   trunk/numpy/core/defchararray.py
Log:
Fix startswith operation on character arrays.


Modified: trunk/numpy/core/defchararray.py
===================================================================
--- trunk/numpy/core/defchararray.py	2006-11-20 07:06:48 UTC (rev 3453)
+++ trunk/numpy/core/defchararray.py	2006-11-20 07:24:53 UTC (rev 3454)
@@ -151,7 +151,7 @@
         for k, val in enumerate(myiter):
             newval = []
             for chk in val[1:]:
-                if chk.dtype is object_ and chk.item() is None:
+                if not chk or (chk.dtype is object_ and chk.item() is None):
                     break
                 newval.append(chk)
             this_str = val[0].rstrip('\x00')



From numpy-svn at scipy.org  Mon Nov 20 02:26:42 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 20 Nov 2006 01:26:42 -0600 (CST)
Subject: [Numpy-svn] r3455 - trunk/numpy/core/tests
Message-ID: <20061120072642.0767339C01D@new.scipy.org>

Author: stefan
Date: 2006-11-20 01:26:29 -0600 (Mon, 20 Nov 2006)
New Revision: 3455

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Add test for chararray.startswith.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-20 07:24:53 UTC (rev 3454)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-20 07:26:29 UTC (rev 3455)
@@ -590,5 +590,9 @@
         """Changeset #3443"""
         assert_valid_refcount(N.vdot)
 
+    def check_startswith(self, level=rlevel):
+        ca = N.char.array(['Hi','There'])
+        assert_equal(ca.startswith('H'),[True,False])
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Mon Nov 20 16:24:22 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 20 Nov 2006 15:24:22 -0600 (CST)
Subject: [Numpy-svn] r3456 - trunk/numpy/core/include/numpy
Message-ID: <20061120212422.8A28039C034@new.scipy.org>

Author: charris
Date: 2006-11-20 15:24:20 -0600 (Mon, 20 Nov 2006)
New Revision: 3456

Modified:
   trunk/numpy/core/include/numpy/ndarrayobject.h
Log:
Parenthesize a macro argument.
Break some long lines.
Lineup macro line continuations for easy reading.
Insert some empty lines for clarity.


Modified: trunk/numpy/core/include/numpy/ndarrayobject.h
===================================================================
--- trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-20 07:26:29 UTC (rev 3455)
+++ trunk/numpy/core/include/numpy/ndarrayobject.h	2006-11-20 21:24:20 UTC (rev 3456)
@@ -911,10 +911,10 @@
 #define NPY_COMPLEX512_FMT NPY_CLONGDOUBLE_FMT
 #endif
 
-        /* End of typedefs for numarray style bit-width names */
+/* End of typedefs for numarray style bit-width names */
 
-/* This is to typedef npy_intp to the appropriate pointer size for this platform.
- * Py_intptr_t, Py_uintptr_t are defined in pyport.h. */
+/* This is to typedef npy_intp to the appropriate pointer size for this
+ * platform.  Py_intptr_t, Py_uintptr_t are defined in pyport.h. */
 typedef Py_intptr_t npy_intp;
 typedef Py_uintptr_t npy_uintp;
 #define NPY_SIZEOF_INTP SIZEOF_PY_INTPTR_T
@@ -996,16 +996,22 @@
 #endif
 
 /* Dimensions and strides */
-#define PyDimMem_NEW(size) ((npy_intp *)PyArray_malloc(size*sizeof(npy_intp)))
+#define PyDimMem_NEW(size)                                         \
+    ((npy_intp *)PyArray_malloc(size*sizeof(npy_intp)))
+
 #define PyDimMem_FREE(ptr) PyArray_free(ptr)
-#define PyDimMem_RENEW(ptr,size) ((npy_intp *)PyArray_realloc(ptr,size*sizeof(npy_intp)))
 
+#define PyDimMem_RENEW(ptr,size)                                   \
+        ((npy_intp *)PyArray_realloc(ptr,size*sizeof(npy_intp)))
 
+
   /* These must deal with unaligned and swapped data if necessary */
 typedef PyObject * (PyArray_GetItemFunc) (void *, void *);
 typedef int (PyArray_SetItemFunc)(PyObject *, void *, void *);
 
-typedef void (PyArray_CopySwapNFunc)(void *, npy_intp, void *, npy_intp, npy_intp, int, void *);
+typedef void (PyArray_CopySwapNFunc)(void *, npy_intp, void *, npy_intp,
+                                     npy_intp, int, void *);
+
 typedef void (PyArray_CopySwapFunc)(void *, void *, int, void *);
 typedef npy_bool (PyArray_NonzeroFunc)(void *, void *);
 
@@ -1015,9 +1021,13 @@
   */
 typedef int (PyArray_CompareFunc)(const void *, const void *, void *);
 typedef int (PyArray_ArgFunc)(void*, npy_intp, npy_intp*, void *);
-typedef void (PyArray_DotFunc)(void *, npy_intp, void *, npy_intp, void *, npy_intp,
-                               void *);
-typedef void (PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, void *);
+
+typedef void (PyArray_DotFunc)(void *, npy_intp, void *, npy_intp, void *,
+                               npy_intp, void *);
+
+typedef void (PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *,
+                                       void *);
+
 typedef int (PyArray_ScanFunc)(FILE *, void *, void *, void *);
 typedef int (PyArray_FromStrFunc)(char *, void *, char **, void *);
 
@@ -1131,13 +1141,17 @@
 
 /* These are inherited for global data-type if any data-types in the field
    have them */
-#define NPY_FROM_FIELDS     (NPY_NEEDS_INIT | NPY_LIST_PICKLE | NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI)
+#define NPY_FROM_FIELDS    (NPY_NEEDS_INIT | NPY_LIST_PICKLE |             \
+                            NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI)
 
-#define NPY_OBJECT_DTYPE_FLAGS (NPY_LIST_PICKLE | NPY_USE_GETITEM | NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | NPY_NEEDS_INIT | NPY_NEEDS_PYAPI)
+#define NPY_OBJECT_DTYPE_FLAGS (NPY_LIST_PICKLE | NPY_USE_GETITEM |       \
+                                NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | \
+                                NPY_NEEDS_INIT | NPY_NEEDS_PYAPI)
 
-#define PyDataType_FLAGCHK(dtype, flag) \
-        ((dtype->hasobject & (flag)) == (flag))
-#define PyDataType_REFCHK(dtype) \
+#define PyDataType_FLAGCHK(dtype, flag)                                   \
+        (((dtype)->hasobject & (flag)) == (flag))
+
+#define PyDataType_REFCHK(dtype)                                          \
         PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)
 
 /* Change dtype hasobject to 32-bit in 1.1 and change its name */
@@ -1310,8 +1324,9 @@
  */
 
 
-#define PyArray_CHKFLAGS(m, FLAGS) \
+#define PyArray_CHKFLAGS(m, FLAGS)                              \
         ((((PyArrayObject *)(m))->flags & (FLAGS)) == (FLAGS))
+
 #define PyArray_ISCONTIGUOUS(m) PyArray_CHKFLAGS(m, NPY_CONTIGUOUS)
 #define PyArray_ISWRITEABLE(m) PyArray_CHKFLAGS(m, NPY_WRITEABLE)
 #define PyArray_ISALIGNED(m) PyArray_CHKFLAGS(m, NPY_ALIGNED)
@@ -1323,12 +1338,15 @@
 #define NPY_BEGIN_THREADS_DEF PyThreadState *_save=NULL;
 #define NPY_BEGIN_THREADS _save = PyEval_SaveThread();
 #define NPY_END_THREADS   if (_save) PyEval_RestoreThread(_save);
+
 #define NPY_BEGIN_THREADS_DESCR(dtype)                          \
         if (!(PyDataType_FLAGCHK(dtype, NPY_NEEDS_PYAPI)))      \
                 NPY_BEGIN_THREADS
+
 #define NPY_END_THREADS_DESCR(dtype)                            \
         if (!(PyDataType_FLAGCHK(dtype, NPY_NEEDS_PYAPI)))      \
                 NPY_END_THREADS
+
 #define NPY_ALLOW_C_API_DEF  PyGILState_STATE __save__;
 #define NPY_ALLOW_C_API      __save__ = PyGILState_Ensure();
 #define NPY_DISABLE_C_API    PyGILState_Release(__save__);
@@ -1369,20 +1387,20 @@
         memset((it)->coordinates, 0, ((it)->nd_m1+1)*sizeof(npy_intp)); \
 }
 
-#define _PyArray_ITER_NEXT1(it) {               \
-                (it)->dataptr += (it)->strides[0];      \
-                (it)->coordinates[0]++;                 \
+#define _PyArray_ITER_NEXT1(it) {                                       \
+                (it)->dataptr += (it)->strides[0];                      \
+                (it)->coordinates[0]++;                                 \
         }
 
 #define _PyArray_ITER_NEXT2(it) {                                       \
                 if ((it)->coordinates[1] < (it)->dims_m1[1]) {          \
                         (it)->coordinates[1]++;                         \
-                        (it)->dataptr += (it)->strides[1];                      \
+                        (it)->dataptr += (it)->strides[1];              \
                 }                                                       \
                 else {                                                  \
-                        (it)->coordinates[1] = 0;                               \
+                        (it)->coordinates[1] = 0;                       \
                         (it)->coordinates[0]++;                         \
-                        (it)->dataptr += (it)->strides[0] -                     \
+                        (it)->dataptr += (it)->strides[0] -             \
                                 (it)->backstrides[1];                   \
                 }                                                       \
         }
@@ -1408,69 +1426,71 @@
                 }                                                       \
         }
 
-#define PyArray_ITER_NEXT(it) {                                     \
-        (it)->index++;                                            \
-        if ((it)->nd_m1 == 0) {                                   \
-                _PyArray_ITER_NEXT1(it);                          \
-        }                                                               \
+#define PyArray_ITER_NEXT(it) {                                               \
+        (it)->index++;                                                        \
+        if ((it)->nd_m1 == 0) {                                               \
+                _PyArray_ITER_NEXT1(it);                                      \
+        }                                                                     \
         else if ((it)->contiguous)  (it)->dataptr += (it)->ao->descr->elsize; \
-        else if ((it)->nd_m1 == 1) {                              \
-                _PyArray_ITER_NEXT2(it);                          \
-        }                                                               \
-        else {                                                          \
-                int __npy_i;                                            \
-                for (__npy_i = (it)->nd_m1; __npy_i >= 0; __npy_i--) {          \
-                        if ((it)->coordinates[__npy_i] <                        \
-                            (it)->dims_m1[__npy_i]) {                           \
-                                (it)->coordinates[__npy_i]++;                   \
-                                (it)->dataptr += (it)->strides[__npy_i];        \
-                                break;                                  \
-                        }                                               \
-                        else {                                          \
-                                (it)->coordinates[__npy_i] = 0;         \
-                                (it)->dataptr -= (it)->backstrides[__npy_i];    \
-                        }                                               \
-                }                                                       \
-        }                                                               \
+        else if ((it)->nd_m1 == 1) {                                          \
+                _PyArray_ITER_NEXT2(it);                                      \
+        }                                                                     \
+        else {                                                                \
+                int __npy_i;                                                  \
+                for (__npy_i = (it)->nd_m1; __npy_i >= 0; __npy_i--) {        \
+                        if ((it)->coordinates[__npy_i] <                      \
+                            (it)->dims_m1[__npy_i]) {                         \
+                                (it)->coordinates[__npy_i]++;                 \
+                                (it)->dataptr += (it)->strides[__npy_i];      \
+                                break;                                        \
+                        }                                                     \
+                        else {                                                \
+                                (it)->coordinates[__npy_i] = 0;               \
+                                (it)->dataptr -= (it)->backstrides[__npy_i];  \
+                        }                                                     \
+                }                                                             \
+        }                                                                     \
 }
 
-#define PyArray_ITER_GOTO(it, destination) {                            \
-                int __npy_i;                                            \
-                (it)->index = 0;                                                \
-                (it)->dataptr = (it)->ao->data;                         \
-                for (__npy_i = (it)->nd_m1; __npy_i>=0; __npy_i--) {                    \
-                        if (destination[__npy_i] < 0) {                     \
-                                destination[__npy_i] += (it)->dims_m1[__npy_i]+1; \
-                        }                                               \
-                        (it)->dataptr += destination[__npy_i] *         \
-                                (it)->strides[__npy_i];                 \
-                        (it)->coordinates[__npy_i] = destination[__npy_i];      \
-                        (it)->index += destination[__npy_i] *                   \
-                                ( __npy_i==(it)->nd_m1 ? 1 :                    \
-                                  (it)->dims_m1[__npy_i+1]+1) ;                 \
-                }                                                       \
+#define PyArray_ITER_GOTO(it, destination) {                                  \
+                int __npy_i;                                                  \
+                (it)->index = 0;                                              \
+                (it)->dataptr = (it)->ao->data;                               \
+                for (__npy_i = (it)->nd_m1; __npy_i>=0; __npy_i--) {          \
+                        if (destination[__npy_i] < 0) {                       \
+                                destination[__npy_i] +=                       \
+                                        (it)->dims_m1[__npy_i]+1;             \
+                        }                                                     \
+                        (it)->dataptr += destination[__npy_i] *               \
+                                (it)->strides[__npy_i];                       \
+                        (it)->coordinates[__npy_i] = destination[__npy_i];    \
+                        (it)->index += destination[__npy_i] *                 \
+                                ( __npy_i==(it)->nd_m1 ? 1 :                  \
+                                  (it)->dims_m1[__npy_i+1]+1) ;               \
+                }                                                             \
         }
 
-#define PyArray_ITER_GOTO1D(it, ind) {                                  \
-                int __npy_i;                                            \
-                npy_intp __npy_ind = (npy_intp) (ind);                          \
-                if (__npy_ind < 0) __npy_ind += (it)->size;                     \
-                (it)->index = __npy_ind;                                        \
-                if ((it)->nd_m1 == 0) {                                   \
-                        (it)->dataptr = (it)->ao->data + __npy_ind *           \
-                                (it)->strides[0];                         \
-                }                                                       \
-                else if ((it)->contiguous)                                \
-                        (it)->dataptr = (it)->ao->data + __npy_ind *            \
-                                (it)->ao->descr->elsize;                        \
-                else {                                                  \
-                        (it)->dataptr = (it)->ao->data;                 \
-                        for (__npy_i = 0; __npy_i<=(it)->nd_m1; __npy_i++) {            \
-                                (it)->dataptr += (__npy_ind / (it)->factors[__npy_i]) \
-                                        * (it)->strides[__npy_i];               \
-                                __npy_ind %= (it)->factors[__npy_i];            \
-                        }                                               \
-                }                                                       \
+#define PyArray_ITER_GOTO1D(it, ind) {                                        \
+                int __npy_i;                                                  \
+                npy_intp __npy_ind = (npy_intp) (ind);                        \
+                if (__npy_ind < 0) __npy_ind += (it)->size;                   \
+                (it)->index = __npy_ind;                                      \
+                if ((it)->nd_m1 == 0) {                                       \
+                        (it)->dataptr = (it)->ao->data + __npy_ind *          \
+                                (it)->strides[0];                             \
+                }                                                             \
+                else if ((it)->contiguous)                                    \
+                        (it)->dataptr = (it)->ao->data + __npy_ind *          \
+                                (it)->ao->descr->elsize;                      \
+                else {                                                        \
+                        (it)->dataptr = (it)->ao->data;                       \
+                        for (__npy_i = 0; __npy_i<=(it)->nd_m1; __npy_i++) {  \
+                                (it)->dataptr +=                              \
+                                        (__npy_ind / (it)->factors[__npy_i])  \
+                                        * (it)->strides[__npy_i];             \
+                                __npy_ind %= (it)->factors[__npy_i];          \
+                        }                                                     \
+                }                                                             \
 }
 
 #define PyArray_ITER_DATA(it) (((PyArrayIterObject *)(it))->dataptr)
@@ -1491,49 +1511,49 @@
         PyArrayIterObject    *iters[NPY_MAXARGS];     /* iterators */
 } PyArrayMultiIterObject;
 
-#define PyArray_MultiIter_RESET(multi) {                          \
-                int __npy_mi;                                     \
-                PyArrayMultiIterObject *__npy_mul = (multi);      \
-                __npy_mul->index = 0;                             \
-                for (__npy_mi = 0; __npy_mi < __npy_mul->numiter; __npy_mi++) { \
-                        PyArray_ITER_RESET(__npy_mul->iters[__npy_mi]);   \
-                }                                                 \
+#define PyArray_MultiIter_RESET(multi) {                                      \
+                int __npy_mi;                                                 \
+                PyArrayMultiIterObject *__npy_mul = (multi);                  \
+                __npy_mul->index = 0;                                         \
+                for (__npy_mi=0; __npy_mi < __npy_mul->numiter; __npy_mi++) { \
+                        PyArray_ITER_RESET(__npy_mul->iters[__npy_mi]);       \
+                }                                                             \
         }
 
-#define PyArray_MultiIter_NEXT(multi) {                          \
-                int __npy_mi;                                     \
-                PyArrayMultiIterObject *__npy_mul = (multi);      \
-                __npy_mul->index += 1;                           \
-                for (__npy_mi=0; __npy_mi<__npy_mul->numiter; __npy_mi++) {      \
-                        PyArray_ITER_NEXT(__npy_mul->iters[__npy_mi]);   \
-                }                                                \
+#define PyArray_MultiIter_NEXT(multi) {                                       \
+                int __npy_mi;                                                 \
+                PyArrayMultiIterObject *__npy_mul = (multi);                  \
+                __npy_mul->index += 1;                                        \
+                for (__npy_mi=0; __npy_mi < __npy_mul->numiter; __npy_mi++) { \
+                        PyArray_ITER_NEXT(__npy_mul->iters[__npy_mi]);        \
+                }                                                             \
         }
 
-#define PyArray_MultiIter_GOTO(multi, dest) {                           \
-                int __npy_mi;                                           \
-                PyArrayMultiIterObject *__npy_mul = (multi);            \
-                for (__npy_mi=0; __npy_mi<__npy_mul->numiter; __npy_mi++) {             \
-                        PyArray_ITER_GOTO(__npy_mul->iters[__npy_mi], dest);    \
-                }                                                       \
-                __npy_mul->index = __npy_mul->iters[0]->index;                  \
+#define PyArray_MultiIter_GOTO(multi, dest) {                                 \
+                int __npy_mi;                                                 \
+                PyArrayMultiIterObject *__npy_mul = (multi);                  \
+                for (__npy_mi=0; __npy_mi < __npy_mul->numiter; __npy_mi++) { \
+                        PyArray_ITER_GOTO(__npy_mul->iters[__npy_mi], dest);  \
+                }                                                             \
+                __npy_mul->index = __npy_mul->iters[0]->index;                \
         }
 
-#define PyArray_MultiIter_GOTO1D(multi, ind) {                          \
-                int __npy_mi;                                           \
-                PyArrayMultiIterObject *__npy_mul = (multi);            \
-                for (__npy_mi=0; __npy_mi<__npy_mul->numiter; __npy_mi++) {             \
-                        PyArray_ITER_GOTO1D(__npy_mul->iters[__npy_mi], ind);   \
-                }                                                       \
-                __npy_mul->index = __npy_mul->iters[0]->index;                  \
+#define PyArray_MultiIter_GOTO1D(multi, ind) {                                \
+                int __npy_mi;                                                 \
+                PyArrayMultiIterObject *__npy_mul = (multi);                  \
+                for (__npy_mi=0; __npy_mi < __npy_mul->numiter; __npy_mi++) { \
+                        PyArray_ITER_GOTO1D(__npy_mul->iters[__npy_mi], ind); \
+                }                                                             \
+                __npy_mul->index = __npy_mul->iters[0]->index;                \
         }
 
-#define PyArray_MultiIter_DATA(multi, i)                        \
+#define PyArray_MultiIter_DATA(multi, i)                                      \
         (((PyArrayMultiIterObject *)(multi))->iters[i]->dataptr)
 
-#define PyArray_MultiIter_SIZE(multi)                   \
+#define PyArray_MultiIter_SIZE(multi)                                         \
         ((PyArrayMultiIterObject *)(multi))->size
 
-#define PyArray_MultiIter_NEXTi(multi, i)                               \
+#define PyArray_MultiIter_NEXTi(multi, i)                                     \
         PyArray_ITER_NEXT(((PyArrayMultiIterObject *)(multi))->iters[i])
 
 /* Store the information needed for fancy-indexing over an array */
@@ -1583,10 +1603,16 @@
  */
 
 #define PyArray_NDIM(obj) (((PyArrayObject *)(obj))->nd)
-#define PyArray_ISONESEGMENT(m) (PyArray_NDIM(m) == 0 || PyArray_CHKFLAGS(m, NPY_CONTIGUOUS) || \
+#define PyArray_ISONESEGMENT(m) (PyArray_NDIM(m) == 0 ||                      \
+                                 PyArray_CHKFLAGS(m, NPY_CONTIGUOUS) ||       \
                                  PyArray_CHKFLAGS(m, NPY_FORTRAN))
-#define PyArray_ISFORTRAN(m) (PyArray_CHKFLAGS(m, NPY_FORTRAN) && (PyArray_NDIM(m) > 1))
-#define PyArray_FORTRAN_IF(m) ((PyArray_CHKFLAGS(m, NPY_FORTRAN) ? NPY_FORTRAN : 0))
+
+#define PyArray_ISFORTRAN(m) (PyArray_CHKFLAGS(m, NPY_FORTRAN) &&             \
+                             (PyArray_NDIM(m) > 1))
+
+#define PyArray_FORTRAN_IF(m) ((PyArray_CHKFLAGS(m, NPY_FORTRAN) ?            \
+                              NPY_FORTRAN : 0))
+
 #define FORTRAN_IF PyArray_FORTRAN_IF
 #define PyArray_DATA(obj) ((void *)(((PyArrayObject *)(obj))->data))
 #define PyArray_BYTES(obj) (((PyArrayObject *)(obj))->data)
@@ -1599,53 +1625,56 @@
 #define PyArray_FLAGS(obj) (((PyArrayObject *)(obj))->flags)
 #define PyArray_ITEMSIZE(obj) (((PyArrayObject *)(obj))->descr->elsize)
 #define PyArray_TYPE(obj) (((PyArrayObject *)(obj))->descr->type_num)
-#define PyArray_GETITEM(obj,itemptr)                    \
-        ((PyArrayObject *)(obj))->descr->f->getitem((char *)(itemptr),    \
+
+#define PyArray_GETITEM(obj,itemptr)                                          \
+        ((PyArrayObject *)(obj))->descr->f->getitem((char *)(itemptr),        \
                                                  (PyArrayObject *)(obj));
-#define PyArray_SETITEM(obj,itemptr,v)                                  \
-        ((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)(v),      \
-                                                    (char *)(itemptr),  \
+
+#define PyArray_SETITEM(obj,itemptr,v)                                        \
+        ((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)(v),          \
+                                                    (char *)(itemptr),        \
                                                     (PyArrayObject *)(obj));
 
 
 #define PyTypeNum_ISBOOL(type) ((type) == NPY_BOOL)
-#define PyTypeNum_ISUNSIGNED(type) (((type) == NPY_UBYTE) || \
-                                 ((type) == NPY_USHORT) || \
-                                 ((type) == NPY_UINT) ||  \
-                                 ((type) == NPY_ULONG) || \
+
+#define PyTypeNum_ISUNSIGNED(type) (((type) == NPY_UBYTE) ||   \
+                                 ((type) == NPY_USHORT) ||     \
+                                 ((type) == NPY_UINT) ||       \
+                                 ((type) == NPY_ULONG) ||      \
                                  ((type) == NPY_ULONGLONG))
 
-#define PyTypeNum_ISSIGNED(type) (((type) == NPY_BYTE) || \
-                               ((type) == NPY_SHORT) ||   \
-                               ((type) == NPY_INT) ||     \
-                               ((type) == NPY_LONG) ||    \
+#define PyTypeNum_ISSIGNED(type) (((type) == NPY_BYTE) ||      \
+                               ((type) == NPY_SHORT) ||        \
+                               ((type) == NPY_INT) ||          \
+                               ((type) == NPY_LONG) ||         \
                                ((type) == NPY_LONGLONG))
 
-#define PyTypeNum_ISINTEGER(type) (((type) >= NPY_BYTE) &&        \
+#define PyTypeNum_ISINTEGER(type) (((type) >= NPY_BYTE) &&     \
                                 ((type) <= NPY_ULONGLONG))
 
-#define PyTypeNum_ISFLOAT(type) (((type) >= NPY_FLOAT) &&  \
+#define PyTypeNum_ISFLOAT(type) (((type) >= NPY_FLOAT) &&      \
                               ((type) <= NPY_LONGDOUBLE))
 
 #define PyTypeNum_ISNUMBER(type) ((type) <= NPY_CLONGDOUBLE)
 
-#define PyTypeNum_ISSTRING(type) (((type) == NPY_STRING) ||       \
+#define PyTypeNum_ISSTRING(type) (((type) == NPY_STRING) ||    \
                                   ((type) == NPY_UNICODE))
 
-#define PyTypeNum_ISCOMPLEX(type) (((type) >= NPY_CFLOAT) &&      \
+#define PyTypeNum_ISCOMPLEX(type) (((type) >= NPY_CFLOAT) &&   \
                                 ((type) <= NPY_CLONGDOUBLE))
 
-#define PyTypeNum_ISPYTHON(type) (((type) == NPY_LONG) || \
-                                  ((type) == NPY_DOUBLE) ||       \
-                                  ((type) == NPY_CDOUBLE) ||      \
-                                  ((type) == NPY_BOOL) || \
+#define PyTypeNum_ISPYTHON(type) (((type) == NPY_LONG) ||      \
+                                  ((type) == NPY_DOUBLE) ||    \
+                                  ((type) == NPY_CDOUBLE) ||   \
+                                  ((type) == NPY_BOOL) ||      \
                                   ((type) == NPY_OBJECT ))
 
-#define PyTypeNum_ISFLEXIBLE(type) (((type) >=NPY_STRING) && \
+#define PyTypeNum_ISFLEXIBLE(type) (((type) >=NPY_STRING) &&  \
                                     ((type) <=NPY_VOID))
 
 #define PyTypeNum_ISUSERDEF(type) (((type) >= NPY_USERDEF) && \
-                                   ((type) < NPY_USERDEF+\
+                                   ((type) < NPY_USERDEF+     \
                                     NPY_NUMUSERTYPES))
 
 #define PyTypeNum_ISEXTENDED(type) (PyTypeNum_ISFLEXIBLE(type) ||  \
@@ -1705,6 +1734,7 @@
 
 #define PyArray_FLAGSWAP(m, flags) (PyArray_CHKFLAGS(m, flags) &&       \
                                     PyArray_ISNOTSWAPPED(m))
+
 #define PyArray_ISCARRAY(m) PyArray_FLAGSWAP(m, NPY_CARRAY)
 #define PyArray_ISCARRAY_RO(m) PyArray_FLAGSWAP(m, NPY_CARRAY_RO)
 #define PyArray_ISFARRAY(m) PyArray_FLAGSWAP(m, NPY_FARRAY)
@@ -1751,83 +1781,106 @@
 
 #define PyArray_DescrCheck(op) ((op)->ob_type == &PyArrayDescr_Type)
 
-#define PyArray_Check(op) ((op)->ob_type == &PyArray_Type ||            \
+#define PyArray_Check(op) ((op)->ob_type == &PyArray_Type ||                  \
                            PyObject_TypeCheck(op, &PyArray_Type))
+
 #define PyArray_CheckExact(op) ((op)->ob_type == &PyArray_Type)
-#define PyArray_HasArrayInterfaceType(op, type, context, out)              \
-        ((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \
-         (((out)=PyArray_FromInterface(op)) != Py_NotImplemented) ||    \
-         (((out)=PyArray_FromArrayAttr(op, type, context)) !=           \
+
+#define PyArray_HasArrayInterfaceType(op, type, context, out)                 \
+        ((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) ||    \
+         (((out)=PyArray_FromInterface(op)) != Py_NotImplemented) ||          \
+         (((out)=PyArray_FromArrayAttr(op, type, context)) !=                 \
           Py_NotImplemented))
-#define PyArray_HasArrayInterface(op, out)              \
+
+#define PyArray_HasArrayInterface(op, out)                                    \
         PyArray_HasArrayInterfaceType(op, NULL, NULL, out)
 
 #define PyArray_IsZeroDim(op) (PyArray_Check(op) && (PyArray_NDIM(op) == 0))
-#define PyArray_IsScalar(obj, cls)                              \
+
+#define PyArray_IsScalar(obj, cls)                                            \
         (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
-#define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \
+
+#define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) ||               \
                                 PyArray_IsZeroDim(m))
-#define PyArray_IsPythonNumber(obj) \
-        (PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) || \
+
+#define PyArray_IsPythonNumber(obj)                                           \
+        (PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) ||    \
          PyLong_Check(obj) || PyBool_Check(obj))
-#define PyArray_IsPythonScalar(obj) \
-        (PyArray_IsPythonNumber(obj) || PyString_Check(obj) ||  \
+
+#define PyArray_IsPythonScalar(obj)                                           \
+        (PyArray_IsPythonNumber(obj) || PyString_Check(obj) ||                \
          PyUnicode_Check(obj))
-#define PyArray_IsAnyScalar(obj)                                        \
+
+#define PyArray_IsAnyScalar(obj)                                              \
         (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
-#define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \
+
+#define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) ||           \
                                      PyArray_CheckScalar(obj))
 
-#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? Py_INCREF(m), (m) : \
+#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ?                   \
+                                  Py_INCREF(m), (m) :                         \
                                   (PyArrayObject *)(PyArray_Copy(m)))
 
-#define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \
-                                  PyArray_CompareLists(PyArray_DIMS(a1), \
-                                                       PyArray_DIMS(a2), \
+#define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) &&   \
+                                  PyArray_CompareLists(PyArray_DIMS(a1),      \
+                                                       PyArray_DIMS(a2),      \
                                                        PyArray_NDIM(a1)))
+
 #define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m))
 #define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
 #define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
-#define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags, NULL)
-#define PyArray_FROM_OT(m,type) PyArray_FromAny(m, PyArray_DescrFromType(type), \
-                                                      0, 0, 0, NULL);
-#define PyArray_FROM_OTF(m, type, flags)                                \
-        PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0,           \
-                        (((flags) & NPY_ENSURECOPY) ?                       \
+
+#define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags,   \
+                                                      NULL)
+
+#define PyArray_FROM_OT(m,type) PyArray_FromAny(m,                            \
+                                PyArray_DescrFromType(type), 0, 0, 0, NULL);
+
+#define PyArray_FROM_OTF(m, type, flags)                                      \
+        PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0,                 \
+                        (((flags) & NPY_ENSURECOPY) ?                         \
                          ((flags) | NPY_DEFAULT) : (flags)), NULL)
-#define PyArray_FROMANY(m, type, min, max, flags)                       \
-        PyArray_FromAny(m, PyArray_DescrFromType(type), min, max,       \
-                        (((flags) & NPY_ENSURECOPY) ?                       \
+
+#define PyArray_FROMANY(m, type, min, max, flags)                             \
+        PyArray_FromAny(m, PyArray_DescrFromType(type), min, max,             \
+                        (((flags) & NPY_ENSURECOPY) ?                         \
                          (flags) | NPY_DEFAULT : (flags)), NULL)
-#define PyArray_ZEROS(m, dims, type, fortran) \
+
+#define PyArray_ZEROS(m, dims, type, fortran)                                 \
         PyArray_Zeros(m, dims, PyArray_DescrFromType(type), fortran)
-#define PyArray_EMPTY(m, dims, type, fortran) \
+
+#define PyArray_EMPTY(m, dims, type, fortran)                                 \
         PyArray_Empty(m, dims, PyArray_DescrFromType(type), fortran)
 
-#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, PyArray_NBYTES(obj))
+#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val,            \
+                                           PyArray_NBYTES(obj))
 
 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
 #define NPY_REFCOUNT PyArray_REFCOUNT
 #define NPY_MAX_ELSIZE (2*SIZEOF_LONGDOUBLE)
 
-#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)   \
-        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
+#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)             \
+        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \
                               max_depth, NPY_DEFAULT, NULL)
 
-#define PyArray_EquivArrTypes(a1, a2)                                   \
+#define PyArray_EquivArrTypes(a1, a2)                                         \
         PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
 
-#define PyArray_EquivByteorders(b1, b2) \
+#define PyArray_EquivByteorders(b1, b2)                                       \
         (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
 
-#define PyArray_SimpleNew(nd, dims, typenum) \
+#define PyArray_SimpleNew(nd, dims, typenum)                                  \
         PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)
-#define PyArray_SimpleNewFromData(nd, dims, typenum, data) \
-        PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, data, 0, NPY_CARRAY, NULL)
-#define PyArray_SimpleNewFromDescr(nd, dims, descr) \
-        PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, NULL, NULL, 0, NULL)
 
-#define PyArray_ToScalar(data, arr) \
+#define PyArray_SimpleNewFromData(nd, dims, typenum, data)                    \
+        PyArray_New(&PyArray_Type, nd, dims, typenum, NULL,                   \
+                    data, 0, NPY_CARRAY, NULL)
+
+#define PyArray_SimpleNewFromDescr(nd, dims, descr)                           \
+        PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims,                  \
+                             NULL, NULL, 0, NULL)
+
+#define PyArray_ToScalar(data, arr)                                           \
         PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)
 
 
@@ -1836,66 +1889,67 @@
    inline the constants inside a for loop making it a moot point
 */
 
-#define PyArray_GETPTR1(obj, i) (void *)(PyArray_BYTES(obj) +           \
+#define PyArray_GETPTR1(obj, i) (void *)(PyArray_BYTES(obj) +                 \
                                          (i)*PyArray_STRIDES(obj)[0])
 
-#define PyArray_GETPTR2(obj, i, j) (void *)(PyArray_BYTES(obj) +        \
-                                            (i)*PyArray_STRIDES(obj)[0] + \
+#define PyArray_GETPTR2(obj, i, j) (void *)(PyArray_BYTES(obj) +              \
+                                            (i)*PyArray_STRIDES(obj)[0] +     \
                                             (j)*PyArray_STRIDES(obj)[1])
 
-#define PyArray_GETPTR3(obj, i, j, k) (void *)(PyArray_BYTES(obj) +     \
-                                               (i)*PyArray_STRIDES(obj)[0] + \
-                                               (j)*PyArray_STRIDES(obj)[1] + \
-                                               (k)*PyArray_STRIDES(obj)[2]) \
+#define PyArray_GETPTR3(obj, i, j, k) (void *)(PyArray_BYTES(obj) +           \
+                                            (i)*PyArray_STRIDES(obj)[0] +     \
+                                            (j)*PyArray_STRIDES(obj)[1] +     \
+                                            (k)*PyArray_STRIDES(obj)[2])      \
 
-#define PyArray_GETPTR4(obj, i, j, k, l) (void *)(PyArray_BYTES(obj) +  \
-                                                  (i)*PyArray_STRIDES(obj)[0] + \
-                                                  (j)*PyArray_STRIDES(obj)[1] + \
-                                                  (k)*PyArray_STRIDES(obj)[2] + \
-                                                  (l)*PyArray_STRIDES(obj)[3])
+#define PyArray_GETPTR4(obj, i, j, k, l) (void *)(PyArray_BYTES(obj) +        \
+                                            (i)*PyArray_STRIDES(obj)[0] +     \
+                                            (j)*PyArray_STRIDES(obj)[1] +     \
+                                            (k)*PyArray_STRIDES(obj)[2] +     \
+                                            (l)*PyArray_STRIDES(obj)[3])
 
 #define PyArray_XDECREF_ERR(obj) \
-        if (obj && (PyArray_FLAGS(obj) & NPY_UPDATEIFCOPY)) {      \
-                PyArray_FLAGS(PyArray_BASE(obj)) |= NPY_WRITEABLE; \
-                PyArray_FLAGS(obj) &= ~NPY_UPDATEIFCOPY; \
-        }\
+        if (obj && (PyArray_FLAGS(obj) & NPY_UPDATEIFCOPY)) {                 \
+                PyArray_FLAGS(PyArray_BASE(obj)) |= NPY_WRITEABLE;            \
+                PyArray_FLAGS(obj) &= ~NPY_UPDATEIFCOPY;                      \
+        }                                                                     \
         Py_XDECREF(obj)
 
-#define PyArray_DESCR_REPLACE(descr) do {       \
-                PyArray_Descr *_new_;                   \
-                _new_ = PyArray_DescrNew(descr);        \
-                Py_XDECREF(descr);                      \
-                descr = _new_;                          \
+#define PyArray_DESCR_REPLACE(descr) do {                                     \
+                PyArray_Descr *_new_;                                         \
+                _new_ = PyArray_DescrNew(descr);                              \
+                Py_XDECREF(descr);                                            \
+                descr = _new_;                                                \
         } while(0)
 
 /* Copy should always return contiguous array */
 #define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER)
 
-#define PyArray_FromObject(op, type, min_depth, max_depth)              \
-        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,     \
+#define PyArray_FromObject(op, type, min_depth, max_depth)                    \
+        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \
                               max_depth, NPY_BEHAVED | NPY_ENSUREARRAY, NULL)
 
-#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth)    \
-        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,     \
+#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth)          \
+        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \
                               max_depth, NPY_DEFAULT | NPY_ENSUREARRAY, NULL)
 
-#define PyArray_CopyFromObject(op, type, min_depth, max_depth)          \
-        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,     \
-                        max_depth, NPY_ENSURECOPY | NPY_DEFAULT | NPY_ENSUREARRAY, NULL)
+#define PyArray_CopyFromObject(op, type, min_depth, max_depth)                \
+        PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \
+                        max_depth, NPY_ENSURECOPY | NPY_DEFAULT |             \
+                        NPY_ENSUREARRAY, NULL)
 
-#define PyArray_Cast(mp, type_num) \
+#define PyArray_Cast(mp, type_num)                                            \
         PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
 
-#define PyArray_Take(ap, items, axis) \
+#define PyArray_Take(ap, items, axis)                                         \
         PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
 
-#define PyArray_Put(ap, items, values) \
+#define PyArray_Put(ap, items, values)                                        \
         PyArray_PutTo(ap, items, values, NPY_RAISE)
 
 /* Compatibility with old Numeric stuff -- don't use in new code */
 
-#define PyArray_FromDimsAndData(nd, d, type, data) \
-        PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type), \
+#define PyArray_FromDimsAndData(nd, d, type, data)                            \
+        PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type),   \
                                         data)
 
 #include "old_defines.h"



From numpy-svn at scipy.org  Tue Nov 21 12:13:16 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 21 Nov 2006 11:13:16 -0600 (CST)
Subject: [Numpy-svn] r3457 - trunk/numpy
Message-ID: <20061121171316.F049639C264@new.scipy.org>

Author: cookedm
Date: 2006-11-21 11:13:14 -0600 (Tue, 21 Nov 2006)
New Revision: 3457

Modified:
   trunk/numpy/add_newdocs.py
Log:
better doc for a.dump and a.dumps

Modified: trunk/numpy/add_newdocs.py
===================================================================
--- trunk/numpy/add_newdocs.py	2006-11-20 21:24:20 UTC (rev 3456)
+++ trunk/numpy/add_newdocs.py	2006-11-21 17:13:14 UTC (rev 3457)
@@ -771,8 +771,10 @@
 
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('dump',
-    """a.dump(file) Dump to specified file.
+    """a.dump(file) Dump a pickle of the array to the specified file.
 
+    The array can be read back with pickle.load or numpy.load
+
     Arguments:
         file -- string naming the dump file.
 
@@ -780,8 +782,9 @@
 
 
 add_newdoc('numpy.core.multiarray', 'ndarray', ('dumps',
-    """a.dumps() -> string containing the dump?
+    """a.dumps() returns the pickle of the array as a string.
 
+    pickle.loads or numpy.loads will convert the string back to an array.
     """))
 
 



From numpy-svn at scipy.org  Wed Nov 22 06:19:22 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 22 Nov 2006 05:19:22 -0600 (CST)
Subject: [Numpy-svn] r3458 - in trunk/numpy: numarray oldnumeric
Message-ID: <20061122111922.AE29D39C043@new.scipy.org>

Author: stefan
Date: 2006-11-22 05:19:08 -0600 (Wed, 22 Nov 2006)
New Revision: 3458

Modified:
   trunk/numpy/numarray/linear_algebra.py
   trunk/numpy/oldnumeric/matrix.py
   trunk/numpy/oldnumeric/mlab.py
Log:
Don't share __all__ between numarray.linear_algebra and oldnumeric.linear_algebra.


Modified: trunk/numpy/numarray/linear_algebra.py
===================================================================
--- trunk/numpy/numarray/linear_algebra.py	2006-11-21 17:13:14 UTC (rev 3457)
+++ trunk/numpy/numarray/linear_algebra.py	2006-11-22 11:19:08 UTC (rev 3458)
@@ -3,7 +3,7 @@
 
 import numpy.oldnumeric.linear_algebra as nol
 
-__all__ = nol.__all__
+__all__ = list(nol.__all__)
 __all__ += ['qr_decomposition']
 
 from numpy.linalg import qr as _qr

Modified: trunk/numpy/oldnumeric/matrix.py
===================================================================
--- trunk/numpy/oldnumeric/matrix.py	2006-11-21 17:13:14 UTC (rev 3457)
+++ trunk/numpy/oldnumeric/matrix.py	2006-11-22 11:19:08 UTC (rev 3458)
@@ -7,7 +7,7 @@
 from user_array import UserArray, asarray
 import numpy.oldnumeric as Numeric
 from numpy.oldnumeric import dot, identity, multiply
-import linear_algebra as LinearAlgebra
+import numpy.oldnumeric.linear_algebra as LinearAlgebra
 from numpy import matrix as Matrix, squeeze
 
 # Hidden names that will be the same. 

Modified: trunk/numpy/oldnumeric/mlab.py
===================================================================
--- trunk/numpy/oldnumeric/mlab.py	2006-11-21 17:13:14 UTC (rev 3457)
+++ trunk/numpy/oldnumeric/mlab.py	2006-11-22 11:19:08 UTC (rev 3458)
@@ -2,8 +2,8 @@
 
 __all__ = ['rand', 'tril', 'trapz', 'hanning', 'rot90', 'triu', 'diff', 'angle', 'roots', 'ptp', 'kaiser', 'randn', 'cumprod', 'diag', 'msort', 'LinearAlgebra', 'RandomArray', 'prod', 'std', 'hamming', 'flipud', 'max', 'blackman', 'corrcoef', 'bartlett', 'eye', 'squeeze', 'sinc', 'tri', 'cov', 'svd', 'min', 'median', 'fliplr', 'eig', 'mean']
 
-import linear_algebra as LinearAlgebra
-import random_array as RandomArray
+import numpy.oldnumeric.linear_algebra as LinearAlgebra
+import numpy.oldnumeric.random_array as RandomArray
 from numpy import tril, trapz as _Ntrapz, hanning, rot90, triu, diff, \
      angle, roots, ptp as _Nptp, kaiser, cumprod as _Ncumprod, \
      diag, msort, prod as _Nprod, std as _Nstd, hamming, flipud, \



From numpy-svn at scipy.org  Wed Nov 22 12:02:47 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 22 Nov 2006 11:02:47 -0600 (CST)
Subject: [Numpy-svn] r3459 - trunk/numpy/lib
Message-ID: <20061122170247.B283A39C28D@new.scipy.org>

Author: oliphant
Date: 2006-11-22 11:02:43 -0600 (Wed, 22 Nov 2006)
New Revision: 3459

Modified:
   trunk/numpy/lib/polynomial.py
Log:
Fix early return in polyadd.

Modified: trunk/numpy/lib/polynomial.py
===================================================================
--- trunk/numpy/lib/polynomial.py	2006-11-22 11:19:08 UTC (rev 3458)
+++ trunk/numpy/lib/polynomial.py	2006-11-22 17:02:43 UTC (rev 3459)
@@ -348,7 +348,7 @@
     a2 = atleast_1d(a2)
     diff = len(a2) - len(a1)
     if diff == 0:
-        return a1 + a2
+        val = a1 + a2
     elif diff > 0:
         zr = NX.zeros(diff, a1.dtype)
         val = NX.concatenate((zr, a1)) + a2



From numpy-svn at scipy.org  Wed Nov 22 12:03:22 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 22 Nov 2006 11:03:22 -0600 (CST)
Subject: [Numpy-svn] r3460 - trunk/numpy/lib
Message-ID: <20061122170322.A289139C286@new.scipy.org>

Author: oliphant
Date: 2006-11-22 11:03:19 -0600 (Wed, 22 Nov 2006)
New Revision: 3460

Modified:
   trunk/numpy/lib/polynomial.py
Log:
Fix early return in polysub.

Modified: trunk/numpy/lib/polynomial.py
===================================================================
--- trunk/numpy/lib/polynomial.py	2006-11-22 17:02:43 UTC (rev 3459)
+++ trunk/numpy/lib/polynomial.py	2006-11-22 17:03:19 UTC (rev 3460)
@@ -367,7 +367,7 @@
     a2 = atleast_1d(a2)
     diff = len(a2) - len(a1)
     if diff == 0:
-        return a1 - a2
+        val = a1 - a2
     elif diff > 0:
         zr = NX.zeros(diff, a1.dtype)
         val = NX.concatenate((zr, a1)) - a2



From numpy-svn at scipy.org  Mon Nov 27 01:48:08 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 27 Nov 2006 00:48:08 -0600 (CST)
Subject: [Numpy-svn] r3461 - trunk/numpy/core/tests
Message-ID: <20061127064808.5C84639C010@new.scipy.org>

Author: stefan
Date: 2006-11-27 00:47:56 -0600 (Mon, 27 Nov 2006)
New Revision: 3461

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Remove dependencies on default integer type in test for ticket #372.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-22 17:03:19 UTC (rev 3460)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-27 06:47:56 UTC (rev 3461)
@@ -575,9 +575,7 @@
         dt = N.dtype([('f0',"i4"),('f1',"i4")])
         for a in [N.array([(1,2),(3,4)],"i4,i4"),
                   N.rec.array([(1,2),(3,4)],"i4,i4"),
-                  N.rec.array([(1,2),(3,4)]),
-                  N.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
-                  N.rec.fromarrays([(1,2),(3,4)])]:
+                  N.rec.fromarrays([(1,2),(3,4)],"i4,i4")]:
             assert_equal(a.dtype,dt)
 
     def check_refcount_vectorize(self, level=rlevel):



From numpy-svn at scipy.org  Mon Nov 27 01:54:52 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 27 Nov 2006 00:54:52 -0600 (CST)
Subject: [Numpy-svn] r3462 - trunk/numpy/core/tests
Message-ID: <20061127065452.1454039C010@new.scipy.org>

Author: stefan
Date: 2006-11-27 00:54:44 -0600 (Mon, 27 Nov 2006)
New Revision: 3462

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Revert previous change and rather check for both possible outcomes.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2006-11-27 06:47:56 UTC (rev 3461)
+++ trunk/numpy/core/tests/test_regression.py	2006-11-27 06:54:44 UTC (rev 3462)
@@ -572,11 +572,14 @@
 
     def check_recarray_fields(self, level=rlevel):
         """Ticket #372"""
-        dt = N.dtype([('f0',"i4"),('f1',"i4")])
+        dt0 = N.dtype([('f0','i4'),('f1','i4')])
+        dt1 = N.dtype([('f0','i8'),('f1','i8')])
         for a in [N.array([(1,2),(3,4)],"i4,i4"),
                   N.rec.array([(1,2),(3,4)],"i4,i4"),
-                  N.rec.fromarrays([(1,2),(3,4)],"i4,i4")]:
-            assert_equal(a.dtype,dt)
+                  N.rec.array([(1,2),(3,4)]),
+                  N.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
+                  N.rec.fromarrays([(1,2),(3,4)])]:
+            assert(a.dtype in [dt0,dt1])
 
     def check_refcount_vectorize(self, level=rlevel):
         """Ticket #378"""



From numpy-svn at scipy.org  Thu Nov 30 14:04:09 2006
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 30 Nov 2006 13:04:09 -0600 (CST)
Subject: [Numpy-svn] r3463 - trunk/numpy/core
Message-ID: <20061130190409.0A2B839C018@new.scipy.org>

Author: rkern
Date: 2006-11-30 13:04:09 -0600 (Thu, 30 Nov 2006)
New Revision: 3463

Modified:
   trunk/numpy/core/numeric.py
Log:
Docstring improvements.

Modified: trunk/numpy/core/numeric.py
===================================================================
--- trunk/numpy/core/numeric.py	2006-11-27 06:54:44 UTC (rev 3462)
+++ trunk/numpy/core/numeric.py	2006-11-30 19:04:09 UTC (rev 3463)
@@ -207,18 +207,17 @@
     return mode
 
 def correlate(a,v,mode='valid'):
-    """Return the discrete, linear correlation of 1-D sequences
-    a and v; mode can be 0 (valid), 1 (same), or 2 (full)
-    to specify the size of the resulting sequence
+    """Return the discrete, linear correlation of 1-D sequences a and v; mode
+    can be 'valid', 'same', or 'full' to specify the size of the resulting
+    sequence
     """
     mode = _mode_from_name(mode)
     return multiarray.correlate(a,v,mode)
 
 
 def convolve(a,v,mode='full'):
-    """Returns the discrete, linear convolution of 1-D
-    sequences a and v; mode can be 0 (valid), 1 (same), or 2 (full)
-    to specify size of the resulting sequence.
+    """Returns the discrete, linear convolution of 1-D sequences a and v; mode
+    can be 'valid', 'same', or 'full' to specify size of the resulting sequence.
     """
     if (len(v) > len(a)):
         a, v = v, a
@@ -229,8 +228,9 @@
 dot = multiarray.dot
 
 def outer(a,b):
-    """outer(a,b) returns the outer product of two vectors.
-    result(i,j) = a(i)*b(j) when a and b are vectors
+    """Returns the outer product of two vectors.
+
+    result[i,j] = a[i]*b[j] when a and b are vectors.
     Will accept any arguments that can be made into vectors.
     """
     a = asarray(a)
@@ -239,8 +239,10 @@
 
 def vdot(a, b):
     """Returns the dot product of 2 vectors (or anything that can be made into
-    a vector). NB: this is not the same as `dot`, as it takes the conjugate
-    of its first argument if complex and always returns a scalar."""
+    a vector).
+    
+    Note: this is not the same as `dot`, as it takes the conjugate of its first
+    argument if complex and always returns a scalar."""
     return dot(asarray(a).ravel().conj(), asarray(b).ravel())
 
 # try to import blas optimized dot if available
@@ -474,8 +476,8 @@
 little_endian = (sys.byteorder == 'little')
 
 def indices(dimensions, dtype=int):
-    """indices(dimensions,dtype=int) returns an array representing a grid
-    of indices with row-only, and column-only variation.
+    """Returns an array representing a grid of indices with row-only, and
+    column-only variation.
     """
     tmp = ones(dimensions, dtype)
     lst = []
@@ -484,17 +486,17 @@
     return array(lst)
 
 def fromfunction(function, shape, **kwargs):
-    """returns an array constructed by calling a function on a tuple
-    of number grids.  The function should accept as many arguments as the
-    length of shape and work on array inputs.  The shape argument is a 
-    sequence of numbers indicating the length of the desired output 
-    for each axis.
+    """Returns an array constructed by calling a function on a tuple of number
+    grids.
+    
+    The function should accept as many arguments as the length of shape and work
+    on array inputs.  The shape argument is a sequence of numbers indicating the
+    length of the desired output for each axis.
 
-    The function can also accept keyword arguments (except dtype), 
-    which will be passed through fromfunction to the function itself.
-    The dtype argument (default float) determines the data-type of 
-    the index grid passed to the function. 
-    
+    The function can also accept keyword arguments (except dtype), which will be
+    passed through fromfunction to the function itself.  The dtype argument
+    (default float) determines the data-type of the index grid passed to the
+    function. 
     """
     dtype = kwargs.pop('dtype', float)
     args = indices(shape, dtype=dtype)
@@ -586,8 +588,8 @@
 # These might wind up in a special abbreviations module
 
 def ones(shape, dtype=None, order='C'):
-    """ones(shape, dtype=None) returns an array of the given
-    dimensions which is initialized to all ones.
+    """Returns an array of the given dimensions which is initialized to all
+    ones.
     """
     a = empty(shape, dtype, order)
     a.fill(1)
@@ -596,25 +598,33 @@
     #a+=1
     return a
 
-def identity(n,dtype=None):
-    """identity(n) returns the identity 2-d array of shape n x n.
+def identity(n, dtype=None):
+    """Returns the identity 2-d array of shape n x n.
+
+    identity(n)[i,j] == 1 for all i == j
+                     == 0 for all i != j
     """
     a = array([1]+n*[0],dtype=dtype)
     b = empty((n,n),dtype=dtype)
+
+    # Note that this assignment depends on the convention that since the a array
+    # is shorter than the flattened b array, then the a array will be repeated
+    # until it is the appropriate size. Given a's construction, this nicely sets
+    # the diagonal to all ones.
     b.flat = a
     return b
 
-def allclose (a, b, rtol=1.e-5, atol=1.e-8):
-    """ allclose(a,b,rtol=1.e-5,atol=1.e-8)
-        Returns true if all components of a and b are equal
-        subject to given tolerances.
-        The relative error rtol must be positive and << 1.0
-        The absolute error atol comes into play for those elements
-        of y that are very small or zero; it says how small x must be also.
+def allclose(a, b, rtol=1.e-5, atol=1.e-8):
+    """Returns True if all components of a and b are equal subject to given
+    tolerances.
+
+    The relative error rtol must be positive and << 1.0
+    The absolute error atol usually comes into play for those elements of b that
+    are very small or zero; it says how small a must be also.
     """
     x = array(a, copy=False)
     y = array(b, copy=False)
-    d = less(absolute(x-y), atol + rtol * absolute(y))
+    d = less_equal(absolute(x-y), atol + rtol * absolute(y))
     return d.ravel().all()