Merge branch 'upstream' into development

dictsource/it_listx

 cortile $2
 cortisol $3
 cortocircuito  kO@-*totSi@-*k'uito
-cosa $alt
+cos  $alt
 cosc  $alt
 coscia  $alt
 cosen  $alt2
-cosi $2
 cosm  $alt
 cosmic  $alt
 cosm  $alt
 ros  $alt
 rosalia $3
 roseo $1  $alt
-rose $2
 rosolia $3
 rospigliosi  $alt2
 rosp  $alt

dictsource/pt_list

 careta		$alt2
 carreta		$alt2
 casebre		$alt
+cateto		$alt2
 catorze		$alt2
 cefaleia	$alt
 cerca		$alt $verb
 desprezo	$alt $verb
 deva		$alt2
 devo		$alt2
+deveras		$alt
 dez		$alt
 diarreia	$alt
 discordo	$alt
 estiveres	$alt
 estrofe		$alt
 etiqueta	$alt2
+europa		$alt
 exagero		$alt $verb
 expeça		$alt2
 expeço		$alt2
 farofa		$alt
 febre		$alt
+feitora		$alt2
 fera		$alt
 fere		$alt
 ferem		$alt
+ferozes		$alt
 fezes		$alt
 folga		$alt
 fogos		$alt
 martelo		$alt
 merda		$alt
 megera		$alt
+mentora		$alt2
+metro		$alt
 mexa		m'eS&
 mexi		meS'i
 mexo		m'eSU
 naquele		$alt2
 negro		$alt2
 novos		$alt
-obstera		$alt
+obstetra	$alt
 obsoleta	$alt2
 obsoleto	$alt2
 odisseia	$alt
 onu		$1
 opereta		$alt2
+ordens		$alt
 osso		$alt2
 ovos		$alt
 padeceste	$alt2
 paexa		paeSa
 pangeia		$alt
 palheta		$alt2
+paralelo	$alt
 parede		$alt2
 pastora		$alt2
 pedra		$alt
 selvagem	seUv'aZeIN
 sincera		$alt
 sincero		$alt
+sinopse		$alt
 sobe		$alt
 sobem		$alt
 soco		$alt2
 travesso	$alt2
 trevo		$alt2
 troco		$alt2 $noun
+tropa		$alt
 tropeço		$alt2 $noun
 trombeta	$alt2
 valeta		$alt2
 vanessa		$alt2
+velozes		$alt
 verbo		$alt
 verme		$alt
 vierem		$alt
 violeta		$alt2
+voga		$alt
 vozes		$alt
 zelo		$alt $verb
 zero		$alt

dictsource/pt_rules

 .L03 a am o
 .L04 a am e em o ue uem
 .L05 r ra ram re rem rdes
+.L06 ra ram ste re rem
 
 
 .group a
 ?1   v) e (l_      ,E        // eg: possível, amovível, disponível, etc...
 ?1   l) e (ta      'E        // eg: bicicleta, atleta.
 
+
+    sf) e (ra_      E        // esfera, biosfera
+   
 //sort
     qu) e (brL04_   E
  _hosp) e (dL03_    E
   _atr) e (vL03_    e
  _escr) e (vL03_    e
 _descr) e (vL03_    e
-_embel) e (zL01_    e
+_embel) e (zL04_    E
    _pr) e (zL04_    E
 _acont) e (çL01_    e
   _ado) e (çL03_    e
 _esclar) e (çL03_    e
 _reapar) e (çL03_   e
 _reconh) e (çL03_   e
+  _coop) e (rL04_   E
+   _sup) e (rL04_   E
+   _imp) e (rL03_   E
+  _temp) e (rL04_   E
 //endsort
 
  _exag) e (L05_     E
  _houv) e (L05_     E
  _soub) e (L05_     E
 
+ _compreend) e (L06_ e
+ _correspond) e (L06_ e
+ _entend) e (L06_   e
+ _estend) e (L06_   e
+ _respond)e (L06_   e
+  _vend) e (L06_    e
 
 .group é
         é          ''E
      c) o (rrL01_  o   // escorra, incorra, corra, recorra
     _m) o (rrL01_  o
      p) ostos (_   Ost=Us#   // dispostos etc.
+  _esn) o (bL04_   O
 //endsort
 
 .group ô
      r) u (_A      u
         u (A_      'u
 
+        u (em_    'u
         ui         uI
         u (iu      w
         u (iCK     u

dictsource/ta_rules

      _) த (ீரரை		d
      _) த (ீர்க		d
      _) த (ீர்க்க		t
-_) தீர்க்க (_சுமங்கலி	dirggV
+_) தீர்க்க (_சுமங்கலி	di:rggV
      _) தீர்க்க (தரிச	di:rggV
      _) தீர்க்க (த்துடன	di:rggV#
      _) த (ீர்க்கமா		d

src/compiledict.cpp

 			}
 			continue;
 		}
-		
+
 		if(rb == RULE_DOLLAR)
 		{
 			value = *rule++ & 0xff;
 	int  multiple_numeric_hyphen = 0;
 	char *multiple_string = NULL;
 	char *multiple_string_end = NULL;
-	
+
 	int len_word;
 	int len_phonetic;
 	int text_not_phonemes;   // this word specifies replacement text, not phonemes
 	unsigned int  wc;
 	int all_upper_case;
-	
+
 	char *mnemptr;
 	unsigned char flag_codes[100];
 	char encoded_ph[200];
 #endif
 
 	step = 0;
-	
+
 	c = 0;
 	while(c != '\n')
 	{
 		c = *p;
-	
+
 		if((c == '?') && (step==0))
 		{
 			// conditional rule, allow only if the numbered condition is set for the voice
 			flag_codes[n_flag_codes++] = ix + flag_offset;
 			c = *p;
 		}
-		
+
 		if((c == '$') && isalnum(p[1]))
 		{
 			/* read keyword parameter */
 			mnemptr = p;
 			while(!isspace2(c = *p)) p++;
 			*p = 0;
-	
+
 			flagnum = LookupMnem(mnem_flags,mnemptr);
 			if(flagnum > 0)
 			{
 				error_count++;
 			}
 		}
-	
+
 		if((c == '/') && (p[1] == '/') && (multiple_words==0))
 		{
 			c = '\n';   /* "//" treat comment as end of line */
 		}
-	
+
 		switch(step)
 		{
 		case 0:
 				step = 1;
 			}
 			break;
-	
+
 		case 1:
 			if((c == '-') && multiple_words)
 			{
 				step = 3;
 			}
 			break;
-	
+
 		case 3:
 			if(!isspace2(c))
 			{
 				step = 4;
 			}
 			break;
-	
+
 		case 4:
 			if(isspace2(c))
 			{
 				step = 5;
 			}
 			break;
-	
+
 		case 5:
 			break;
 		}
 		p++;
 	}
-	
+
 	if(word[0] == 0)
 	{
 		return(0);   /* blank line */
 
 	*hash = HashDictionary(word);
 	len_phonetic = strlen(encoded_ph);
-	
+
 	dict_line[1] = len_word;   // bit 6 indicates whether the word has been compressed
 	len_word &= 0x3f;
 
 		length = len_word + len_phonetic + 3;
 		strcpy(&dict_line[(len_word)+2],encoded_ph);
 	}
-	
+
 	for(ix=0; ix<n_flag_codes; ix++)
 	{
 		dict_line[ix+length] = flag_codes[ix];
 		fflush(f_log);
 #endif
 	}
-	
+
 	for(hash=0; hash<N_HASH_DICT; hash++)
 	{
 		p = hash_chains[hash];
 		hash_counts[hash] = (int)ftell(f_out);
-	
+
 		while(p != NULL)
 		{
 			length = *(p+sizeof(char *));
 	char buf[200];
 	char fname[sizeof(path_home)+45];
 	char dict_line[128];
-	
+
 	text_mode = 0;
 
 	// try with and without '.txt' extension
 	fprintf(f_log,"Compiling: '%s'\n",fname);
 
 	linenum=0;
-	
+
 	while(fgets(buf,sizeof(buf),f_in) != NULL)
 	{
 		linenum++;
 		if(length == 0)  continue;   /* blank line */
 
 		hash_counts[hash]++;
-	
+
 		p = (char *)malloc(length+sizeof(char *));
 		if(p == NULL)
 		{
 			}
 			break;
 		}
-	
+
 		memcpy(p,&hash_chains[hash],sizeof(char *));
 		hash_chains[hash] = p;
 		memcpy(p+sizeof(char *),dict_line,length);
 		count++;
 	}
-	
+
 	fprintf(f_log,"\t%d entries\n",count);
 	fclose(f_in);
 	return(0);
 		output = &rule_phonemes[len];
 	}
 	sxflags = 0x808000;           // to ensure non-zero bytes
-	
+
 	for(p=string,ix=0;;)
 	{
 		literal = 0;
 						case 'a':
 							sxflags |= SUFX_A;
 							break;
+                        case 'm':
+                            sxflags |= SUFX_M;
+                            break;
 						default:
 							if(isdigit(c))
 								value = (value*10) + (c - '0');
 	rule_phonemes[0]=0;
 
 	p = buf;
-	
+
 	for(ix=0; finish==0; ix++)
 	{
 		c = input[ix];
 			copy_rule_string(buf,state);
 			p = buf;
 			break;
-			
+
 		case '(':		// start of suffix section
 			*p = 0;
 			state = 2;
 				error_count++;
 			}
 			break;
-			
+
 		case '\n':		// end of line
 		case '\r':
 		case 0:			// end of line
 			copy_rule_string(buf,state);
 			finish=1;
 			break;
-			
+
 		case '\t':		// end of section section
 		case ' ':
 			*p = 0;
 			copy_rule_string(buf,state);
 			p = buf;
 			break;
-			
+
 		case '?':
 			if(state==2)
 				state=0;
 			break;
 		}
 	}
-	
+
 	if(strcmp(rule_match,"$group")==0)
 		strcpy(rule_match,group_name);
 
 	}
 	strcpy(output,buf);
 	len = strlen(buf)+1;
-	
+
 	len_name = strlen(group_name);
 	if((len_name > 0) && (memcmp(rule_match,group_name,len_name) != 0))
 	{
 		len1 = strlen(p) + 1;
 		p = &p[len1];
 		len2 = strlen(p);
-		
+
 		rule_match[0]=0;
 		rule_pre[0]=0;
 		rule_post[0]=0;
 			}
 		}
 		*pout = 0;
-		
+
 		spaces = 12;
 		if(condition > 0)
 		{
 			fprintf(f_out,"%s",buf);
 			spaces = 0;
 		}
-		
+
 		for(ix=0; ix<spaces; ix++)
 			fputc(' ',f_out);
-		
+
 		spaces = 14;
 		sprintf(buf," %s ",rule_match);
 		if(rule_post[0] != 0)
 	int n_rgroups = 0;
 	int n_groups3 = 0;
 	RGROUP rgroup[N_RULE_GROUP2];
-	
+
 	linenum = 0;
 	group_name[0] = 0;
 
 			if((p = (unsigned char *)strstr(buf,"//")) != NULL)
 				*p = 0;
 
-			if(buf[0] == '\r') buf++;  // ignore extra \r in \r\n 
+			if(buf[0] == '\r') buf++;  // ignore extra \r in \r\n
 		}
 
 		if((buf == NULL) || (buf[0] == '.'))
 				{
 					// group character is given as a character code (max 16 bits)
 					p = (unsigned char *)group_name;
-	
+
 					if(char_code > 0x100)
 					{
 						*p++ = (char_code >> 8);
 						}
 					}
 				}
-	
+
 				if((group3_ix == 0) && (strlen(group_name) > 2))
 				{
 					if(utf8_in(&c,group_name) < 2)
 						fprintf(f_log,"%5d: Group name longer than 2 bytes (UTF8)",linenum);
 						error_count++;
 					}
-	
+
 					group_name[2] = 0;
 				}
 			}
 
 			continue;
 		}
-		
+
 		switch(compile_mode)
 		{
 		case 1:    //  .group
 		compile_dictlist_file(path,"list");
 	}
 	compile_dictlist_file(path,"extra");
-	
+
 	compile_dictlist_end(f_out);
 	offset_rules = ftell(f_out);
-	
+
 	fprintf(f_log,"Compiling: '%s'\n",fname_in);
 
 	compile_dictrules(f_in,f_out,fname_temp);

src/dictionary.cpp

 		{
 			if(vowel_stress[ix] == 4)
 					vowel_stress[ix] = 3;    // change marked stress (consonant clusters) to secondary (except the last)
-	
+
 			if(vowel_length[ix] > 0)
 			{
 					long_vowel = ix;
 					vowel_stress[ix] = 3;    // give secondary stress to all long vowels
 			}
 		}
-	
+
 		// 'stressed_syllable' gives the last marked stress
 		if(stressed_syllable == 0)
 		{
 			*word_end = 'e';
 	}
 	i = word_end - word;
-	memcpy(word_copy,word,i);
-	word_copy[i] = 0;
+
+	if(word_copy != NULL)
+	{
+	    memcpy(word_copy,word,i);
+	    word_copy[i] = 0;
+	}
 
 	// look for multibyte characters to increase the number of bytes to remove
 	for(len_ending = i = (end_type & 0x3f); i>0 ;i--)   // num.of characters of the suffix

src/translate.cpp

 
 int utf8_in2(int *c, const char *buf, int backwards)
 {//=================================================
-// Read a unicode characater from a UTF8 string 
+// Read a unicode characater from a UTF8 string
 // Returns the number of UTF8 bytes used.
 // backwards: set if we are moving backwards through the UTF8 string
 	int c1;
 
 int utf8_in(int *c, const char *buf)
 {//=================================
-// Read a unicode characater from a UTF8 string 
+// Read a unicode characater from a UTF8 string
 // Returns the number of UTF8 bytes used.
 	return(utf8_in2(c,buf,0));
 }
 	unsigned int dictionary_flags[2];
 	unsigned int dictionary_flags2[2];
 	int end_type=0;
+	int end_type1=0;
 	int prefix_type=0;
 	int prefix_stress;
 	char *wordx;
 	char phonemes[N_WORD_PHONEMES];
+    char phonemes2[N_WORD_PHONEMES];
 	char prefix_phonemes[N_WORD_PHONEMES];
 	char unpron_phonemes[N_WORD_PHONEMES];
 	char end_phonemes[N_WORD_PHONEMES];
+	char end_phonemes2[N_WORD_PHONEMES];
 	char word_copy[N_WORD_BYTES];
 	char word_copy2[N_WORD_BYTES];
 	int word_copy_length;
-	char prefix_chars[0x3f + 2];  
+	char prefix_chars[0x3f + 2];
 	int found=0;
-   int end_flags;
+    int end_flags;
 	char c_temp;   // save a character byte while we temporarily replace it with space
 	int first_char;
 	int last_char = 0;
 	int add_plural_suffix = 0;
 	int prefix_flags = 0;
+	int more_suffixes;
 	int confirm_prefix;
 	int spell_word;
 	int stress_bits;
 			// the word has $abbrev flag, but no pronunciation specified.  Speak as individual letters
 			spell_word = 1;
 		}
- 
+
 		if(!found && iswdigit(first_char))
 		{
 			Lookup(tr,"_0lang",word_phonemes);
 				if(confirm_prefix && !(end_type & SUFX_B))
 				{
 					int end2;
-					char phonemes2[N_WORD_PHONEMES];
 					char end_phonemes2[N_WORD_PHONEMES];
 
 					// remove any standard suffix and confirm that the prefix is still recognised
 					for(ix=0; ix < n_chars; ix++)    // num. of bytes to remove
 					{
 						prefix_chars[pfix++] = *wordx++;
-	
+
 						if((prefix_type & SUFX_B) && (ix == (n_chars-1)))
 						{
 							prefix_chars[pfix-1] = 0;  // discard the last character of the prefix, this is the separator character
 				}
 			}
 
+
+
+
 			if((end_type != 0) && !(end_type & SUFX_P))
 			{
-char phonemes2[N_WORD_PHONEMES];
-strcpy(phonemes2,phonemes);
+                end_type1 = end_type;
+                strcpy(phonemes2,phonemes);
 
 				// The word has a standard ending, re-translate without this ending
 				end_flags = RemoveEnding(tr, wordx, end_type, word_copy);
-
-				phonemes[0] = 0;
-
-				if(prefix_phonemes[0] != 0)
-				{
-					// lookup the stem without the prefix removed
-					wordx[-1] = c_temp;
-					found = LookupDictList(tr, &word1, phonemes, dictionary_flags2, end_flags, wtab);  // include prefix, but not suffix
-					wordx[-1] = ' ';
-					if(phonemes[0] == phonSWITCH)
-					{
-						// change to another language in order to translate this word
-						memcpy(wordx,word_copy,strlen(word_copy));
-						strcpy(word_phonemes,phonemes);
-						return(0);
-					}
-					if(dictionary_flags[0]==0)
-					{
-						dictionary_flags[0] = dictionary_flags2[0];
-						dictionary_flags[1] = dictionary_flags2[1];
-					}
-					if(found)
-						prefix_phonemes[0] = 0;  // matched whole word, don't need prefix now
-
-					if((found==0) && (dictionary_flags2[0] != 0))
-						prefix_flags = 1;
-				}
-				if(found == 0)
-				{
-					found = LookupDictList(tr, &wordx, phonemes, dictionary_flags2, end_flags, wtab);  // without prefix and suffix
-					if(phonemes[0] == phonSWITCH)
-					{
-						// change to another language in order to translate this word
-						memcpy(wordx,word_copy,strlen(word_copy));
-						strcpy(word_phonemes,phonemes);
-						return(0);
-					}
-
-if(dictionary_flags2[0] & FLAG_ABBREV)
-{
-	// Removing the suffix leaves a word which should be spoken as individual letters
-	// Not yet implemented
-}
-					if(dictionary_flags[0]==0)
-					{
-						dictionary_flags[0] = dictionary_flags2[0];
-						dictionary_flags[1] = dictionary_flags2[1];
-					}
-				}
-				if(found == 0)
-				{
-					if(end_type & SUFX_Q)
-					{
-						// don't retranslate, use the original lookup result
-						strcpy(phonemes,phonemes2);
-
-						// language specific changes
-						ApplySpecialAttribute(tr,phonemes,dictionary_flags[0]);
-					}
-					else
-					{
-						if(end_flags & FLAG_SUFX)
-							wflags |= FLAG_SUFFIX_REMOVED;
-						if(end_type & SUFX_A)
-							wflags |= FLAG_SUFFIX_VOWEL;
-
-						TranslateRules(tr, wordx, phonemes, N_WORD_PHONEMES, NULL, wflags, dictionary_flags);
-
-						if(phonemes[0] == phonSWITCH)
-						{
-							// change to another language in order to translate this word
-							strcpy(word_phonemes,phonemes);
-							memcpy(wordx,word_copy,strlen(word_copy));
-							wordx[-1] = c_temp;
-							return(0);
-						}
-					}
-				}
-
-				if((end_type & SUFX_T) == 0)
+                more_suffixes = 1;
+
+                while(more_suffixes)
+                {
+                    more_suffixes = 0;
+                    phonemes[0] = 0;
+
+                    if(prefix_phonemes[0] != 0)
+                    {
+                        // lookup the stem without the prefix removed
+                        wordx[-1] = c_temp;
+                        found = LookupDictList(tr, &word1, phonemes, dictionary_flags2, end_flags, wtab);  // include prefix, but not suffix
+                        wordx[-1] = ' ';
+                        if(phonemes[0] == phonSWITCH)
+                        {
+                            // change to another language in order to translate this word
+                            memcpy(wordx,word_copy,strlen(word_copy));
+                            strcpy(word_phonemes,phonemes);
+                            return(0);
+                        }
+                        if(dictionary_flags[0]==0)
+                        {
+                            dictionary_flags[0] = dictionary_flags2[0];
+                            dictionary_flags[1] = dictionary_flags2[1];
+                        }
+                        if(found)
+                            prefix_phonemes[0] = 0;  // matched whole word, don't need prefix now
+
+                        if((found==0) && (dictionary_flags2[0] != 0))
+                            prefix_flags = 1;
+                    }
+                    if(found == 0)
+                    {
+                        found = LookupDictList(tr, &wordx, phonemes, dictionary_flags2, end_flags, wtab);  // without prefix and suffix
+                        if(phonemes[0] == phonSWITCH)
+                        {
+                            // change to another language in order to translate this word
+                            memcpy(wordx,word_copy,strlen(word_copy));
+                            strcpy(word_phonemes,phonemes);
+                            return(0);
+                        }
+
+    if(dictionary_flags2[0] & FLAG_ABBREV)
+    {
+        // Removing the suffix leaves a word which should be spoken as individual letters
+        // Not yet implemented
+    }
+                        if(dictionary_flags[0]==0)
+                        {
+                            dictionary_flags[0] = dictionary_flags2[0];
+                            dictionary_flags[1] = dictionary_flags2[1];
+                        }
+                    }
+                    if(found == 0)
+                    {
+                        if(end_type & SUFX_Q)
+                        {
+                            // don't retranslate, use the original lookup result
+                            strcpy(phonemes,phonemes2);
+
+                            // language specific changes
+                            ApplySpecialAttribute(tr,phonemes,dictionary_flags[0]);
+                        }
+                        else
+                        {
+                            if(end_flags & FLAG_SUFX)
+                                wflags |= FLAG_SUFFIX_REMOVED;
+                            if(end_type & SUFX_A)
+                                wflags |= FLAG_SUFFIX_VOWEL;
+
+                            if(end_type & SUFX_M)
+                            {
+                                // allow more suffixes before this suffix
+                                strcpy(end_phonemes2, end_phonemes);
+                                end_type = TranslateRules(tr, wordx, phonemes, N_WORD_PHONEMES, end_phonemes, wflags, dictionary_flags);
+                                strcat(end_phonemes, end_phonemes2);   // add the phonemes for the previous suffixes after this one
+
+                                if((end_type != 0) && !(end_type & SUFX_P))
+                                {
+                                    // there is another suffix
+				                    end_flags = RemoveEnding(tr, wordx, end_type, NULL);
+                                    more_suffixes = 1;
+                                }
+                            }
+                            else
+                            {
+                                // don't remove any previous suffix
+                                TranslateRules(tr, wordx, phonemes, N_WORD_PHONEMES, NULL, wflags, dictionary_flags);
+                                end_type = 0;
+                            }
+
+                            if(phonemes[0] == phonSWITCH)
+                            {
+                                // change to another language in order to translate this word
+                                strcpy(word_phonemes,phonemes);
+                                memcpy(wordx,word_copy,strlen(word_copy));
+                                wordx[-1] = c_temp;
+                                return(0);
+                            }
+                        }
+                    }
+                }
+
+
+				if((end_type1 & SUFX_T) == 0)
 				{
 					// the default is to add the suffix and then determine the word's stress pattern
 					AppendPhonemes(tr,phonemes, N_WORD_PHONEMES, end_phonemes);
 				}
 				memcpy(wordx,word_copy,strlen(word_copy));
 			}
+
+
+
+
 			wordx[-1] = c_temp;
 		}
 	}
 
 	// dictionary flags for this word give a clue about which alternative pronunciations of
 	// following words to use.
-	if(end_type & SUFX_F)
+	if(end_type1 & SUFX_F)
 	{
 		// expect a verb form, with or without -s suffix
 		tr->expect_verb = 2;
 						ok = 0;
 					}
 				}
-	
+
 				if((sylimit & 0x200) && ((wtab+1)->flags & FLAG_LAST_WORD))
 				{
 					// not if the next word is end-of-sentence
 		else
 		if(ph_code == phonX1)
 		{
-			// a language specific action 
+			// a language specific action
 			if(tr->langopts.param[LOPT_IT_DOUBLING])
 			{
 				flags |= FLAG_DOUBLING;
 			{
 				if(first_phoneme && tr->langopts.param[LOPT_IT_DOUBLING])
 				{
-					if(((tr->prev_dict_flags & FLAG_DOUBLING) && (tr->langopts.param[LOPT_IT_DOUBLING] & 1)) || 
+					if(((tr->prev_dict_flags & FLAG_DOUBLING) && (tr->langopts.param[LOPT_IT_DOUBLING] & 1)) ||
 						(tr->end_stressed_vowel && (tr->langopts.param[LOPT_IT_DOUBLING] & 2)))
 					{
 						// italian, double the initial consonant if the previous word ends with a
 }
 #endif
 			if((c == 0x92) || (c == 0xb4) || (c == 0x2019) || (c == 0x2032))
-				c = '\'';    // 'microsoft' quote or sexed closing single quote, or prime - possibly used as apostrophe 
+				c = '\'';    // 'microsoft' quote or sexed closing single quote, or prime - possibly used as apostrophe
 
 			if(((c == 0x2018) || (c == '?')) && IsAlpha(prev_out) && IsAlpha(next_in))
 			{
 			{
 				if((next_in == '\002') || ((next_in == '[') && option_phoneme_input))
 				{
-					//  "[\002" is used internally to start phoneme mode  
+					//  "[\002" is used internally to start phoneme mode
 					phoneme_mode = FLAG_PHONEMES;
 					source_index++;
 					continue;
 				if(!IsSpace(prev_in) && IsAlpha(next_in))
 				{
 					if(prev_out != ' ')
-					{	
+					{
 						// previous 'word' not yet ended (not alpha or numeric), start new word now.
 						c = ' ';
 						space_inserted = 1;
 	if((word_count==0) && (embedded_count > 0))
 	{
 		// add a null 'word' to carry the embedded command flag
-		embedded_list[embedded_ix-1] |= 0x80; 
+		embedded_list[embedded_ix-1] |= 0x80;
 		words[word_count].flags |= FLAG_EMBEDDED;
 		word_count = 1;
 	}
 			ix--;  // the last word is a bracket, mark the previous word as last
 		words[ix].flags |= FLAG_LAST_WORD;
 
-		// FLAG_NOSPACE check to avoid recognizing  .mr  -mr 
+		// FLAG_NOSPACE check to avoid recognizing  .mr  -mr
 		if((terminator & CLAUSE_DOT) && !(words[word_count-1].flags & FLAG_NOSPACE))
 			words[word_count-1].flags |= FLAG_HAS_DOT;
 	}

src/translate.h

 #define SUFX_T        0x10000   // don't affect the stress position in the stem
 #define SUFX_B        0x20000  // break, this character breaks the word into stem and suffix (used with SUFX_P)
 #define SUFX_A        0x40000  // remember that the suffix starts with a vowel
+#define SUFX_M        0x80000  // bit 19, allow multiple suffixes
 
 #define SUFX_UNPRON     0x8000   // used to return $unpron flag from *_rules