def __parse_hgvs_syntax(self, aa_hgvs):
        """Convert HGVS syntax for amino acid change into attributes.

        Specific details of the mutation are stored in attributes like
        self.intial (prior to mutation), sel.pos (mutation position),
        self.mutated (mutation), and self.stop_pos (position of stop codon,
        if any).

        Args:
            aa_hgvs (str): amino acid string following HGVS syntax
        """
        self.is_valid = True  # assume initially the syntax is legitimate
        self.is_synonymous = False  # assume not synonymous until proven
        if self.unknown_effect or self.is_no_protein:
            # unknown effect from mutation. usually denoted as p.?
            self.pos = None
            pass
        elif self.is_lost_stop:
            self.initial = aa_hgvs[0]
            self.mutated = re.findall('([A-Z?*]+)$', aa_hgvs)[0]
            self.pos = int(re.findall('^\*(\d+)', aa_hgvs)[0])
            self.stop_pos = None
        elif self.is_lost_start:
            self.initial = aa_hgvs[0]
            self.mutated = aa_hgvs[-1]
            self.pos = int(aa_hgvs[1:-1])
        elif self.is_missense:
            self.initial = aa_hgvs[0]
            self.mutated = aa_hgvs[-1]
            self.pos = int(aa_hgvs[1:-1])
            self.stop_pos = None  # not a nonsense mutation
            if self.initial == self.mutated:
                self.is_synonymous = True
                self.is_non_silent = False
            elif self.mutated == '*':
                self.is_nonsense_mutation = True
        elif self.is_indel:
            if self.is_insertion:
                if not self.is_missing_info:
                    self.initial = re.findall('([A-Z])\d+', aa_hgvs)[:2]  # first two
                    self.pos = tuple(map(int, re.findall('[A-Z](\d+)', aa_hgvs)[:2]))  # first two
                    self.mutated = re.findall('(?<=INS)[A-Z0-9?*]+', aa_hgvs)[0]
                    self.mutated = self.mutated.strip('?')  # remove the missing info '?'
                else:
                    self.initial = ''
                    self.pos = tuple()
                    self.mutated = ''
            elif self.is_deletion:
                if not self.is_missing_info:
                    self.initial = re.findall('([A-Z])\d+', aa_hgvs)
                    self.pos = tuple(map(int, re.findall('[A-Z](\d+)', aa_hgvs)))
                    self.mutated = re.findall('(?<=DEL)[A-Z]*', aa_hgvs)[0]
                else:
                    self.initial = ''
                    self.pos = tuple()
                    self.mutated = ''
        elif self.is_frame_shift:
            self.initial = aa_hgvs[0]
            self.mutated = ''
            try:
                self.pos = int(re.findall('[A-Z*](\d+)', aa_hgvs)[0])
                if self.is_premature_stop_codon:
                    self.stop_pos = int(re.findall('\*>?(\d+)$', aa_hgvs)[0])
                else:
                    self.stop_pos = None
            except IndexError:
                # unconventional usage of indicating frameshifts will cause
                # index errors. For example, in some cases 'fs' is not used.
                # In other cases, either amino acids were not included or
                # just designated as a '?'
                self.logger.debug('(Parsing-Problem) frame shift hgvs string: "%s"' % aa_hgvs)
                self.pos = None
                self.stop_pos = None
                self.is_missing_info = True
        elif self.is_nonsense_mutation:
            self.initial = aa_hgvs[0]
            self.mutated = '*'  # there is actually a stop codon
            self.stop_pos = 0  # indicates same position is stop codon
            try:
                self.pos = int(aa_hgvs[1:-1])
            except ValueError:
                # wierd error of p.E217>D*
                self.is_valid = False
                self.pos = None
                self.logger.debug('(Parsing-Problem) Invalid HGVS Amino Acid '
                                  'syntax: ' + aa_hgvs)
            if self.initial == self.mutated:
                # classify nonsense-to-nonsense mutations as synonymous
                self.is_synonymous = True
                self.is_non_silent = False
        else:
            self.is_valid = False  # did not match any of the possible cases
            self.logger.debug('(Parsing-Problem) Invalid HGVS Amino Acid '
                              'syntax: ' + aa_hgvs)