syllable.cpp

/********************************************************************************
 * Separador silábico para el Español                                           *
 * Autor  : Zenón J. Hernández Figueroa                                         *
 *          Gustavo Rodríguez Rodríguez                                         *
 *          Francisco Carreras Riudavets                                        *
 * Version: 1.1                                                                 *
 * Date   : 12-02-2010                                                          *
 *                                                                              *
 *------------------------------------------------------------------------------*
 * Copyright (C) 2009 TIP: Text & Information Processing                        *
 * (http://tip.dis.ulpgc.es)                                                    *
 * All rights reserved.                                                         *
 *                                                                              *
 * This file is part of SeparatorOfSyllables                                    *
 * SeparatorOfSyllables is free software; you can redistribute it and/or        *
 * modify it under the terms of the GNU General Public License                  *
 * as published by the Free Software Foundation; either version 3               *
 * of the License, or (at your option) any later version.                       *
 *                                                                              *
 * This program is distributed in the hope that it will be useful,              *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                *
 * GNU General Public License for more details.                                 *
 *                                                                              *
 * You should have received a copy of the GNU General Public License            *
 * along with this program; if not, write to the Free Software                  *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.   *
 *                                                                              *
 * The "GNU General Public License" (GPL) is available at                       *
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html                        *
 *                                                                              *
 * When citing this resource, please use the following reference:               *
 * Hernández-Figueroa, Z; Rodríguez-Rodríguez, G; Carreras-Riudavets, F (2009). *
 * Separador de sílabas del español - Silabeador TIP.                               *
 * Available at http://tip.dis.ulpgc.es                                         *
 ********************************************************************************/

#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <ctype.h>
#include "syllable.h"

/***************/
/* Constructor */
/***************/

SeparatorOfSyllables::SeparatorOfSyllables () {
	lastWord[0] = '\0';
}

/*********************************************/
/* Returns the number of syllables in a word */
/*********************************************/

int SeparatorOfSyllables::NumberOfSyllables (const char *word) {
  Process (word);
  return numSyl;
}

/****************************************************************/
/* Returns an array with the start positions of every syllables */
/****************************************************************/

int * SeparatorOfSyllables::SyllablePositions (const char *word) {
  Process (word);
  return positions;
}	

/*************************************************/
/* Returns the position of the stressed syllable */
/*************************************************/
	
int SeparatorOfSyllables::StressedSyllable (const char *word) {
  Process (word);
  return stressed;
}

/*********************************************************/
/*********************************************************/
/**             PRIVATE OPERATIONS                      **/
/*********************************************************/
/*********************************************************/

/*************************************************************/
/* Determines whether to call SyllablePositions              */
/* (if word is the same as last processed, it is not needed) */
/*************************************************************/

void SeparatorOfSyllables::Process (const char *word) {
  if (strcmp (word, lastWord) != 0) {
    strcpy (lastWord, word);
    SyllablePositions ();
  }
}

/**************************************************************/
/* Returns an array with the start positions of the syllables */
/**************************************************************/
	
void SeparatorOfSyllables::SyllablePositions () {
  wordLength      = strlen (lastWord);
  stressedFound   = false;
  stressed        = 0;
  numSyl       = 0;
  letterAccent = -1;
  
  // It looks for syllables in the word

  for (int i = 0; i < wordLength;) {
    positions [numSyl++] = i;  // It marks the beginning of the current syllable
    
    // Syllables consist of three parts: onset, nucleus and coda
    
    Onset   (lastWord, i);
    Nucleus (lastWord, i);
    Coda    (lastWord, i);
    
    if ((stressedFound) && (stressed == 0))
      stressed = numSyl; // It marks the stressed syllable
  }
  
  // If the word has not written accent, the stressed syllable is determined
  // according to the stress rules
  
  if (!stressedFound) {
    if (numSyl < 2) stressed = numSyl;  // Monosyllables
    else {                              // Polysyllables
      char endLetter      = tolower(lastWord[wordLength - 1]);
      char previousLetter = tolower(lastWord[wordLength - 2]);
      
      
      if ((!IsConsonant (endLetter) || (endLetter == 'y')) ||
	  (((endLetter == 'n') || (endLetter == 's') && !IsConsonant (previousLetter))))
	stressed = numSyl - 1;	// Stressed penultimate syllable
      else
	stressed = numSyl;		// Stressed last syllable
    }
  }
  
  positions [numSyl] = -1;  // It marks the end of found syllables
}

/************************************/
/* Determines whether hiatus exists */
/************************************/

bool SeparatorOfSyllables::Hiatus () {
  char accented = tolower (lastWord [letterAccent]);
  
  if ((letterAccent > 1) &&  // Hiatus is only possible if there is accent
      (tolower(lastWord [letterAccent - 1]) == 'u') &&
      (tolower(lastWord [letterAccent - 2]) == 'q'))
    return false; // The 'u' letter belonging "qu" doesn't form hiatus

  // The central character of a hiatus must be a close-vowel with written accent
  
  if ((accented == 'í') || (accented == 'ì') || (accented == 'ú') || (accented == 'ù')) {
    
    if ((letterAccent > 0) && OpenVowel (lastWord [letterAccent - 1])) return true;
    
    if ((letterAccent < (wordLength - 1)) && OpenVowel (lastWord [letterAccent + 1])) return true;		
  }
  
  return false;
}

/********************************************************************/
/* Determines the onset of the current syllable whose begins in pos */
/* and pos is changed to the follow position after end of onset     */
/********************************************************************/

void SeparatorOfSyllables::Onset (const char *pal, int &pos) {
  // Every initial consonant belongs to the onset
  
  char lastConsonant = 'a';
  while ((pos < wordLength) && ((IsConsonant (pal [pos])) && (tolower (pal [pos]) != 'y'))) {
    lastConsonant = tolower (pal [pos]);
    pos++;
  }
  
  // (q | g) + u (example: queso, gueto)
  
  if (pos < wordLength - 1)
    if (tolower (pal [pos]) == 'u') {
      if (lastConsonant == 'q') pos++;
      else
	if (lastConsonant == 'g') {
	  char letter = tolower (pal [pos + 1]);
	  if ((letter == 'e') || (letter == 'é') ||
	      (letter == 'i') || (letter == 'í')) pos ++;
	}
    }
    else { // The 'u' with diaeresis is added to the consonant
      if ((pal [pos] == 'ü') || (pal [pos] == 'Ü'))
	if (lastConsonant == 'g') pos++;
    }
}

/****************************************************************************/
/* Determines the nucleus of current syllable whose onset ending on pos - 1 */
/* and changes pos to the follow position behind of nucleus                 */
/****************************************************************************/

void SeparatorOfSyllables::Nucleus (const char *pal, int &pos) {
  int previous; // Saves the type of previous vowel when two vowels together exists
  // 0 = open
  // 1 = close with written accent
  // 2 = close
  
  if (pos >= wordLength) return; // ¡¿Doesn't it have nucleus?!
  
  // Jumps a letter 'y' to the starting of nucleus, it is as consonant
  
  if (tolower(pal [pos]) == 'y') pos++;
  
  // First vowel
  
  if (pos < wordLength) {
    switch (pal [pos]) {
      // Open-vowel or close-vowel with written accent
    case 'á': case 'Á': case 'à': case 'À':
    case 'é': case 'É': case 'è': case 'È':
    case 'ó': case 'Ó': case 'ò': case 'Ò':
      letterAccent = pos;
      stressedFound   = true;
      // Open-vowel
    case 'a': case 'A':
    case 'e': case 'E':
    case 'o': case 'O':
      previous = 0;
      pos++;
      break;
      // Close-vowel with written accent breaks some possible diphthong
    case 'í': case 'Í': case 'ì': case 'Ì':
    case 'ú': case 'Ú': case 'ù': case 'Ù': case 'ü': case 'Ü':
      letterAccent = pos;
      previous = 1;
      pos++;
      stressedFound = true;
      return;
      break;
      // Close-vowel
    case 'i': case 'I':
    case 'u': case 'U':
      previous = 2;
      pos++;
      break;
    }
  }
  
  // If 'h' has been inserted in the nucleus then it doesn't determine diphthong neither hiatus
  
  bool aitch = false;
  if (pos < wordLength) {
    if (tolower(pal [pos]) == 'h') {
      pos++;
      aitch = true;
    }
  }
  
  // Second vowel
  
  if (pos < wordLength) {
    switch (pal [pos]) {
      // Open-vowel with written accent
    case 'á': case 'Á': case 'à': case 'À':
    case 'é': case 'É': case 'è': case 'È':
    case 'ó': case 'Ó': case 'ò': case 'Ò':
      letterAccent = pos;
      if (previous != 0) {
	stressedFound    = true;
      }
      // Open-vowel
    case 'a': case 'A':
    case 'e': case 'E':
    case 'o': case 'O':
      if (previous == 0) {    // Two open-vowels don't form syllable
	if (aitch) pos--;
	return;
      }
      else {
	pos++;
      }
      
      break;
      
      // Close-vowel with written accent, can't be a triphthong, but would be a diphthong
    case 'í': case 'Í': case 'ì': case 'Ì':
    case 'ú': case 'Ú': case 'ù': case 'Ù':
      letterAccent = pos;
      
      if (previous != 0) {  // Diphthong
	stressedFound    = true;
	pos++;
      }
      else
	if (aitch) pos--;
      
      return;
      // Close-vowel
    case 'i': case 'I':
    case 'u': case 'U': case 'ü': case 'Ü':
      if (pos < wordLength - 1) { // ¿Is there a third vowel?
	if (!IsConsonant (pal [pos + 1])) {
	  if (tolower(pal [pos - 1]) == 'h') pos--;
	  return;
	}
      }
      
      // Two equals close-vowels don't form diphthong
      if (pal [pos] != pal [pos - 1]) pos++; 
      
      return;  // It is a descendent diphthong
      break;
    }
  }
  
  // Third vowel?
  
  if (pos < wordLength) {
    if ((tolower(pal [pos]) == 'i') || (tolower(pal [pos]) == 'u')) { // Close-vowel
      pos++;
      return;  // It is a triphthong	
    }
  }
}

/*****************************************************************************/
/* Determines the coda of the current syllable whose nucleus ends in pos - 1 */
/* and changes pos to follow position to the end of the coda                 */
/*****************************************************************************/
                                       
void SeparatorOfSyllables::Coda (const char *pal, int &pos) {	
  if ((pos >= wordLength) || (!IsConsonant (pal [pos])))
    return; // Syllable hasn't coda
  else {
    if (pos == wordLength - 1) // End of word
      {
	pos++;
	return;
      }
    
    // If there is only a consonant between vowels, it belongs to the following syllable
    
    if (!IsConsonant (pal [pos + 1])) return;
    
    char c1 = tolower (pal [pos]);
    char c2 = tolower (pal [pos + 1]);
    
    // Has the syllable a third consecutive consonant?
    
    if ((pos < wordLength - 2)) {
      char c3 = tolower (pal [pos + 2]);
      
      if (!IsConsonant (c3)) { // There isn't third consonant
	// The groups ll, ch and rr begin a syllable
	
	if ((c1 == 'l') && (c2 == 'l')) return;
	if ((c1 == 'c') && (c2 == 'h')) return;
	if ((c1 == 'r') && (c2 == 'r')) return;
	
	// A consonant + 'h' begins a syllable, except for groups sh and rh
	if ((c1 != 's') && (c1 != 'r') &&
	    (c2 == 'h'))
	  return;
	
	// If the letter 'y' is preceded by the some
	//      letter 's', 'l', 'r', 'n' or 'c' then
	//      a new syllable begins in the previous consonant
	// else it begins in the letter 'y'
	
	if ((c2 == 'y')) {
	  if ((c1 == 's') || (c1 == 'l') || (c1 == 'r') || (c1 == 'n') || (c1 == 'c'))
	    return;
	  
	  pos++;
	  return;
	}
	
	// groups: gl - kl - bl - vl - pl - fl - tl
	
	if ((((c1 == 'b')||(c1 == 'v')||(c1 == 'c')||(c1 == 'k')||
	      (c1 == 'f')||(c1 == 'g')||(c1 == 'p')||(c1 == 't')) && 
	     (c2 == 'l')
	     )
	    ) {
	  return;
	}
	
	// groups: gr - kr - dr - tr - br - vr - pr - fr
	
	if ((((c1 == 'b')||(c1 == 'v')||(c1 == 'c')||(c1 == 'd')||(c1 == 'k')||
	      (c1 == 'f')||(c1 == 'g')||(c1 == 'p')||(c1 == 't')) && 
	     (c2 == 'r')
	     )
	    ) {
	  return;
	}
	
	pos++;
	return;
      }
      else { // There is a third consonant
	if ((pos + 3) == wordLength) { // Three consonants to the end, foreign words?
	  if ((c2 == 'y')) {  // 'y' as vowel
	    if ((c1 == 's') || (c1 == 'l') || (c1 == 'r') || (c1 == 'n') || (c1 == 'c'))
	      return;
	  }
	  
	  if (c3 == 'y') { // 'y' at the end as vowel with c2
	    pos++;
	  }
	  else {	// Three consonants to the end, foreign words?
	    pos += 3;
	  }
	  return;
	}
	
	if ((c2 == 'y')) { // 'y' as vowel
	  if ((c1 == 's') || (c1 == 'l') || (c1 == 'r') || (c1 == 'n') || (c1 == 'c'))
	    return;
	  
	  pos++;
	  return;
	}
	
	// The groups pt, ct, cn, ps, mn, gn, ft, pn, cz, tz and ts begin a syllable
	// when preceded by other consonant
	
	if ((c2 == 'p') && (c3 == 't') ||
	    (c2 == 'c') && (c3 == 't') ||
	    (c2 == 'c') && (c3 == 'n') ||
	    (c2 == 'p') && (c3 == 's') ||
	    (c2 == 'm') && (c3 == 'n') ||
	    (c2 == 'g') && (c3 == 'n') ||
	    (c2 == 'f') && (c3 == 't') ||
	    (c2 == 'p') && (c3 == 'n') ||
	    (c2 == 'c') && (c3 == 'z') ||
	    (c2 == 't') && (c3 == 's') ||
	    (c2 == 't') && (c3 == 's'))
	  {
	    pos++;
	    return;
	  }
	
	if ((c3 == 'l') || (c3 == 'r') ||    // The consonantal groups formed by a consonant
	    // following the letter 'l' or 'r' cann't be
	    // separated and they always begin syllable
	    ((c2 == 'c') && (c3 == 'h')) ||  // 'ch'
	    (c3 == 'y')) {                   // 'y' as vowel
	  pos++;  // Following syllable begins in c2
	}
	else
	  pos += 2; // c3 begins the following syllable
      }
    }
    else {
      if ((c2 == 'y')) return;
      
      pos +=2; // The word ends with two consonants
    }
  }	
}

/***************************************************************************/
/* Determines whether c is a open-vowel or close vowel with written accent */
/***************************************************************************/

bool SeparatorOfSyllables::OpenVowel (char c) {
  switch (c) {
  case 'a': case 'á': case 'A': case 'Á': case 'à': case 'À':
  case 'e': case 'é': case 'E': case 'É': case 'è': case 'È':
  case 'í': case 'Í': case 'ì': case 'Ì':
  case 'o': case 'ó': case 'O': case 'Ó': case 'ò': case 'Ò':
  case 'ú': case 'Ú': case 'ù': case 'Ù':
    return true;
  }
  return false;
}

//**********************************/
/* Determines whether c is a vowel */
/***********************************/

bool SeparatorOfSyllables::IsConsonant (char c) {
  switch (c) {
    // Open-vowel or close-vowel with written accent
  case 'a': case 'á': case 'A': case 'Á': case 'à': case 'À':
  case 'e': case 'é': case 'E': case 'É': case 'è': case 'È':
  case 'í': case 'Í': case 'ì': case 'Ì':
  case 'o': case 'ó': case 'O': case 'Ó': case 'ò': case 'Ò':
  case 'ú': case 'Ú': case 'ù': case 'Ù':
    // Close-vowel 
  case 'i': case 'I':
  case 'u': case 'U':
  case 'ü': case 'Ü':
    return false;
    break;
  }
  
  return true;
}