[Numpy-svn] r3385 - trunk/numpy/f2py/lib/parser

numpy-svn at scipy.org numpy-svn at scipy.org
Mon Oct 23 17:42:03 CDT 2006


Author: pearu
Date: 2006-10-23 17:41:47 -0500 (Mon, 23 Oct 2006)
New Revision: 3385

Modified:
   trunk/numpy/f2py/lib/parser/expressions.py
   trunk/numpy/f2py/lib/parser/pattern_tools.py
   trunk/numpy/f2py/lib/parser/test_expressions.py
Log:
F2PY G3: Cont implementing Fortran expression parser, almost finished.

Modified: trunk/numpy/f2py/lib/parser/expressions.py
===================================================================
--- trunk/numpy/f2py/lib/parser/expressions.py	2006-10-23 22:22:41 UTC (rev 3384)
+++ trunk/numpy/f2py/lib/parser/expressions.py	2006-10-23 22:41:47 UTC (rev 3385)
@@ -33,9 +33,6 @@
 class NoMatchError(Exception):
     pass
 
-class NoSubClasses:
-    pass
-
 class Base(object):
 
     subclasses = {}
@@ -51,8 +48,6 @@
             obj.string = string
             if hasattr(cls, 'init'):
                 obj.init(*result)
-            #if cls.__dict__.has_key('init'):
-            #    obj.init(*result)
             return obj
         elif isinstance(result, Base):
             return result
@@ -66,79 +61,8 @@
             raise AssertionError,`result`
         raise NoMatchError,'%s: %r' % (cls.__name__, string)
 
-    default_match = staticmethod(lambda string: None)
-
     findall = staticmethod(re.compile(r'(_F2PY_STRING_CONSTANT_\d+_|F2PY_EXPR_TUPLE_\d+)').findall)
     
-    def match_binary_operand_right(lhs_cls, op_pattern, rhs_cls, string):
-        line, repmap = string_replace_map(string)
-        t = op_pattern.rsplit(line)
-        if t is None: return
-        lhs, op, rhs = t
-        for k in Base.findall(lhs):
-            lhs = lhs.replace(k, repmap[k])
-        for k in Base.findall(rhs):
-            rhs = rhs.replace(k, repmap[k])
-        lhs_obj = lhs_cls(lhs)
-        rhs_obj = rhs_cls(rhs)
-        return lhs_obj, t[1], rhs_obj
-    match_binary_operand_right = staticmethod(match_binary_operand_right)
-
-    def match_binary_unary_operand_right(lhs_cls, op_pattern, rhs_cls, string):
-        line, repmap = string_replace_map(string)
-        t = op_pattern.rsplit(line)
-        if t is None: return
-        lhs, op, rhs = t
-        if lhs: 
-            for k in Base.findall(lhs):
-                lhs = lhs.replace(k, repmap[k])
-        for k in Base.findall(rhs):
-            rhs = rhs.replace(k, repmap[k])
-        rhs_obj = rhs_cls(rhs)
-        if lhs:
-            lhs_obj = lhs_cls(lhs)
-            return lhs_obj, t[1], rhs_obj
-        else:
-            return None, t[1], rhs_obj
-    match_binary_unary_operand_right = staticmethod(match_binary_unary_operand_right)
-
-    def match_binary_operand_left(lhs_cls, op_pattern, rhs_cls, string):
-        line, repmap = string_replace_map(string)
-        t = op_pattern.lsplit(line)
-        if t is None: return
-        lhs, op, rhs = t
-        for k in Base.findall(lhs):
-            lhs = lhs.replace(k, repmap[k])
-        for k in Base.findall(rhs):
-            rhs = rhs.replace(k, repmap[k])
-        lhs_obj = lhs_cls(lhs)
-        rhs_obj = rhs_cls(rhs)
-        return lhs_obj, t[1], rhs_obj
-    match_binary_operand_left = staticmethod(match_binary_operand_left)
-
-    def match_unary_operand(op_pattern, rhs_cls, string):
-        line, repmap = string_replace_map(string)
-        t = op_pattern.lsplit(line)
-        if t is None: return
-        lhs, op, rhs = t
-        for k in Base.findall(rhs):
-            rhs = rhs.replace(k, repmap[k])
-        assert not lhs,`lhs`
-        rhs_obj = rhs_cls(rhs)
-        return t[1], rhs_obj
-    match_unary_operand = staticmethod(match_unary_operand)
-
-    def match_list_of(subcls, string):
-        line, repmap = string_replace_map(string)
-        lst = []
-        for p in line.split(','):
-            p = p.strip()
-            for k in Base.findall(p):
-                p = p.replace(k,repmap[k])
-            lst.append(subcls(p))
-        return tuple(lst)
-    match_list_of = staticmethod(match_list_of)
-
     def init_list(self, *items):
         self.items = items
         return
@@ -149,59 +73,12 @@
     def torepr_list(self):
         return '%s(%s)' % (self.__class__.__name__,', '.join(map(repr,self.items)))
 
-    def init_binary_operand(self, lhs, op, rhs):
-        self.lhs = lhs
-        self.op = op
-        self.rhs = rhs
-        return
-
-    def init_unary_operand(self, op, rhs):
-        self.op = op
-        self.rhs = rhs
-        return
-
-    def init_primary(self, primary):
-        self.primary = primary
-        return
-
-    def tostr_binary_operand(self):
-        return '%s %s %s' % (self.lhs, self.op, self.rhs)
-
-    def tostr_binary_unary_operand(self):
-        if self.lhs is None:
-            return '%s %s' % (self.op, self.rhs)
-        return '%s %s %s' % (self.lhs, self.op, self.rhs)
-
-    def tostr_unary_operand(self):
-        return '%s %s' % (self.op, self.rhs)
-
-    def tostr_primary(self):
-        return str(self.primary)
-
     def tostr_string(self):
         return str(self.string)
 
-    def torepr_binary_operand(self):
-        return '%s(%r, %r, %r)' % (self.__class__.__name__,self.lhs, self.op, self.rhs)
-
-    def torepr_binary_unary_operand(self):
-        return '%s(%r, %r, %r)' % (self.__class__.__name__,self.lhs, self.op, self.rhs)
-
-    def torepr_unary_operand(self):
-        return '%s(%r, %r)' % (self.__class__.__name__,self.op, self.rhs)
-
-    def torepr_primary(self):
-        return '%s(%r)' % (self.__class__.__name__,self.primary)
-
     def torepr_string(self):
         return '%s(%r)' % (self.__class__.__name__,self.string)
 
-    def tostr_number(self):
-        if self.items[1] is None: return str(self.items[0])
-        return '%s_%s' % (self.items[0],self.items[1])
-    def torepr_number(self):
-        return '%s(%r,%r)' % (self.__class__.__name__, self.items[0],self.items[1])
-
     def __str__(self):
         return self.tostr()
         if self.__class__.__dict__.has_key('tostr'):
@@ -215,7 +92,9 @@
         return '%s(%r)' % (self.__class__.__name__, self.string)
 
 class SequenceBase(Base):
-
+    """
+    <sequence-base> = <obj> [ , <obj> ]...
+    """
     def match(separator, subcls, string):
         line, repmap = string_replace_map(string)
         lst = []
@@ -229,10 +108,18 @@
     def init(self, separator, items):
         self.separator = separator
         self.items = items
-    def tostr(self): return (self.separator+' ').join(map(str, self.items))
+        return
+    def tostr(self):
+        s = self.separator
+        if s==',': s = s + ' '
+        else: s = ' ' + s + ' '
+        return s.join(map(str, self.items))
     def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.separator, self.items)
     
 class UnaryOpBase(Base):
+    """
+    <unary-op-base> = [ <unary-op> ] <rhs>
+    """
     def init(self, op, rhs):
         self.op = op
         self.rhs = rhs
@@ -256,7 +143,7 @@
 
 class BinaryOpBase(Base):
     """
-    <..> = <lhs> <op> <rhs>
+    <binary-op-base> = <lhs> <op> <rhs>
     """
     def match(lhs_cls, op_pattern, rhs_cls, string):
         line, repmap = string_replace_map(string)
@@ -285,7 +172,7 @@
 
 class RBinaryOpBase(BinaryOpBase):
     """
-    <..> = [ <lhs> <op> ] <rhs>
+    <rbinary-op-base> = [ <lhs> <op> ] <rhs>
     """
     def match(lhs_cls, op_pattern, rhs_cls, string):
         line, repmap = string_replace_map(string)
@@ -304,7 +191,7 @@
 
 class LBinaryOpBase(BinaryOpBase):
     """
-    <..> = <lhs> [ <op> <rhs> ]
+    <lbinary-op-base> = <lhs> [ <op> <rhs> ]
     """
     def match(lhs_cls, op_pattern, rhs_cls, string):
         line, repmap = string_replace_map(string)
@@ -321,16 +208,90 @@
         return lhs_obj, t[1], rhs_obj
     match = staticmethod(match)
 
+class KeywordValueBase(BinaryOpBase):
+    """
+    <keyword-value-base> = [ <keyword> = ] <rhs>
+    """
+    def match(cls, string):
+        if '=' not in string: return cls(string)
+        lhs,rhs = string.split('=',1)
+        return Keyword(lhs.rstrip()),'=',cls(rhs.lstrip())
+    match = staticmethod(match)
+    
+class BracketBase(Base):
+    """
+    <bracket-base> = <left-bracket-base> <something> <right-bracket>
+    """
+    def match(brackets, cls, string):
+        left = brackets[:len(brackets)/2]
+        right = brackets[-len(brackets)/2:]
+        if string.startswith(left) and string.endswith(right):
+            return left,cls(string[len(left):-len(right)].strip())
+        return
+    match = staticmethod(match)
+    def init(self,left,item,right):
+        self.left = left
+        self.item = item
+        self.right = right
+        return
+    def tostr(self): '%s%s%s' % (self.left, self.item, self.right)
+    def torepr(self): '%s(%r, %r, %r)' % (self.__class__.__name__, self.left, self.item, self.right)
+
+class NumberBase(Base):
+    """
+    <number-base> = <number> [ _ <kind-param> ]
+    """
+    def match(number_pattern, string):
+        m = number_pattern.match(string)
+        if m is None: return
+        return m.group('value'),m.group('kind_param')
+    match = staticmethod(match)
+    def init(self, value, kind_param):
+        self.value = value
+        self.kind_param = kind_param
+        return
+    def tostr(self):
+        if self.kind_param is None: return str(self.value)
+        return '%s_%s' % (self.value, self.kind_param)
+    def torepr(self):
+        return '%s(%r, %r)' % (self.__class__.__name__, self.value, self.kind_param)
+
+class CallBase(Base):
+    """
+    <call-base> = <lhs> ( <rhs> )
+    """
+    def match(lhs_cls, rhs_cls, string):
+        if not string.endswith(')'): return
+        line, repmap = string_replace_map(string)
+        i = line.find('(')
+        if i==-1: return
+        lhs = line[:i]
+        rhs = line[i+1:-1].strip()
+        for k in Base.findall(lhs):
+            lhs = lhs.replace(k,repmap[k])
+        for k in Base.findall(rhs):
+            rhs = rhs.replace(k,repmap[k])
+        return lhs_cls(lhs), rhs_cls(rhs)
+    match = staticmethod(match)
+    def init(self, lhs, rhs):
+        self.lhs = lhs
+        self.rhs = rhs
+        return
+    def tostr(self): return '%s(%s)' % (self.lhs, self.rhs)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.lhs, self.rhs)
+
+##################################################
+    
 class Expr(RBinaryOpBase):
     """
     <expr> = [ <expr> <defined-binary-op> ] <level-5-expr>
     <defined-binary-op> = . <letter> [ <letter> ]... .
     TODO: defined_binary_op must not be intrinsic_binary_op!!
     """
-    #subclass_names = ['Level_5_Expr']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(Expr, pattern.defined_binary_op.named(), Level_5_Expr,
-                                 string)
+                                   string)
     match = staticmethod(match)
 
 class Level_5_Expr(RBinaryOpBase):
@@ -339,7 +300,7 @@
     <equiv-op> = .EQV.
                | .NEQV.
     """
-    #subclass_names = ['Equiv_Operand']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Level_5_Expr,pattern.equiv_op.named(),Equiv_Operand,string)
@@ -350,7 +311,7 @@
     <equiv-operand> = [ <equiv-operand> <or-op> ] <or-operand>
     <or-op>  = .OR.
     """
-    #subclass_names = ['Or_Operand']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Equiv_Operand,pattern.or_op.named(),Or_Operand,string)
@@ -361,7 +322,7 @@
     <or-operand> = [ <or-operand> <and-op> ] <and-operand>    
     <and-op> = .AND.
     """
-    #subclass_names = ['And_Operand']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Or_Operand,pattern.and_op.named(),And_Operand,string)
@@ -372,7 +333,7 @@
     <and-operand> = [ <not-op> ] <level-4-expr>
     <not-op> = .NOT.
     """
-    #subclass_names = ['Level_4_Expr']
+    subclass_names = []
     def match(string):
         return UnaryOpBase.match(\
             pattern.not_op.named(),Level_4_Expr,string)
@@ -383,7 +344,7 @@
     <level-4-expr> = [ <level-3-expr> <rel-op> ] <level-3-expr>
     <rel-op> = .EQ. | .NE. | .LT. | .LE. | .GT. | .GE. | == | /= | < | <= | > | >=
     """
-    #subclass_names = ['Level_3_Expr']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Level_3_Expr,pattern.rel_op.named(),Level_3_Expr,string)
@@ -394,7 +355,7 @@
     <level-3-expr> = [ <level-3-expr> <concat-op> ] <level-2-expr>
     <concat-op>    = //
     """
-    #subclass_names = ['Level_2_Expr']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Level_3_Expr,pattern.concat_op.named(),Level_2_Expr,string)
@@ -406,7 +367,7 @@
     <add-op>   = +
                  | -
     """
-    subclass_names = ['Add_Operand']
+    subclass_names = []
     def match(string):
         lhs_cls, op_pattern, rhs_cls = Level_2_Expr,pattern.add_op.named(),Add_Operand
         line, repmap = string_replace_map(string)
@@ -432,7 +393,7 @@
     <mult-op>  = *
                  | /
     """
-    #subclass_names = ['Mult_Operand']
+    subclass_names = []
     def match(string):
         return RBinaryOpBase.match(\
             Add_Operand,pattern.mult_op.named(),Mult_Operand,string)
@@ -443,7 +404,7 @@
     <mult-operand> = <level-1-expr> [ <power-op> <mult-operand> ]
     <power-op> = **
     """
-    #subclass_names = ['Level_1_Expr']
+    subclass_names = []
     def match(string):
         return LBinaryOpBase.match(\
             Level_1_Expr,pattern.power_op.named(),Mult_Operand,string)
@@ -454,7 +415,7 @@
     <level-1-expr> = [ <defined-unary-op> ] <primary>
     <defined-unary-op> = . <letter> [ <letter> ]... .
     """
-    #subclass_names = ['Primary']
+    subclass_names = []
     def match(string):
         return UnaryOpBase.match(\
             pattern.defined_unary_op.named(),Primary,string)
@@ -490,42 +451,39 @@
             Designator, pattern.percent_op.named(), Type_Param_Name, string)
     match = staticmethod(match)
 
+class Structure_Constructor_2(KeywordValueBase):
+    """
+    <structure-constructor-2> = [ <keyword> = ] <component-data-source>
+    """
+    subclass_names = []
+    def match(string): return KeywordValueBase.match(Component_Data_Source, string)
+    match = staticmethod(match)
+
 class Structure_Constructor(Base):
     """
     <structure-constructor> = <derived-type-spec> ( [ <component-spec-list> ] )
                             | [ <keyword> = ] <component-data-source>
     """
-    subclass_names = []
+    subclass_names = ['Structure_Constructor_2']
     def match(string):
+        if string[-1]!=')': return
         line, repmap = string_replace_map(string)
-        if line[-1]==')':
-            i = line.rfind('(')
-            if i==-1: return
-            specline = line[:i].rstrip()
-            for k in Base.findall(specline):
-                specline = specline.replace(k,repmap[k])
-            try:
-                spec = Derived_Type_Spec(specline)
-            except NoMatchError:
-                spec = None
-            if spec is not None:
-                l = line[i+1:-1].strip()
-                for k in Base.findall(l):
-                    l = l.replace(k,repmap[k])
-                if not l: return spec,'(',None,')'
-                return spec,'(',Component_Spec_List(l),')'
-        if '=' not in string: return None, Component_Data_Source(string)
-        lhs,rhs = string.split('=',1)
-        return Keyword(lhs.rstrip()), Component_Data_Source(rhs.lstrip())        
+        i = line.rfind('(')
+        if i==-1: return
+        specline = line[:i].rstrip()
+        for k in Base.findall(specline):
+            specline = specline.replace(k,repmap[k])
+        spec = Derived_Type_Spec(specline)
+        l = line[i+1:-1].strip()
+        for k in Base.findall(l):
+            l = l.replace(k,repmap[k])
+        if not l: return spec,'(',None,')'
+        return spec,'(',Component_Spec_List(l),')'
     match = staticmethod(match)
     init = Base.init_list
     def tostr(self):
-        if len(self.items)==4:
-            if self.items[2] is None: return '%s()' % (self.items[0])
-            return '%s(%s)' % (self.items[0],self.items[2])
-        if self.items[0] is None:
-            return str(self.items[1])
-        return '%s = %s' % (self.items[0], self.items[1])
+        if self.items[2] is None: return '%s()' % (self.items[0])
+        return '%s(%s)' % (self.items[0],self.items[2])
     torepr = Base.torepr_list
 
 class Component_Data_Source(Base):
@@ -534,7 +492,7 @@
                               | <data-target>
                               | <proc-target>
     """
-    subclass_names = ['Expr','Data-Target','Proc-Target']
+    subclass_names = ['Expr','Data_Target','Proc_Target']
 
 class Data_Target(Base):
     """
@@ -549,7 +507,7 @@
                     | <procedure-name>
                     | <proc-component-ref>
     """
-    subclass_names = ['Expr','Procedure_Name','Proc_Component_Ref']
+    subclass_names = ['Procedure_Name','Proc_Component_Ref', 'Expr']
 
 class Proc_Component_Ref(BinaryOpBase):
     """
@@ -561,36 +519,23 @@
             Variable, pattern.percent_op.named(), Procedure_Component_Name, string)            
     match = staticmethod(match)
 
-class Component_Spec(Base):
+class Component_Spec(KeywordValueBase):
     """
     <component-spec> = [ <keyword> = ] <component-data-source>
     """
     subclass_names = []
-    def match(string):
-        if '=' not in string: return None, Component_Data_Source(string)
-        lhs,rhs = string.split('=',1)
-        return Keyword(lhs.rstrip()), Component_Data_Source(rhs.lstrip())
+    def match(string): return KeywordValueBase.match(Component_Data_Source, string)
     match = staticmethod(match)
-    init = Base.init_list
-    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(%r, %r)' % (self.__class__.__name__, self.items[0],self.items[1])
 
-class Component_Spec_List(Base):
+class Component_Spec_List(SequenceBase):
     """
     <component-spec-list> = <component-spec> [ , <component-spec> ]...
     """
     subclass_names = []
-    def match(string):
-        return Base.match_list_of(Component_Spec, string)
+    def match(string): return SequenceBase.match(r',', Component_Spec, string)
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_list
-    torepr = Base.torepr_list
 
-class Array_Constructor(Base):
+class Array_Constructor(BracketBase):
     """
     <array-constructor> = (/ <ac-spec> /)
                           | <left-square-bracket> <ac-spec> <right-square-bracket>
@@ -598,15 +543,14 @@
     """
     subclass_names = []
     def match(string):
-        if string[:2]+string[-2:]=='(//)':
-            return '(/',Ac_Spec(string[2:-2].strip()),'/)'
-        if string[:1]+string[-1:]=='[]':
-            return '[',Ac_Spec(string[1:-1].strip()),']'
-        return
+        try:
+            obj = BracketBase.match('(//)', Ac_Spec, string)
+        except NoMatchError:
+            obj = None
+        if obj is None:
+            obj = BracketBase.match('[]', Ac_Spec, string)
+        return obj
     match = staticmethod(match)
-    init = Base.init_list
-    def tostr(self): return ''.join(map(str,self.items))
-    def torepr(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr,self.items)))
 
 class Ac_Spec(Base):
     """
@@ -639,17 +583,16 @@
     def torepr(self):
         return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
 
-class Ac_Value_List(Base):
+class Ac_Value_List(SequenceBase):
     """
     <ac-value-list> = <ac-value> [ , <ac-value> ]...
     """
     subclass_names = []
     def match(string):
-        return Base.match_list_of(Ac_Value, string)
+        r = SequenceBase.match(r',', Ac_Value, string)
+        if len(r[1])==1: return r[1][0]
+        return r
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_list
-    torepr = Base.torepr_list
 
 class Ac_Value(Base):
     """
@@ -657,7 +600,6 @@
                  | <ac-implied-do>
     """
     subclass_names = ['Ac_Implied_Do','Expr']
-    extra_subclasses = [Expr]
 
 class Ac_Implied_Do(Base):
     """
@@ -707,7 +649,6 @@
     <scalar-int-expr> = <expr>
     """
     subclass_names = ['Expr']
-    extra_subclasses = [Expr]
 
 class Ac_Do_Variable(Base):
     """
@@ -932,7 +873,6 @@
                        | :
     """
     subclass_names = ['Scalar_Int_Expr']
-    extra_subclasses = [Scalar_Int_Expr]
     def match(string):
         if string in ['*',':']: return string,
         return
@@ -959,34 +899,24 @@
     def torepr(self):
         return '%s(%r, %r)' % (self.__class__.__name__, self.items[0],self.items[1])
 
-class Type_Param_Spec(Base):
+class Type_Param_Spec(KeywordValueBase):
     """
     <type-param-spec> = [ <keyword> = ] <type-param-value>
     """
     subclass_names = []
-    def match(string):
-        if '=' not in string: return None, Type_Param_Value(string)
-        lhs,rhs = string.split('=',1)
-        return Keyword(lhs.rstrip()), Type_Param_Value(rhs.lstrip())
+    def match(string): return KeywordValueBase.match(Type_Param_Value, string)
     match = staticmethod(match)
-    init = Base.init_list
-    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(%r, %r)' % (self.__class__.__name__, self.items[0],self.items[1])
 
-class Type_Param_Spec_List(Base):
+class Type_Param_Spec_List(SequenceBase):
     """
-    <type-param-spec> = <type-param> [ , <type-param> ]...
+    <type-param-spec-list> = <type-param> [ , <type-param> ]...
     """
     subclass_names = []
     def match(string):
-        return Base.match_list_of(Type_Param_Spec, string)
+        r = SequenceBase.match(',', Type_Param_Spec, string)
+        if len(r[1])==1: return r[1][0]
+        return r
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_list
-    torepr = Base.torepr_list
 
 
 class Constant(Base):
@@ -1003,15 +933,6 @@
                    | <array-section>
                    | <structure-component>
                    | <substring>
-    <array-element> = <data-ref>
-    <array-section> = <data-ref> [ ( <substring-range> ) ]
-    <data-ref> = <part-ref> [ % <part-ref> ]...
-    <part-ref> = <part-name> [ ( <section-subscript-list> ) ]
-    <substring> = <parent-string> ( <substring-range> )
-    <parent-string> = <scalar-variable-name>
-                      | <array-element>
-                      | <scalar-structure-component>
-                      | <scalar-constant>
     <substring-range> = [ <scalar-int-expr> ] : [ <scalar-int-expr> ]
     <structure-component> = <data-ref>
     """
@@ -1019,6 +940,98 @@
                       'Substring'
                       ]
 
+class Substring(CallBase):
+    """
+    <substring> = <parent-string> ( <substring-range> )    
+    """
+    subclass_names = []
+    def match(string): return CallBase.match(Parent_String, Substring_Range, string)
+    match = staticmethod(match)
+
+class Parent_String(Base):
+    """
+    <parent-string> = <scalar-variable-name>
+                      | <array-element>
+                      | <scalar-structure-component>
+                      | <scalar-constant>    
+    """
+    subclass_names = ['Scalar_Variable_Name', 'Array_Element', 'Scalar_Structure_Component', 'Scalar_Constant']
+
+class Scalar_Variable_Name(Base):
+    """
+    <scalar-variable-name> = <name>
+    """
+    subclass_names = ['Name']
+
+class Scalar_Structure_Component(Base):
+    """
+    <scalar-structure-component> = <structure-component>
+    """
+    subclass_names = ['Structure_Component']
+
+class Scalar_Constant(Base):
+    """
+    <scalar-constant> = <constant>
+    """
+    subclass_names = ['Constant']
+
+class Structure_Component(Base):
+    """
+    <structure-component> = <data-ref>
+    """
+    subclass_names = ['Data_Ref']
+
+class Array_Section(CallBase):
+    """
+    <array-section> = <data-ref> [ ( <substring-range> ) ]
+    """
+    subclass_names = ['Data_Ref']
+    def match(string): return CallBase.match(Data_Ref, Substring_Range, string)
+    match = staticmethod(match)
+
+class Substring_Range(Base):
+    """
+    <substring-range> = [ <scalar-int-expr> ] : [ <scalar-int-expr> ]
+    """
+    subclass_names = []
+    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()
+        if lhs:
+            for k in Base.findall(lhs):
+                lhs = lhs.replace(k,repmap[k])
+            lhs_obj = Scalar_Int_Expr(lhs)
+        else:
+            lhs_obj = None
+        if rhs:
+            for k in Base.findall(rhs):
+                rhs = rhs.replace(k,repmap[k])
+            rhs_obj = Scalar_Int_Expr(rhs)
+        else:
+            rhs_obj = None
+        return lhs_obj, rhs_obj
+    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 Array_Element(Base):
+    """
+    <array-element> = <data-ref>
+    """
+    subclass_names = ['Data_Ref']
+
 class Literal_Constant(Base):
     """
     <literal-constant> = <int-literal-constant>
@@ -1031,45 +1044,50 @@
     subclass_names = ['Int_Literal_Constant', 'Real_Literal_Constant','Complex_Literal_Constant',
                       'Logical_Literal_Constant','Char_Literal_Constant','Boz_Literal_Constant']
 
-class Int_Literal_Constant(Base):
+class Int_Literal_Constant(NumberBase):
     """
     <int-literal-constant> = <digit-string> [ _ <kind-param> ]
     """
     subclass_names = []
     def match(string):
-        m = pattern.abs_int_literal_constant_named.match(string)
-        if m is None: return
-        return m.group('value'),m.group('kind_param')
+        return NumberBase.match(pattern.abs_int_literal_constant_named, string)
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_number
-    torepr = Base.torepr_number
 
+class Signed_Int_Literal_Constant(NumberBase):
+    """
+    <signed-int-literal-constant> = [ <sign> ] <int-literal-constant>
+    """
+    subclass_names = []
+    def match(string):
+        return NumberBase.match(pattern.abs_signed_int_literal_constant_named, string)
+    match = staticmethod(match)
+
 class Scalar_Int_Literal_Constant(Base):
     """
     <scalar-int-literal-constant> = <int-literal-constant>
     """
     subclass_names = ['Int_Literal_Constant']
 
-class Real_Literal_Constant(Base):
+class Real_Literal_Constant(NumberBase):
     """
     """
     subclass_names = []
     def match(string):
-        m = pattern.abs_real_literal_constant_named.match(string)
-        if m is None: return
-        return m.group('value'),m.group('kind_param')
+        return NumberBase.match(pattern.abs_real_literal_constant_named, string)
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_number
-    torepr = Base.torepr_number
 
+class Signed_Real_Literal_Constant(NumberBase):
+    """
+    <signed-real-literal-constant> = [ <sign> ] <real-literal-constant>
+    """
+    subclass_names = []
+    def match(string):
+        return NumberBase.match(pattern.abs_signed_real_literal_constant_named, string)
+    match = staticmethod(match)
+
 class Complex_Literal_Constant(Base):
     """
     <complex-literal-constant> = ( <real-part>, <imag-part> )
-    <real-part> = <imag-part> = <signed-int-literal-constant>
-                                | <signed-real-literal-constant>
-                                | <named-constant>
     """
     subclass_names = []
     def match(string):
@@ -1079,9 +1097,11 @@
         r,i = string[1:-1].split(',')
         return Real_Part(r.strip()), Imag_Part(i.strip())
     match = staticmethod(match)
-    init = Base.init_list
-    def tostr(self): return '(%s, %s)' % (self.items[0], self.items[1])
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
+    def init(self,real,imag):
+        self.real, self.imag = real, imag
+        return
+    def tostr(self): return '(%s, %s)' % (self.real, self.imag)
+    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.real, self.imag)
 
 class Real_Part(Base):
     """
@@ -1089,41 +1109,13 @@
                   | <signed-real-literal-constant>
                   | <named-constant>
     """
-    subclass_names = []
-    def match(string):
-        clses = [Int_Literal_Constant, Real_Literal_Constant]
-        if string[0] in '+-':
-            sign = string[0]
-            string = string[1:].lstrip()
+    subclass_names = ['Signed_Int_Literal_Constant','Signed_Real_Literal_Constant','Named_Constant']
 
-        else:
-            sign = None
-            clses.append(Named_Constant)
-        obj = None
-        for cls in clses:
-            try:
-                obj = cls(string)
-            except NoMatchError:
-                pass
-        if obj is None:
-            return
-        return sign, obj
-    match = staticmethod(match)
-    init = Base.init_list
-    def tostr(self):
-        if self.items[0] is None: return str(self.items[1])
-        return '%s%s' % (self.items[0], self.items[1])
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
-
-class Imag_Part(Real_Part):
+class Imag_Part(Base):
     """
     <imag-part> = <real-part>
     """
-    subclass_names = []
-    match = staticmethod(Real_Part.match)
-    init = Real_Part.init
-    tostr = Real_Part.tostr
-    torepr = Real_Part.torepr
+    subclass_names = ['Signed_Int_Literal_Constant','Signed_Real_Literal_Constant','Named_Constant']
 
 class Char_Literal_Constant(Base):
     """
@@ -1152,22 +1144,15 @@
         return '%s_%s' % (self.items[1], self.items[0])
     def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
 
-class Logical_Literal_Constant(Base):
+class Logical_Literal_Constant(NumberBase):
     """
     <logical-literal-constant> = .TRUE. [ _ <kind-param> ]
                                  | .FALSE. [ _ <kind-param> ]
     """
     subclass_names = []
     def match(string):
-        m = pattern.abs_logical_literal_constant_named.match(string)
-        if m is None: return
-        return m.group('value'), m.group('kind_param')
+        return NumberBase.match(pattern.abs_logical_literal_constant_named, string)    
     match = staticmethod(match)
-    init = Base.init_list
-    def tostr(self):
-        if self.items[1] is None: return self.items[0]
-        return '%s_%s' % (self.items[0], self.items[1])
-    def torepr(self): return '%s(%r, %r)' % (self.__class__.__name__, self.items[0], self.items[1])
 
 class Boz_Literal_Constant(Base):
     """
@@ -1260,11 +1245,11 @@
         
 
 
-class Procedure_Designator(Base):
+class Procedure_Designator(BinaryOpBase):
     """
     <procedure-designator> = <procedure-name>
-                           | <proc-component-ref>
-                           | <data-ref> % <binding-name>
+                             | <proc-component-ref>
+                             | <data-ref> % <binding-name>
     """
     subclass_names = ['Procedure_Name','Proc_Component_Ref']
     def match(string):
@@ -1272,20 +1257,102 @@
             Data_Ref, pattern.percent_op.named(),  Binding_Name, string)
     match = staticmethod(match)
 
-class Part_Ref(Base):
+class Part_Ref(CallBase):
     """
     <part-ref> = <part-name> [ ( <section-subscript-list> ) ]
     """
     subclass_names = ['Part_Name']
+    def match(string): return CallBase.match(Part_Name, Section_Subscript_List, string)
+    match = staticmethod(match)
+
+class Section_Subscript_List(SequenceBase):
+    """
+    <section-subscript-list> = <section-subscript> [ , <section-subscript> ]...
+    """
+    subclass_names = []
     def match(string):
-        if string.endswith(')'):
-            i = string.find('(')
-            if i==-1: return
-            return Part_Name(string[:i].rstrip()),'(',Section_Subscript_List(string[i+1:-1].strip()),')'
-        return
+        r = SequenceBase.match(',', Section_Subscript, string)
+        if len(r[1])==1: return r[1][0]
+        return r
     match = staticmethod(match)
-    init = Base.init_list
 
+class Section_Subscript(Base):
+    """
+    <section-subscript> = <subscript>
+                          | <subscript-triplet>
+                          | <vector-subscript>
+    """
+    subclass_names = ['Subscript', 'Subscript_Triplet', 'Vector_Subscript']
+
+class Subscript_Triplet(Base):
+    """
+    <subscript-triplet> = [ <subscript> ] : [ <subscript> ] [ : <stride> ]
+    """
+    subclass_names = []
+    def match(string):
+        line, repmap = string_replace_map(string)
+        t = line.split(':')
+        if len(t)==1 or len(t)>3: return
+        lhs_obj,rhs_obj, stride_obj = None, None, None
+        if len(t)==2:
+            lhs,rhs = t[0].rstrip(),t[1].lstrip()
+        else:
+            lhs,rhs,stride = t[0].rstrip(),t[1].strip(),t[2].lstrip()
+            if stride:
+                for k in Base.findall(stride):
+                    stride = stride.replace(k, repmap[k])
+                stride_obj = Stride(stride)
+        if lhs:
+            for k in Base.findall(lhs):
+                lhs = lhs.replace(k, repmap[k])
+            lhs_obj = Subscript(lhs)
+        if rhs:
+            for k in Base.findall(rhs):
+                rhs = rhs.replace(k, repmap[k])
+            rhs_obj = Subscript(rhs)
+        return lhs_obj, rhs_obj, stride_obj
+    match = staticmethod(match)
+    def init(self, lhs, rhs, stride):
+        self.lhs, self.rhs, self.stride =lhs, rhs, stride
+        return
+    def tostr(self):
+        s = ''
+        if self.lhs is not None:
+            s += str(self.lhs) + ' :'
+        else:
+            s += ':'
+        if self.rhs is not None:
+            s += ' ' + str(self.rhs)
+        if self.stride is not None:
+            s += ' : ' + str(self.stride)
+        return s
+    def torepr(self):
+        return '%s(%r, %r, %r)' % (self.__class__.__name__,self.lhs, self.rhs, self.stride)        
+
+class Stride(Base):
+    """
+    <stride> = <scalar-int-expr>
+    """
+    subclass_names = ['Scalar_Int_Expr']
+
+class Vector_Subscript(Base):
+    """
+    <vector-subscript> = <int-expr>
+    """
+    subclass_names = ['Int_Expr']
+
+class Int_Expr(Base):
+    """
+    <int-expr> = <expr>
+    """
+    subclass_names = ['Expr']
+
+class Subscript(Base):
+    """
+    <subscript> = <scalar-int-expr>
+    """
+    subclass_names = ['Scalar_Int_Expr']
+
 class Part_Name(Base):
     """
     <part-name> = <name>
@@ -1304,47 +1371,29 @@
     """
     subclass_names = []
     def match(string):
-        return SequenceBase.match(r'%', Part_Ref, string)
+        r = SequenceBase.match('%', Part_Ref, string)
+        if len(r[1])==1: return r[1][0]
+        return r
     match = staticmethod(match)
 
-class Actual_Arg_Spec_List(Base):
+class Actual_Arg_Spec_List(SequenceBase):
     """
     <actual-arg-spec-list> = <actual-arg-spec> [ , <actual-arg-spec> ]...
     """
     subclass_names = []
     def match(string):
-        return Base.match_list_of(Actual_Arg_Spec, string)
+        r = SequenceBase.match(r',', Actual_Arg_Spec, string)
+        if len(r[1])==1: return r[1][0]
+        return r
     match = staticmethod(match)
-    init = Base.init_list
-    tostr = Base.tostr_list
-    torepr = Base.torepr_list
 
-class Actual_Arg_Spec(Base):
+class Actual_Arg_Spec(KeywordValueBase):
     """
     <actual-arg-spec> = [ <keyword> = ] <actual-arg>
     """
     subclass_names = []
-    def match(string):
-        if pattern.keyword_equal.match(string):
-            i = string.find('=')
-            assert i!=-1,`string`
-            kw = Keyword(string[:i].rstrip())
-            string = string[i+1:].lstrip()
-        else:
-            kw = None
-        return kw, Actual_Arg(string)
-
+    def match(string): return KeywordValueBase.match(Actual_Arg, string)
     match = staticmethod(match)
-    def init(self,kw,arg):
-        self.keyword = kw
-        self.actual_arg =arg
-        return
-    def tostr(self):
-        if self.keyword is not None:
-            return '%s = %s' % (self.keyword, self.actual_arg)
-        return str(self.actual_arg)
-    def torepr(self):
-        return '%s(%s, %s)' % (self.__class__.__name__, self.keyword, self.actual_arg)
 
 class Keyword(Base):
     """
@@ -1362,8 +1411,6 @@
         if pattern.abs_intrinsic_type_name.match(string): return
         return Name(string)
     match = staticmethod(match)
-    tostr = Base.tostr_string
-    torepr = Base.torepr_string        
     
 class Actual_Arg(Base):
     """
@@ -1372,19 +1419,32 @@
                  | <procedure-name>
                  | <proc-component-ref>
                  | <alt-return-spec>
+    """
+    subclass_names = ['Expr','Variable','Procedure_Name','Proc_Component_Ref','Alt_Return_Spec']
+
+class Alt_Return_Spec(Base):
+    """
     <alt-return-spec> = * <label>
-    <variable> = <designator>
-    <proc-component-ref> = <variable> % <procedure-component-name>
     """
-    subclass_names = ['Expr','Variable','Procedure_Name','Alt_Return_Spec']
-    extra_subclasses = [Expr]
+    subclass_names = []
+    def match(string):
+        if not string.startswith('*'): return
+        line = string[1:].lstrip()
+        if pattern.abs_label.match(line):
+            return line,
+        return
+    match = staticmethod(match)
+    def init(self, label):
+        self.label = label
+        return
+    def tostr(self): return '*%s' % (self.label)
+    def torepr(self): return '%s(%r)' % (self.__class__.__name__, self.label)
 
 class Variable(Base):
     """
     <variable> = <designator>
     """
     subclass_names = ['Designator']
-    extra_subclasses = [Designator]
 
 class Procedure_Component_Name(Base):
     """
@@ -1398,19 +1458,13 @@
     """
     subclass_names = ['Name']
     
-class Parenthesis(Base):
+class Parenthesis(BracketBase):
     """
     <parenthesis> = ( <expr> )
     """
     subclass_names = []
-    def match(string):
-        if string[0]+string[-1]=='()':
-            return '(',Expr(string[1:-1].strip()),')'
-        return None
+    def match(string): BracketBase.match('()', Expr, string)
     match = staticmethod(match)
-    init = Base.init_binary_operand
-    tostr = Base.tostr_binary_operand
-    torepr = Base.torepr_binary_operand
 
 class Name(Base):
     """
@@ -1424,6 +1478,8 @@
     match = staticmethod(match)
     tostr = Base.tostr_string
     torepr = Base.torepr_string
+
+##############################################################################
     
 ClassType = type(Base)
 Base_classes = {}
@@ -1435,7 +1491,8 @@
 for clsname, cls in Base_classes.items():
     subclass_names = getattr(cls, 'subclass_names', None)
     if subclass_names is None:
-        print '%s class is missing subclass_names list' % (clsname)
+        if clsname[-4:]!='Base':
+            print '%s class is missing subclass_names list' % (clsname)
         continue
     try:
         l = Base.subclasses[clsname]
@@ -1447,26 +1504,6 @@
         else:
             print '%s not implemented needed by %s' % (n,clsname)
 
-print 
-for clsname in dir():
-    break
-    cls = eval(clsname)
-    if isinstance(cls, ClassType) and issubclass(cls, Base):
-        extra_subclasses = cls.__dict__.get('extra_subclasses',[])
-        if extra_subclasses:
-            try:
-                l = Base.subclasses[cls.__name__]
-            except KeyError:
-                Base.subclasses[cls.__name__] = l = []
-            l.extend(extra_subclasses)
-        for basecls in cls.__bases__:
-            if basecls is Base: continue
-            if issubclass(basecls, Base):
-                try:
-                    Base.subclasses[basecls.__name__].append(cls)
-                except KeyError:
-                    Base.subclasses[basecls.__name__] = [cls]
-
 for cls in Base_classes.values():
     subclasses = Base.subclasses.get(cls.__name__,[])
     subclasses_names = [c.__name__ for c in subclasses]

Modified: trunk/numpy/f2py/lib/parser/pattern_tools.py
===================================================================
--- trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-10-23 22:22:41 UTC (rev 3384)
+++ trunk/numpy/f2py/lib/parser/pattern_tools.py	2006-10-23 22:41:47 UTC (rev 3385)
@@ -209,8 +209,8 @@
 signed_digit_string = ~sign + digit_string
 int_literal_constant = digit_string + ~('_' + kind_param)
 signed_int_literal_constant = ~sign + int_literal_constant
-
 int_literal_constant_named = digit_string.named('value') + ~ ('_' + kind_param_named)
+signed_int_literal_constant_named = (~sign + digit_string).named('value') + ~ ('_' + kind_param_named)
 
 binary_constant = ('B' + ("'" & binary_digit_string & "'" | '"' & binary_digit_string & '"')).flags(re.I)
 octal_constant = ('O' + ("'" & octal_digit_string & "'" | '"' & octal_digit_string & '"')).flags(re.I)
@@ -223,6 +223,8 @@
                         digit_string + exponent_letter + exponent + ~ ('_' + kind_param)
 real_literal_constant_named = (significand + ~(exponent_letter + exponent) |\
                                digit_string + exponent_letter + exponent).named('value') +  ~ ('_' + kind_param_named)
+signed_real_literal_constant_named = (~sign + (significand + ~(exponent_letter + exponent) |\
+                               digit_string + exponent_letter + exponent)).named('value') +  ~ ('_' + kind_param_named)
 signed_real_literal_constant = ~sign + real_literal_constant
 
 named_constant = name
@@ -262,6 +264,7 @@
 defined_operator = defined_unary_op | defined_binary_op | extended_intrinsic_operator
 
 label = Pattern('<label>','\d{1,5}')
+abs_label = abs(label)
 
 keyword = name
 keyword_equal = keyword + '='
@@ -269,8 +272,12 @@
 abs_constant = abs(constant)
 abs_literal_constant = abs(literal_constant)
 abs_int_literal_constant = abs(int_literal_constant)
+abs_signed_int_literal_constant = abs(signed_int_literal_constant)
+abs_signed_int_literal_constant_named = abs(signed_int_literal_constant_named)
 abs_int_literal_constant_named = abs(int_literal_constant_named)
 abs_real_literal_constant = abs(real_literal_constant)
+abs_signed_real_literal_constant = abs(signed_real_literal_constant)
+abs_signed_real_literal_constant_named = abs(signed_real_literal_constant_named)
 abs_real_literal_constant_named = abs(real_literal_constant_named)
 abs_complex_literal_constant = abs(complex_literal_constant)
 abs_logical_literal_constant = abs(logical_literal_constant)

Modified: trunk/numpy/f2py/lib/parser/test_expressions.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_expressions.py	2006-10-23 22:22:41 UTC (rev 3384)
+++ trunk/numpy/f2py/lib/parser/test_expressions.py	2006-10-23 22:41:47 UTC (rev 3385)
@@ -17,6 +17,15 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
+class test_Designator(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_Procedure_Designator(NumpyTestCase):
 
     def check_part_ref(self):
@@ -32,7 +41,7 @@
         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), ')')")
+        assert_equal(repr(a),"Kind_Selector('(', Int_Literal_Constant('1', None), ')')")
 
         a = cls('(kind=1+2)')
         assert isinstance(a,cls),`a`
@@ -62,7 +71,7 @@
         a = cls('1')
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'1')
-        assert_equal(repr(a),"Char_Length(Int_Literal_Constant('1',None))")
+        assert_equal(repr(a),"Char_Length(Int_Literal_Constant('1', None))")
 
         a = cls('(1)')
         assert isinstance(a,cls),`a`
@@ -92,7 +101,7 @@
         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))")
+        assert_equal(repr(a),"Char_Selector(Int_Literal_Constant('2', None), Int_Literal_Constant('8', None))")
 
 
         a = cls('(2, kind=8)')
@@ -148,10 +157,10 @@
 
     def check_type_param_spec(self):
         cls = Type_Param_Spec
-        a = cls('a')
+        a = cls('a=1')
         assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a')
-        assert_equal(repr(a),"Type_Param_Spec(None, Name('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`
@@ -163,15 +172,15 @@
 
     def check_type_param_spec_list(self):
         cls = Type_Param_Spec_List
-        a = cls('a')
-        assert isinstance(a,cls),`a`
-        assert_equal(str(a),'a')
-        assert_equal(repr(a),"Type_Param_Spec_List(Type_Param_Spec(None, Name('a')))")
 
         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')
@@ -198,6 +207,61 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'f(2, k = 1, a)')
 
+    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')")
+        
+    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),':')
+
+    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 :)')
+
+    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'))")
+        
+    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_Structure_Constructor(NumpyTestCase):
 
     def check_proc_component_ref(self):
@@ -219,9 +283,13 @@
         assert_equal(str(a),'t(s = 1, a)')
 
         a = cls('a=k')
-        assert isinstance(a,cls),`a`
+        assert isinstance(a,Structure_Constructor_2),`a`
         assert_equal(str(a),'a = k')
-        assert_equal(repr(a),"Structure_Constructor(Name('a'), Name('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_Array_Constructor(NumpyTestCase):
 
@@ -230,7 +298,7 @@
         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)])")
+        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`
@@ -241,10 +309,10 @@
         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'))")
+        assert_equal(repr(a),"Ac_Value_List(',', (Name('a'), Name('b')))")
 
         a = cls('a')
-        assert isinstance(a,cls),`a`
+        assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
         
     def check_ac_implied_do(self):
@@ -252,7 +320,7 @@
         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)]))")
+        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)]))")
 
     def check_ac_spec(self):
         cls = Ac_Spec
@@ -292,12 +360,12 @@
         a = cls('1')
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'1')
-        assert_equal(repr(a),"%s('1',None)" % (cls.__name__))
+        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__))
+        assert_equal(repr(a),"%s('21', '2')" % (cls.__name__))
 
         a = cls('21_SHORT')
         assert isinstance(a,cls),`a`
@@ -316,12 +384,12 @@
         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__))
+        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__))
+        assert_equal(repr(a),"%s('12.78', '8')" % (cls.__name__))
 
         a = cls('12.')
         assert isinstance(a,cls),`a`
@@ -371,7 +439,7 @@
         a = cls('(1.0, -1.0)')
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'(1.0, -1.0)')
-        assert_equal(repr(a),"%s(Real_Part(None, Real_Literal_Constant('1.0',None)), Imag_Part('-', Real_Literal_Constant('1.0',None)))" % (cls.__name__))
+        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`



More information about the Numpy-svn mailing list