def add_lexemes(self, **kw):
        """
        :return: list of dicts corresponding to newly created Lexemes
        """
        lexemes = []

        # Do we have morpheme segmentation on top of phonemes?
        with_morphemes = '+' in self['FormTable', 'Segments'].separator

        for i, form in enumerate(self.dataset.split_forms(kw, kw['Value'])):
            kw_ = kw.copy()
            if form:
                if form != kw_['Value']:
                    self.dataset.log.debug(
                        'iter_forms split: "{0}" -> "{1}"'.format(kw_['Value'], form))
                if form:
                    kw_.setdefault('Segments', self.tokenize(kw_, form) or [])
                    kw_.update(ID=self.lexeme_id(kw), Form=form)
                    lexemes.append(self._add_object(self.dataset.lexeme_class, **kw_))

                    if kw_['Segments']:
                        analysis = self.dataset.tr_analyses.setdefault(
                            kw_['Language_ID'], Analysis())
                        try:
                            segments = kw_['Segments']
                            if with_morphemes:
                                segments = list(chain(*[s.split() for s in segments]))
                            _, _bipa, _sc, _analysis = analyze(segments, analysis)

                            # update the list of `bad_words` if necessary; we precompute a
                            # list of data types in `_bipa` just to make the conditional
                            # checking easier
                            _bipa_types = [type(s) for s in _bipa]
                            if pyclts.models.UnknownSound in _bipa_types or '?' in _sc:
                                self.dataset.tr_bad_words.append(kw_)
                        except ValueError:  # pragma: no cover
                            self.dataset.tr_invalid_words.append(kw_)
                        except (KeyError, AttributeError):  # pragma: no cover
                            print(kw_['Form'], kw_)
                            raise

        return lexemes