示例#1
0
 def __str__(self):
     """Return a string of the declaration of the type"""
     if self.default_kind:
         return self.typestr
     elif check_fortran_intrinsic(self.typestr):
         return "{}(kind={})".format(self.typestr, self._kind)
     else:
         # Derived type
         return "{}({})".format(self.typestr, self._kind)
示例#2
0
 def __init__(self,
              typestr_in=None,
              kind_in=None,
              line_in=None,
              context=None):
     if context is None:
         self._context = ParseContext()
     else:
         self._context = ParseContext(context=context)
     # We have to distinguish which type of initialization we have
     if typestr_in is not None:
         if line_in is not None:
             raise ParseInternalError(
                 "typestr_in and line_in cannot both be used in a single call",
                 self._context)
         # End if
         self._typestr = typestr_in
         self.default_kind = kind_in is None
         if kind_in is None:
             self._kind = None
         elif kind_in[0] == '(':
             # Parse an explicit kind declaration
             self._kind = self.parse_kind_selector(kind_in)
         else:
             # The kind has already been parsed for us (e.g., by character)
             self._kind = kind_in
     elif kind_in is not None:
         raise ParseInternalError(
             "kind_in cannot be passed without typestr_in", self._context)
     elif line_in is not None:
         match = Ftype.type_match(line_in)
         self._match_len = len(match.group(0))
         if match is None:
             raise ParseSyntaxError("type declaration",
                                    token=line_in,
                                    context=self._context)
         elif check_fortran_intrinsic(match.group(1)):
             self._typestr = match.group(1)
             if match.group(2) is not None:
                 # Parse kind section
                 self._kind = self.parse_kind_selector(
                     match.group(2).strip())
             else:
                 self._kind = None
             # End if
             self.default_kind = self._kind is None
         else:
             raise ParseSyntaxError("type declaration",
                                    token=line_in,
                                    context=self._context)
     else:
         raise ParseInternalError(
             "At least one of typestr_in or line must be passed",
             self._context)
示例#3
0
 def __init__(self,
              typestr_in=None,
              kind_in=None,
              match_len_in=None,
              line_in=None,
              context=None):
     """Initialize  this FType object, either using <typestr_in> and
     <kind_in>, OR using line_in."""
     if context is None:
         self.__context = ParseContext()
     else:
         self.__context = ParseContext(context=context)
     # end if
     # We have to distinguish which type of initialization we have
     self.__typestr = typestr_in
     if typestr_in is not None:
         if line_in is not None:
             emsg = "Cannot pass both typestr_in and line_in as arguments"
             raise ParseInternalError(emsg, self.__context)
         # end if
         self.__default_kind = kind_in is None
         if kind_in is None:
             self.__kind = None
         elif kind_in[0] == '(':
             # Parse an explicit kind declaration
             self.__kind = self.parse_kind_selector(kind_in)
         else:
             # The kind has already been parsed for us (e.g., by character)
             self.__kind = kind_in
         # end if
         if match_len_in is not None:
             self.__match_len = match_len_in
         else:
             self.__match_len = len(self.typestr)
             if kind_in is not None:
                 self.__match_len += len(self.__kind) + 2
             # end if
         # end if
     elif kind_in is not None:
         emsg = "kind_in cannot be passed without typestr_in"
         raise ParseInternalError(emsg, self.__context)
     elif line_in is not None:
         match = Ftype.type_match(line_in)
         if match is None:
             emsg = "type declaration"
             raise ParseSyntaxError(emsg,
                                    token=line_in,
                                    context=self.__context)
         # end if
         if match_len_in is not None:
             self.__match_len = match_len_in
         else:
             self.__match_len = len(match.group(0))
         # end if
         if check_fortran_intrinsic(match.group(1)):
             self.__typestr = match.group(1)
             if match.group(2) is not None:
                 # Parse kind section
                 kmatch = match.group(2).strip()
                 self.__kind = self.parse_kind_selector(kmatch)
             else:
                 self.__kind = None
             # end if
             self.__default_kind = self.__kind is None
         else:
             raise ParseSyntaxError("type declaration",
                                    token=line_in,
                                    context=self.__context)
         # end if
     else:
         emsg = "At least one of typestr_in or line_in must be passed"
         raise ParseInternalError(emsg, self.__context)