def _process_macro_default_arg(self):
        """Handle the bit after an '=' in a macro default argument. This is
        probably the trickiest thing. The goal here is to accept all strings
        jinja would accept and always handle block start/end correctly: It's
        fine to have false positives, jinja can fail later.

        Return True if there are more arguments expected.
        """
        while self._parenthesis_stack:
            match = self._expect_match(
                'macro argument',
                # you could have a string
                STRING_PATTERN,
                # a quote, a comma, or a open/close parenthesis
                NON_STRING_MACRO_ARGS_PATTERN,
                # we want to "match", not "search"
                method='match'
            )
            matchgroups = match.groupdict()
            self.advance(match.end())
            if matchgroups.get('string') is not None:
                # we got a string value. There could be more data.
                continue
            elif matchgroups.get('quote') is not None:
                # we got a bunch of data and then a string opening value.
                # put the quote back on the menu
                self.rewind()
                # now look for a string
                match = self._expect_match('any string', STRING_PATTERN)
                self.advance(match.end())
            elif matchgroups.get('comma') is not None:
                # small hack: if we hit a comma and there is one parenthesis
                # left, return to look for a new name. otherwise we're still
                # looking for the parameter close.
                if len(self._parenthesis_stack) == 1:
                    return
            elif matchgroups.get('open'):
                self._parenthesis_stack.append(True)
            elif matchgroups.get('close'):
                self._parenthesis_stack.pop()
            else:
                raise dbt.exceptions.InternalException(
                    'unhandled regex in _process_macro_default_arg(), no match'
                    ': {}'.format(matchgroups)
                )
Handle the bit after an '=' in a macro default argument. This is
        probably the trickiest thing. The goal here is to accept all strings
        jinja would accept and always handle block start/end correctly: It's
        fine to have false positives, jinja can fail later.

        Return True if there are more arguments expected.