Merge branch 'master' of https://github.com/espeak-ng/espeak-ng

src/espeak-ng.c

 // This version of the command-line speak program uses the
 // libespeak.so.1  library
 
-
-
 static const char *help_text =
     "\nespeak-ng [options] [\"<words>\"]\n\n"
     "-f <text file>   Text file to speak\n"
     "\t   List the available voices for the specified language.\n"
     "\t   If <language> is omitted, then list all voices.\n";
 
-
-
-
 int samplerate;
 int quiet = 0;
 unsigned int samples_total = 0;
 char filetype[5];
 char wavefile[200];
 
-
 void DisplayVoices(FILE *f_out, char *language)
 {
 	int ix;
 	}
 }
 
-
-
-
 static void Write4Bytes(FILE *f, int value)
 {
 // Write 4 bytes to a file, least significant first
 	}
 }
 
-
-
 int OpenWavFile(char *path, int rate)
 {
 	static unsigned char wave_hdr[44] = {
 		return 1;
 	}
 
-
 	fwrite(wave_hdr, 1, 24, f_wavfile);
 	Write4Bytes(f_wavfile, rate);
 	Write4Bytes(f_wavfile, rate * 2);
 	return 0;
 }
 
-
-
 static void CloseWavFile()
 {
 	unsigned int pos;
 
 }
 
-
 static int SynthCallback(short *wav, int numsamples, espeak_EVENT *events)
 {
 	char fname[210];
 	return 0;
 }
 
-
 static void PrintVersion()
 {
 	const char *version;
 	printf("eSpeak text-to-speech: %s  Data at: %s\n", version, path_data);
 }
 
-
-
 #ifdef NEED_GETOPT
 struct option {
 	char *name;
 
 	static const char *err_load = "Failed to read ";
 
-
 	FILE *f_text = NULL;
 	char *p_text = NULL;
 	FILE *f_phonemes_out = stdout;
 			else
 				synth_flags |= espeakCHARS_8BIT;
 			break;
-
 		case 'h':
 			printf("\n");
 			PrintVersion();
 			printf("%s", help_text);
 			exit(0);
 			break;
-
 		case 'k':
 			option_capitals = atoi(optarg2);
 			break;
-
 		case 'x':
 			phoneme_options |= espeakPHONEMES_SHOW;
 			break;
-
 		case 'X':
 			phoneme_options |= espeakPHONEMES_TRACE;
 			break;
-
 		case 'm':
 			synth_flags |= espeakSSML;
 			break;
-
 		case 'p':
 			pitch = atoi(optarg2);
 			break;
-
 		case 'q':
 			quiet = 1;
 			break;
-
 		case 'f':
 			strncpy0(filename, optarg2, sizeof(filename));
 			break;
-
 		case 'l':
 			option_linelength = atoi(optarg2);
 			break;
-
 		case 'a':
 			volume = atoi(optarg2);
 			break;
-
 		case 's':
 			speed = atoi(optarg2);
 			break;
-
 		case 'g':
 			wordgap = atoi(optarg2);
 			break;
-
 		case 'v':
 			strncpy0(voicename, optarg2, sizeof(voicename));
 			break;
-
 		case 'w':
 			option_waveout = 1;
 			strncpy0(wavefile, optarg2, sizeof(filename));
 			break;
-
 		case 'z':  // remove pause from the end of a sentence
 			synth_flags &= ~espeakENDPAUSE;
 			break;
-
 		case 0x100:     // --stdin
 			flag_stdin = 1;
 			break;
-
 		case 0x105:     // --stdout
 			option_waveout = 1;
 			strcpy(wavefile, "stdout");
 			break;
-
 		case 0x101:    // --compile-debug
 		case 0x102:     // --compile
 			strncpy0(voicename, optarg2, sizeof(voicename));
 			flag_compile = c;
 			quiet = 1;
 			break;
-
 		case 0x103:     // --punct
 			option_punctuation = 1;
 			if (optarg2 != NULL) {
 				option_punctuation = 2;
 			}
 			break;
-
 		case 0x104:   // --voices
 			espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, data_path, 0);
 			DisplayVoices(stdout, optarg2);
 			exit(0);
-
 		case 0x106:   // -- split
 			if (optarg2 == NULL)
 				samples_split_seconds = 30 * 60;  // default 30 minutes
 			else
 				samples_split_seconds = atoi(optarg2) * 60;
 			break;
-
 		case 0x107:  // --path
 			data_path = optarg2;
 			break;
-
 		case 0x108:  // --phonout
 			if ((f_phonemes_out = fopen(optarg2, "w")) == NULL)
 				fprintf(stderr, "Can't write to: %s\n", optarg2);
 			break;
-
 		case 0x109:  // --pho
 			phoneme_options |= espeakPHONEMES_MBROLA;
 			break;
-
 		case 0x10a:  // --ipa
 			phoneme_options |= espeakPHONEMES_IPA;
 			if (optarg2 != NULL) {
 
 			}
 			break;
-
 		case 0x10b:  // --version
 			PrintVersion();
 			exit(0);
-
 		case 0x10c:  // --sep
 			phoneme_options |= espeakPHONEMES_SHOW;
 			if (optarg2 == 0)
 			if (phonemes_separator == 'z')
 				phonemes_separator = 0x200c;      // ZWNJ
 			break;
-
 		case 0x10d:  // --tie
 			phoneme_options |= (espeakPHONEMES_SHOW | espeakPHONEMES_TIE);
 			if (optarg2 == 0)
 			if (phonemes_separator == 'z')
 				phonemes_separator = 0x200d;      // ZWJ
 			break;
-
 		case 0x10e:  // --compile-mbrola
 			samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, 0);
 			espeak_ng_CompileMbrolaVoice(optarg2, stdout);
 			exit(0);
-
 		case 0x10f:  // --compile-intonations
 			samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, espeakINITIALIZE_PATH_ONLY);
 			espeak_ng_CompileIntonation(stdout);
 			exit(0);
-
 		case 0x110:  // --compile-phonemes
 			samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, espeakINITIALIZE_PATH_ONLY);
 			espeak_ng_CompilePhonemeData(22050, stdout);
 			exit(0);
-
 		default:
 			exit(0);
 		}
 	}
 
-
 	if (option_waveout || quiet) {
 		// writing to a file (or no output), we can use synchronous mode
 		samplerate = espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, data_path, 0);
 		samplerate = espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, data_path, 0);
 	}
 
-
 	if (voicename[0] == 0)
 		strcpy(voicename, "default");
 
 	if (option_punctuation == 2)
 		espeak_SetPunctuationList(option_punctlist);
 
-
 	espeak_SetPhonemeTrace(phoneme_options | (phonemes_separator << 8), f_phonemes_out);
 
 	if (filename[0] == 0) {
 		exit(1);
 	}
 
-
 	if (p_text != NULL) {
 		int size;
 		size = strlen(p_text);

src/libespeak-ng/compiledata.c

 	{ NULL, 0, 0 }
 };
 
-
-
 static keywtab_t k_properties[] = {
 	{ "isPause",      0,  phPAUSE },
 	{ "isVowel",      0,  phVOWEL },
 	{ "afr",       tPHONEME_TYPE, phSTOP },      // treat as stop
 	{ "apr",       tPHONEME_TYPE, phFRICATIVE }, // [h] voiceless approximant
 
-
 	// keywords
 	{ "phonemenumber", tSTATEMENT, kPHONEMENUMBER },
 	{ "phonemetable", tSTATEMENT, kPHONEMETABLE },
 	{ "endtype",    tSTATEMENT, kENDTYPE },
 	{ "voicingswitch", tSTATEMENT, kVOICINGSWITCH },
 
-
 	{ "IF",         tSTATEMENT, kIF },
 	{ "ELSE",       tSTATEMENT, kELSE },
 	{ "ELIF",       tSTATEMENT, kELIF },
 	{ "VowelEnding", tSTATEMENT, kVOWELENDING },
 	{ "addWav",     tSTATEMENT, kANDWAV },
 
-
 	{ "Vowelin",    tSTATEMENT, kVOWELIN },
 	{ "Vowelout",   tSTATEMENT, kVOWELOUT },
 	{ "Continue",   tSTATEMENT, kCONTINUE },
 	{ NULL, 0, -1 }
 };
 
-
 static keywtab_t *keyword_tabs[] = {
 	keywords, k_conditions, k_properties, k_intonation
 };
 
-
 static PHONEME_TAB *phoneme_out;
 
 static int n_phcodes_list[N_PHONEME_TABS];
 static char *p_equivalence;
 static char equivalence_buf[20000];
 
-
 #define N_PROCS 50
 int n_procs;
 int proc_addr[N_PROCS];
 				fprintf(f_out, ")");
 			}
 			break;
-
 		case 2:
 		case 3:
 			if (type2 < 12) {
 			}
 			fprintf(f_out, ")");
 			break;
-
 		case 6:
 			fprintf(f_out, "%s", instn_jumps[(instn >> 9) & 7]);
 			fprintf(f_out, " %d", instn & 0x1ff);
 			break;
-
 		case 9:
 			address = ((data1 & 0xf) << 4) + *pc++;
 			fprintf(f_out, "CALL %.5x", address);
 			break;
-
 		case 10:
 			fprintf(f_out, "%s", instn10_string[type2]);
 			switch (type2)
 				break;
 			}
 			break;
-
 		case 11:
 		case 12:
 		case 13:
 	}
 }
 
-
-
-
-
 static int n_phoneme_tabs;
 static int n_phcodes;
 
 static FILE *f_prog_log = NULL;
 static FILE *f_report;
 
-
 static FILE *f_in;
 static int f_in_linenum;
 static int f_in_displ;
 
-
 static int linenum;
 static int count_references = 0;
 static int duplicate_references = 0;
 
 static REF_HASH_TAB *ref_hash_tab[256];
 
-
 #define N_ENVELOPES  30
 int n_envelopes = 0;
 char envelope_paths[N_ENVELOPES][80];
 unsigned char envelope_dat[N_ENVELOPES][ENV_LEN];
 
-
 typedef struct {
 	FILE *file;
 	int linenum;
 } IF_STACK;
 IF_STACK if_stack[N_IF_STACK];
 
-
 enum {
 	tENDFILE = 1,
 	tSTRING,
 #define N_ITEM_STRING 256
 char item_string[N_ITEM_STRING];
 
-
-
 static int ref_sorter(char **a, char **b)
 {
 	int ix;
 	return p1->ph_mnemonic - p2->ph_mnemonic;
 }
 
-
-
 static void CompileReport(void)
 {
 	int ix;
 	fclose(f_report);
 }
 
-
 static void error(const char *format, const char *string)
 {
 	if (string == NULL)
 	return f;
 }
 
-
 static unsigned int StringToWord(const char *string)
 {
 // Pack 4 characters into a word
 	return word;
 }
 
-
 static MNEM_TAB reserved_phonemes[] = {
 	{ "_\001",  phonCONTROL },      // NOT USED
 	{ "%",  phonSTRESS_U },
 	{ NULL, 0 }
 };
 
-
 static void ReservePhCodes()
 {
 // Reserve phoneme codes which have fixed numbers so that they can be
 	}
 }
 
-
 static int LookupPhoneme(const char *string, int control)
 {
 // control = 0   explicit declaration
 	return use;
 }
 
-
-
 static unsigned int get_char()
 {
 	unsigned int c;
 		linenum--;
 }
 
-
 int CheckNextChar()
 {
 	int c;
 	return c;
 }
 
-
 static int NextItem(int type)
 {
 	int acc;
 		return acc * sign;
 	}
 
-
 	if ((type >= tKEYWORD) && (type <= tINTONATION)) {
 		pk = keyword_tabs[type-tKEYWORD];
 		while (pk->mnem != NULL) {
 	return -1;
 }
 
-
-
 static int NextItemMax(int max)
 {
 // Get a number, but restrict value to max
 	return value;
 }
 
-
-
 static int NextItemBrackets(int type, int control)
 {
 // Expect a parameter inside parantheses
 	if (item_terminator != ')')
 		error("Expected ')'", NULL);
 	return value;
-
 }
 
-
 static void UngetItem()
 {
 	fseek(f_in, f_in_displ, SEEK_SET);
 	linenum = f_in_linenum;
 }
 
-
-
-
 static int Range(int value, int divide, int min, int max)
 {
 	if (value < 0)
 	return value - min;
 }
 
-
 int CompileVowelTransition(int which)
 {
 // Compile a vowel transition
 	return 0;
 }
 
-
-
 int LoadSpect(const char *path, int control)
 {
 	SpectSeq *spectseq;
 	return displ;
 }
 
-
-
 static int LoadWavefile(FILE *f, const char *fname)
 {
 	int displ;
 		if (system(command) != 0)
 			failed = 1;
 
-
 		if (failed || (GetFileLength(fname_temp) <= 0)) {
 			if (resample_fails < 2)
 				error("Resample command failed: %s", command);
 			max = sample;
 		else if (sample < -max)
 			max = -sample;
-
 	}
 
 	scale_factor = (max / 127) + 1;
 	return displ | 0x800000;  // set bit 23 to indicate a wave file rather than a spectrum
 }
 
-
-
 static int LoadEnvelope(FILE *f, const char *fname)
 {
 	int displ;
 	return displ;
 }
 
-
-
 /* Generate a hash code from the specified string */
 static int Hash8(const char *string)
 {
 	return (hash+chars) & 0xff;
 }
 
-
-
 static int LoadEnvelope2(FILE *f, const char *fname)
 {
 	int ix, ix2;
 		env[x] = y;
 	}
 
-
 	if (n_envelopes < N_ENVELOPES) {
 		strncpy0(envelope_paths[n_envelopes], fname, sizeof(envelope_paths[0]));
 		memcpy(envelope_dat[n_envelopes], env, ENV_LEN);
 	return addr;
 }
 
-
 static int CompileToneSpec(void)
 {
 	int pitch1 = 0;
 	return 0;
 }
 
-
-
 /*
    Condition
    bits 14,15   1
    =8         data = stress bitmap
    =9         special tests
  */
-
 int CompileIf(int elif)
 {
 	int key;
 	return 0;
 }
 
-
 void FillThen(int add)
 {
 	USHORT *p;
 	then_count = 0;
 }
 
-
 int CompileElse(void)
 {
 	USHORT *ref;
 	return 0;
 }
 
-
 int CompileElif(void)
 {
 	if (if_level < 1) {
 	return 0;
 }
 
-
 int CompileEndif(void)
 {
 	USHORT *p;
 	return 0;
 }
 
-
 static int CompileSwitch(int type)
 {
 // Type 0:  EndSwitch
 	return 0;
 }
 
-
-
 static PHONEME_TAB_LIST *FindPhonemeTable(const char *string)
 {
 	int ix;
 	return NULL;
 }
 
-
-
 static PHONEME_TAB *FindPhoneme(const char *string)
 {
 	PHONEME_TAB_LIST *phtab = NULL;
 	return NULL;
 }
 
-
 static void ImportPhoneme(void)
 {
 	unsigned int ph_mnem;
 	if (phoneme_out->type != phVOWEL) {
 		phoneme_out->end_type = 0;  // voicingswitch, this must be set later to refer to a local phoneme
 	}
-
 }
 
-
 static void CallPhoneme(void)
 {
 	PHONEME_TAB *ph;
 	*prog_out++ = addr;
 }
 
-
 static void DecThenCount()
 {
 	if (then_count > 0)
 	*prog_out++ = instn + phcode;
 }
 
-
 int CompilePhoneme(int compile_phoneme)
 {
 	int endphoneme = 0;
 				error("More than one phoneme type: %s", item_string);
 			phoneme_out->type = keyword;
 			break;
-
 		case tPLACE:
 			if (place_articulation > 0)
 				error("Place of articulation has already been given: %s", item_string);
 			place_articulation = keyword;
 			break;
-
 		case tPHONEME_FLAG:
 			phoneme_flags |= keyword;
 			break;
-
 		case tINSTRN1:
 // instruction group 0, with 8 bit operands which set data in PHONEME_DATA
 			switch (keyword)
 				InstnPlusPhoneme(keyword << 8);
 				DecThenCount();
 				break;
-
 			case i_PAUSE_BEFORE:
 				value = NextItemMax(255);
 				*prog_out++ = (i_PAUSE_BEFORE << 8) + value;
 				DecThenCount();
 				break;
-
 			case i_PAUSE_AFTER:
 				value = NextItemMax(255);
 				*prog_out++ = (i_PAUSE_AFTER << 8) + value;
 				DecThenCount();
 				break;
-
 			case i_SET_LENGTH:
 				value = NextItemMax(511);
 				if (phoneme_out->type == phVOWEL)
 					DecThenCount();
 				}
 				break;
-
 			case i_ADD_LENGTH:
 				value = NextItem(tSIGNEDNUMBER) / 2;
 				*prog_out++ = (i_ADD_LENGTH << 8) + (value & 0xff);
 				DecThenCount();
 				break;
-
 			case i_LENGTH_MOD:
 				value = NextItem(tNUMBER);
 				phoneme_out->length_mod = value;
 				break;
-
 			case i_IPA_NAME:
 				NextItem(tSTRING);
 
 				break;
 			}
 			break;
-
 		case tSTATEMENT:
 			switch (keyword)
 			{
 				ImportPhoneme();
 				phoneme_flags = phoneme_out->phflags;
 				break;
-
 			case kSTARTTYPE:
 				phcode = NextItem(tPHONEMEMNEM);
 				if (phcode == -1)
 					phcode = LookupPhoneme(item_string, 1);
 				phoneme_out->start_type = phcode;
 				break;
-
 			case kENDTYPE:
 				phcode = NextItem(tPHONEMEMNEM);
 				if (phcode == -1)
 				else if (phcode != phoneme_out->start_type)
 					error("endtype must equal starttype for consonants", NULL);
 				break;
-
 			case kVOICINGSWITCH:
 				phcode = NextItem(tPHONEMEMNEM);
 				if (phcode == -1)
 					phcode = LookupPhoneme(item_string, 1);
 				phoneme_out->end_type = phcode;       // use end_type field for consonants as voicing_switch
 				break;
-
 			case kSTRESSTYPE:
 				value = NextItem(tNUMBER);
 				phoneme_out->std_length = value;
 					prog_out = prog_buf;
 				}
 				break;
-
 			case kIF:
 				endphoneme = CompileIf(0);
 				break;
-
 			case kELSE:
 				endphoneme = CompileElse();
 				break;
-
 			case kELIF:
 				endphoneme = CompileElif();
 				break;
-
 			case kENDIF:
 				endphoneme = CompileEndif();
 				break;
-
 			case kENDSWITCH:
 				break;
-
 			case kSWITCH_PREVVOWEL:
 				endphoneme = CompileSwitch(1);
 				break;
-
 			case kSWITCH_NEXTVOWEL:
 				endphoneme = CompileSwitch(2);
 				break;
-
 			case kCALLPH:
 				CallPhoneme();
 				DecThenCount();
 				break;
-
 			case kFMT:
 				if_stack[if_level].returned = 1;
 				DecThenCount();
 				else
 					endphoneme = CompileSound(keyword, 0);
 				break;
-
 			case kWAV:
 				if_stack[if_level].returned = 1;
+				// fallthrough:
 			case kVOWELSTART:
 			case kVOWELENDING:
 			case kANDWAV:
 				DecThenCount();
 				endphoneme = CompileSound(keyword, 0);
 				break;
-
 			case kVOWELIN:
 				DecThenCount();
 				endphoneme = CompileVowelTransition(1);
 				break;
-
 			case kVOWELOUT:
 				DecThenCount();
 				endphoneme = CompileVowelTransition(2);
 				break;
-
 			case kTONESPEC:
 				DecThenCount();
 				endphoneme = CompileToneSpec();
 				break;
-
 			case kCONTINUE:
 				*prog_out++ = i_CONTINUE;
 				DecThenCount();
 				break;
-
 			case kRETURN:
 				*prog_out++ = i_RETURN;
 				DecThenCount();
 				break;
-
 			case kINCLUDE:
 			case kPHONEMENUMBER:
 			case kPHONEMETABLE:
 				error("Missing 'endphoneme' before '%s'", item_string);  // drop through to endphoneme
+				// fallthrough:
 			case kENDPHONEME:
 			case kENDPROCEDURE:
 				endphoneme = 1;
 					*prog_out++ = i_RETURN;
 				break;
 			}
-
 			break;
 		}
 	}
 	return 0;
 }
 
-
-
-
-
 static void WritePhonemeTables()
 {
 	int ix;
 	}
 }
 
-
 static void EndPhonemeTable()
 {
 	int ix;
 	}
 }
 
-
 static void StartPhonemeTable(const char *name)
 {
 	int ix;
 	n_phoneme_tabs++;
 }
 
-
 static void CompileEquivalents()
 {
 	// a list of phonemes in another language and the equivalent phoneme strings in this language
 	p_start[3] = n_bytes;
 }
 
-
-
 static void CompilePhonemeFiles()
 {
 	int item;
 		{
 		case kUTF8_BOM:
 			break;  // ignore bytes 0xef 0xbb 0xbf
-
 		case kINCLUDE:
 			NextItem(tSTRING);
 			sprintf(buf, "%s/../phsource/%s", path_home, item_string);
 				f_in = f;
 				strncpy0(current_fname, item_string, sizeof(current_fname));
 				linenum = 1;
-
 			} else
 				error("Missing file: %s", item_string);
 			break;
-
 		case kPHONEMETABLE:
 			EndPhonemeTable();
 			NextItem(tSTRING);  // name of the new phoneme table
 			StartPhonemeTable(item_string);
 			break;
-
 		case kPHONEMESTART:
 			if (n_phoneme_tabs == 0) {
 				Error("phonemetable is missing");
 			}
 			CompilePhoneme(1);
 			break;
-
 		case kPROCEDURE:
 			CompilePhoneme(0);
 			break;
-
 		case kEQUIVALENTS:
 			CompileEquivalents();
 			break;
-
 		default:
 			if (!feof(f_in))
 				Error("Keyword 'phoneme' expected");
 	phoneme_tab2[n_phcodes+1].mnemonic = 0;  // terminator
 }
 
-
-
 static espeak_ng_STATUS CompilePhonemeData2(const char *source, FILE *log)
 {
 	char fname[sizeof(path_home)+40];
 	        "#  Address  Data file\n"
 	        "#  -------  ---------\n");
 
-
 	fprintf(f_errors, "Source data path = '%s/../phsource'\n", path_home);
 	fprintf(f_errors, "Master phonemes file = '%s/../phsource/phonemes'\n", path_home);
 	fprintf(f_errors, "Output to '%s/'\n\n", path_home);
 	return ENS_OK;
 }
 
-
 static const char *preset_tune_names[] = {
 	"s1", "c1", "q1", "e1", NULL
 };
 	return LookupMnem(envelope_names, name);
 }
 
-
 #pragma GCC visibility push(default)
 
 espeak_ng_STATUS espeak_ng_CompileIntonation(FILE *log)
 	TUNE *tune_data;
 	TUNE new_tune;
 
-
 	char name[12];
 	char tune_names[N_TUNE_NAMES][12];
 	char buf[sizeof(path_home)+150];
 		}
 	}
 
-
 	for (ix = 0; preset_tune_names[ix] != NULL; ix++) {
 		strcpy(tune_names[ix], preset_tune_names[ix]);
 	}
 			if (found == 0)
 				error("Bad tune name: '%s;", new_tune.name);
 			break;
-
 		case kENDTUNE:
 			compiling_tune = 0;
 
 			}
 			memcpy(&tune_data[tune_number], &new_tune, sizeof(TUNE));
 			break;
-
 		case kTUNE_PREHEAD:
 			new_tune.prehead_start = NextItem(tNUMBER);
 			new_tune.prehead_end = NextItem(tNUMBER);
 			break;
-
 		case kTUNE_ONSET:
 			new_tune.onset = NextItem(tNUMBER);
 			new_tune.unstr_start[0] = NextItem(tSIGNEDNUMBER);
 			new_tune.unstr_end[0] = NextItem(tSIGNEDNUMBER);
 			done_onset = 1;
 			break;
-
 		case kTUNE_HEADLAST:
 			new_tune.head_last = NextItem(tNUMBER);
 			new_tune.unstr_start[2] = NextItem(tSIGNEDNUMBER);
 			new_tune.unstr_end[2] = NextItem(tSIGNEDNUMBER);
 			done_last = 1;
 			break;
-
 		case kTUNE_HEADENV:
 			NextItem(tSTRING);
 			if ((ix = LookupEnvelopeName(item_string)) < 0)
 				new_tune.stressed_env = ix;
 			new_tune.stressed_drop = NextItem(tNUMBER);
 			break;
-
 		case kTUNE_HEAD:
 			new_tune.head_max_steps = NextItem(tNUMBER);
 			new_tune.head_start = NextItem(tNUMBER);
 			new_tune.unstr_start[1] = NextItem(tSIGNEDNUMBER);
 			new_tune.unstr_end[1] = NextItem(tSIGNEDNUMBER);
 			break;
-
 		case kTUNE_HEADEXTEND:
 			// up to 8 numbers
 			for (ix = 0; ix < (int)(sizeof(new_tune.head_extend)); ix++) {
 			}
 			new_tune.n_head_extend = ix;    // number of values
 			break;
-
 		case kTUNE_NUCLEUS0:
 			NextItem(tSTRING);
 			if ((ix = LookupEnvelopeName(item_string)) < 0) {
 			new_tune.nucleus0_max = NextItem(tNUMBER);
 			new_tune.nucleus0_min = NextItem(tNUMBER);
 			break;
-
 		case kTUNE_NUCLEUS1:
 			NextItem(tSTRING);
 			if ((ix = LookupEnvelopeName(item_string)) < 0) {
 				new_tune.split_tail_end = new_tune.tail_end;
 			}
 			break;
-
 		case kTUNE_SPLIT:
 			NextItem(tSTRING);
 			if ((ix = LookupEnvelopeName(item_string)) < 0) {
 			else
 				new_tune.split_tune = ix;
 			break;
-
 		default:
 			error("Unexpected: '%s'", item_string);
 			break;
 	return error_count > 0 ? ENE_COMPILE_ERRORS : ENS_OK;
 }
 
-
-
 espeak_ng_STATUS espeak_ng_CompilePhonemeData(long rate, FILE *log)
 {
 	if (!log) log = stderr;

src/libespeak-ng/compiledict.c

 	{ "$u2+", 0x4e },
 	{ "$u3+", 0x4f },
 
-
 	// these set the corresponding numbered bit if dictionary_flags
 	{ "$pause",     8 },    // ensure pause before this word
 	{ "$strend",    9 },   // full stress if at end of clause
 	{ NULL,   -1 }
 };
 
-
 #define LEN_GROUP_NAME  12
 
 typedef struct {
 	int group3_ix;
 } RGROUP;
 
-
 int isspace2(unsigned int c)
 {
 // can't use isspace() because on Windows, isspace(0xe1) gives TRUE !
 	return 1;
 }
 
-
-
 static FILE *fopen_log(const char *fname, const char *access)
 {
 // performs fopen, but produces error message to f_log if it fails
 	return f;
 }
 
-
 /* Lookup a mnemonic string in a table, return its name */
 const char *LookupMnemName(MNEM_TAB *table, const int value)
 {
 	return "";   /* not found */
 }
 
-
 void print_dictionary_flags(unsigned int *flags, char *buf, int buf_len)
 {
 	int stress;
 	}
 }
 
-
-
-
 char *DecodeRule(const char *group_chars, int group_length, char *rule, int control)
 {
 	/* Convert compiled match template to ascii */
 	return output;
 }
 
-
-
-
 static int compile_line(char *linebuf, char *dict_line, int *hash)
 {
 // Compile a line in the language_list file
 				step = 1;
 			}
 			break;
-
 		case 1:
 			if ((c == '-') && multiple_words) {
 				if (IsDigit09(word[0]))
 				}
 			}
 			break;
-
 		case 2:
 			if (isspace2(c))
 				multiple_words++;
 				step = 3;
 			}
 			break;
-
 		case 3:
 			if (!isspace2(c)) {
 				phonetic = p;
 				step = 4;
 			}
 			break;
-
 		case 4:
 			if (isspace2(c)) {
 				p[0] = 0;   /* terminate phonetic */
 				step = 5;
 			}
 			break;
-
 		case 5:
 			break;
 		}
 	}
 	dict_line[0] = length;
 
-
 	return length;
 }
 
-
-
 static void compile_dictlist_start(void)
 {
 // initialise dictionary list
 	}
 }
 
-
 static void compile_dictlist_end(FILE *f_out)
 {
 // Write out the compiled dictionary list
 	}
 }
 
-
-
 static int compile_dictlist_file(const char *path, const char *filename)
 {
 	int length;
 	return 0;
 }
 
-
-
 static char rule_cond[80];
 static char rule_pre[80];
 static char rule_post[80];
 
 #define N_RULES 3000        // max rules for each group
 
-
-
 int isHexDigit(int c)
 {
 	if ((c >= '0') && (c <= '9'))
 	return -1;
 }
 
-
 static void copy_rule_string(char *string, int *state_out)
 {
 // state 0: conditional, 1=pre, 2=match, 3=post, 4=phonemes
 					} else
 						output[ix++] = RULE_LETTERGP2;
 					break;
-
 				case '$':
 					value = 0;
 					mr = mnem_rules;
 						error_count++;
 					}
 					break;
-
 				case 'P':
 					sxflags |= SUFX_P;   // Prefix, now drop through to Suffix
+					// fallthrough
 				case 'S':
 					output[ix++] = RULE_ENDING;
 					value = 0;
 	*state_out = next_state[state];
 }
 
-
-
 static char *compile_rule(char *input)
 {
 	int 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;
 			else
 				*p++ = c;
 			break;
-
 		default:
 			*p++ = c;
 			break;
 	return prule;
 }
 
-
 int __cdecl string_sorter(char **a, char **b)
 {
 	char *pa, *pb;
 	return strcmp(pa, pb);
 }
 
-
 static int __cdecl rgroup_sorter(RGROUP *a, RGROUP *b)
 {
 // Sort long names before short names
 	return a->start-b->start;
 }
 
-
 #ifdef OUTPUT_FORMAT
 static void print_rule_group(FILE *f_out, int n_rules, char **rules, char *name)
 {
 }
 #endif
 
-
 static void output_rule_group(FILE *f_out, int n_rules, char **rules, char *name)
 {
 	int ix;
 #endif
 }
 
-
-
 static int compile_lettergroup(char *input, FILE *f_out)
 {
 	char *p;
 	return 0;
 }
 
-
 static int compile_dictrules(FILE *f_in, FILE *f_out, char *fname_temp)
 {
 	char *prule;
 
 			}
 			break;
-
 		case 2:   //  .replace
 		{
 			int replace1;
 	return 0;
 }
 
-
-
 int CompileDictionary(const char *dsource, const char *dict_name, FILE *log, char *fname_err, int flags)
 {
 // fname:  space to write the filename in case of error

src/libespeak-ng/dictionary.c

 #include "synthesize.h"
 #include "translate.h"
 
-
 int dictionary_skipwords;
 char dictionary_name[40];
 
 	'a', 'a', 'a', 'b', 'o', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'e', 'e'
 };
 
-
-
-
-
 #pragma GCC visibility push(default)
 void strncpy0(char *to, const char *from, int size)
 {
 }
 #pragma GCC visibility pop
 
-
 int Reverse4Bytes(int word)
 {
 // reverse the order of bytes from little-endian to big-endian
 #endif
 }
 
-
 int LookupMnem(MNEM_TAB *table, const char *string)
 {
 	while (table->mnem != NULL) {
 	return table->value;
 }
 
-
 static void InitGroups(Translator *tr)
 {
 // Called after dictionary 1 is loaded, to set up table of entry points for translation rule chains
 //	for single-letters and two-letter combinations
 
-
 	int ix;
 	char *p;
 	char *p_name;
 			p += (strlen(p) + 1);
 		p++;
 	}
-
 }
 
-
-
 int LoadDictionary(Translator *tr, const char *name, int no_error)
 {
 	int hash;
 	size = fread(tr->data_dictlist, 1, size, f);
 	fclose(f);
 
-
 	pw = (int *)(tr->data_dictlist);
 	length = Reverse4Bytes(pw[1]);
 
 	return 0;
 }
 
-
 /* Generate a hash code from the specified string
     This is used to access the dictionary_2 word-lookup dictionary
  */
 	return (hash+chars) & 0x3ff;  // a 10 bit hash code
 }
 
-
-
 /* Translate a phoneme string from ascii mnemonics to internal phoneme numbers,
    from 'p' up to next blank .
    Returns advanced 'p'
 				p++;
 				break;
 			}
-
 		default:
 			// lookup the phoneme mnemonic, find the phoneme with the highest number of
 			// matching characters
 	return p;
 }
 
-
-
 void DecodePhonemes(const char *inptr, char *outptr)
 {
 // Translate from internal phoneme codes into phoneme mnemonics
 	*outptr = 0;    /* string terminator */
 }
 
-
 // using Kirschenbaum to IPA translation, ascii 0x20 to 0x7f
 unsigned short ipa1[96] = {
 	0x20, 0x21, 0x22, 0x2b0, 0x24, 0x25, 0x0e6, 0x2c8, 0x28, 0x29, 0x27e, 0x2b, 0x2cc, 0x2d, 0x2e, 0x2f,
 static char *phon_out_buf = NULL;   // passes the result of GetTranslatedPhonemeString()
 static unsigned int phon_out_size = 0;
 
-
 char *WritePhMnemonic(char *phon_out, PHONEME_TAB *ph, PHONEME_LIST *plist, int use_ipa, int *flags)
 {
 	int c;
 	return phon_out;
 }
 
-
-
 const char *GetTranslatedPhonemeString(int phoneme_mode)
 {
 	/* Called after a clause has been translated into phonemes, in order
 		use_tie = 0;
 	}
 
-
 	for (ix = 1; ix < (n_phoneme_list-2); ix++) {
 		buf = phon_buf;
 
 	return phon_out_buf;
 }
 
-
-
 static int IsLetterGroup(Translator *tr, char *word, int group, int pre)
 {
 // match the word against a list of utf-8 strings
 	return 0;
 }
 
-
 static int IsLetter(Translator *tr, int letter, int group)
 {
 	int letter2;
 	return 0;
 }
 
-
 int IsVowel(Translator *tr, int letter)
 {
 	return IsLetter(tr, letter, LETTERGP_VOWEL2);
 }
 
-
-
-
 static int Unpronouncable2(Translator *tr, char *word)
 {
 	int c;
 	return 0;
 }
 
-
 int Unpronouncable(Translator *tr, char *word, int posn)
 {
 	/* Determines whether a word in 'unpronouncable', i.e. whether it should
 		return 1;  // no vowel, or no vowel in first few letters
 
 	return 0;
-
 }
 
-
-
 static int GetVowelStress(Translator *tr, unsigned char *phonemes, signed char *vowel_stress, int *vowel_count, int *stressed_syllable, int control)
 {
 // control = 1, set stress to 1 for forced unstressed vowels
 	return max_stress;
 }
 
-
-
 static char stress_phonemes[] = { phonSTRESS_D, phonSTRESS_U, phonSTRESS_2, phonSTRESS_3,
 	                              phonSTRESS_P, phonSTRESS_P2, phonSTRESS_TONIC };
 
-
 void ChangeWordStress(Translator *tr, char *word, int new_stress)
 {
 	int ix;
 	*word = 0;
 }
 
-
-
 void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, int tonic, int control)
 {
 /* Guess stress pattern of word.  This is language specific
 
 	static char consonant_types[16] = { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 };
 
-
 	/* stress numbers  STRESS_BASE +
 	    0  diminished, unstressed within a word
 	    1  unstressed, weak
 		}
 	}
 
-
 	switch (tr->langopts.stress_rule)
 	{
 	case 8:
 		// stress on first syllable, unless it is a light syllable followed by a heavy syllable
 		if ((syllable_weight[1] > 0) || (syllable_weight[2] == 0))
 			break;
-	// else drop through to case 1
+		// fallthrough
 	case 1:
 		// stress on second syllable
 		if ((stressed_syllable == 0) && (vowel_count > 2)) {
 			max_stress = 4;
 		}
 		break;
-
 	case 10:  // penultimate, but final if only 1 or 2 syllables
 		if (stressed_syllable == 0) {
 			if (vowel_count < 4) {
 				break;
 			}
 		}
-	// drop through to next case
+		// fallthrough
 	case 2:
 		// a language with stress on penultimate vowel
 
 			}
 		}
 		break;
-
 	case 3:
 		// stress on last vowel
 		if (stressed_syllable == 0) {
 			max_stress = 4;
 		}
 		break;
-
 	case 4:   // stress on antipenultimate vowel
 		if (stressed_syllable == 0) {
 			stressed_syllable = vowel_count - 3;
 			max_stress = 4;
 		}
 		break;
-
 	case 5:
 		// LANG=Russian
 		if (stressed_syllable == 0) {
 			max_stress = 4;
 		}
 		break;
-
 	case 6:    // LANG=hi stress on the last heaviest syllable
 		if (stressed_syllable == 0) {
 			int wt;
 			max_stress = 4;
 		}
 		break;
-
 	case 7:  // LANG=tr, the last syllable for any vowel marked explicitly as unstressed
 		if (stressed_syllable == 0) {
 			stressed_syllable = vowel_count - 1;
 			max_stress = 4;
 		}
 		break;
-
 	case 9:  // mark all as stressed
 		for (ix = 1; ix < vowel_count; ix++) {
 			if (vowel_stress[ix] < 0)
 				vowel_stress[ix] = 4;
 		}
 		break;
-
 	case 12:  // LANG=kl (Greenlandic)
 		long_vowel = 0;
 		for (ix = 1; ix < vowel_count; ix++) {
 		vowel_stress[stressed_syllable] = 4;
 		max_stress = 4;
 		break;
-
 	case 13:  // LANG=ml, 1st unless 1st vowel is short and 2nd is long
 		if (stressed_syllable == 0) {
 			stressed_syllable = 1;
 	else
 		stress = 3;
 
-
 	if (unstressed_word == 0) {
 		if ((stressflags & S_2_SYL_2) && (vowel_count == 3)) {
 			// Two syllable word, if one syllable has primary stress, then give the other secondary stress
 		max_stress = tonic;
 	}
 
-
 	/* produce output phoneme string */
 	p = phonetic;
 	v = 1;
 
 	if (!(control & 1) && ((ph = phoneme_tab[*p]) != NULL)) {
-
 		while ((ph->type == phSTRESS) || (*p == phonEND_WORD)) {
 			p++;
 			ph = phoneme_tab[p[0]];
 	return;
 }
 
-
-
 void AppendPhonemes(Translator *tr, char *string, int size, const char *ph)
 {
 /* Add new phoneme string "ph" to "string"
 		strcat(string, ph);
 }
 
-
-
 static void MatchRule(Translator *tr, char *word[], char *word_start, int group_length, char *rule, MatchRecord *match_out, int word_flags, int dict_flags)
 {
 /* Checks a specified word against dictionary rules.
 		return;
 	}
 
-
 	total_consumed = 0;
 	common_phonemes = NULL;
 	match_type = 0;
 					rule--;      // so we are still pointing at the 0
 					failed = 2;    // matched OK
 					break;
-
 				case RULE_PRE_ATSTART:   // pre rule with implied 'start of word'
 					check_atstart = 1;
 					unpron_ignore = 0;
 					match_type = RULE_PRE;
 					break;
-
 				case RULE_PRE:
 					match_type = RULE_PRE;
 					if (word_flags & FLAG_UNPRON_TEST) {
 						failed = 1;
 					}
 					break;
-
 				case RULE_POST:
 					match_type = RULE_POST;
 					break;
 				} else
 					failed = 1;
 				break;
-
-
 			case RULE_POST:
 				/* continue moving fowards */
 				distance_right += 6;
 					} else
 						failed = 1;
 					break;
-
 				case RULE_LETTERGP2:   // match against a list of utf-8 strings
 					letter_group = *rule++ - 'A';
 					if ((n_bytes = IsLetterGroup(tr, post_ptr-1, letter_group, 0)) > 0) {
 					} else
 						failed = 1;
 					break;
-
 				case RULE_NOTVOWEL:
 					if (IsLetter(tr, letter_w, 0) || ((letter_w == ' ') && (word_flags & FLAG_SUFFIX_VOWEL)))
 						failed = 1;
 						post_ptr += letter_xbytes;
 					}
 					break;
-
 				case RULE_DIGIT:
 					if (IsDigit(letter_w)) {
 						add_points = (20-distance_right);
 					} else
 						failed = 1;
 					break;
-
 				case RULE_NONALPHA:
 					if (!iswalpha2(letter_w)) {
 						add_points = (21-distance_right);
 					} else
 						failed = 1;
 					break;
-
 				case RULE_DOUBLE:
 					if (letter == last_letter)
 						add_points = (21-distance_right);
 					else
 						failed = 1;
 					break;
-
 				case RULE_DOLLAR:
 					command = *rule++;
 					if (command == DOLLAR_UNPR)
 							failed = 1;
 					}
 					break;
-
 				case '-':
 					if ((letter == '-') || ((letter == ' ') && (word_flags & FLAG_HYPHEN_AFTER)))
 						add_points = (22-distance_right);    // one point more than match against space
 					else
 						failed = 1;
 					break;
-
 				case RULE_SYLLABLE:
 				{
 					/* more than specified number of vowel letters to the right */
 					else
 						failed = 1;
 				}
-				break;
-
+					break;
 				case RULE_NOVOWELS:
 				{
 					char *p = post_ptr + letter_xbytes;
 					if (!failed)
 						add_points = (19-distance_right);
 				}
-				break;
-
+					break;
 				case RULE_SKIPCHARS:
 				{
 					// Used for lang=Tamil, used to match on the next word after an unknown word ending
 					if (letter_w == rule_w)
 						post_ptr = p2;
 				}
-				break;
-
+					break;
 				case RULE_INC_SCORE:
 					add_points = 20;      // force an increase in points
 					break;
-
 				case RULE_DEL_FWD:
 					// find the next 'e' in the word and replace by 'E'
 					for (p = *word + group_length; p < post_ptr; p++) {
 						}
 					}
 					break;
-
 				case RULE_ENDING:
 				{
 					int end_type;
 						rule += 3;
 					}
 				}
-				break;
-
+					break;
 				case RULE_NO_SUFFIX:
 					if (word_flags & FLAG_SUFFIX_REMOVED)
 						failed = 1;             // a suffix has been removed
 					else
 						add_points = 1;
 					break;
-
 				default:
 					if (letter == rb) {
 						if ((letter & 0xc0) != 0x80) {
 					break;
 				}
 				break;
-
-
 			case RULE_PRE:
 				/* match backwards from start of current group */
 				distance_left += 2;
 					} else
 						failed = 1;
 					break;
-
 				case RULE_LETTERGP2:   // match against a list of utf-8 strings
 					letter_group = *rule++ - 'A';
 					if ((n_bytes = IsLetterGroup(tr, pre_ptr, letter_group, 1)) > 0) {
 					} else
 						failed = 1;
 					break;
-
 				case RULE_NOTVOWEL:
 					if (!IsLetter(tr, letter_w, 0)) {
 						add_points = (20-distance_left);
 					} else
 						failed = 1;
 					break;
-
 				case RULE_DOUBLE:
 					if (letter == last_letter)
 						add_points = (21-distance_left);
 					else
 						failed = 1;
 					break;
-
 				case RULE_DIGIT:
 					if (IsDigit(letter_w)) {
 						add_points = (21-distance_left);
 					} else
 						failed = 1;
 					break;
-
 				case RULE_NONALPHA:
 					if (!iswalpha2(letter_w)) {
 						add_points = (21-distance_right);
 					} else
 						failed = 1;
 					break;
-
 				case RULE_DOLLAR:
 					command = *rule++;
 					if ((command == DOLLAR_LIST) || ((command & 0xf0) == 0x20)) {
 							failed = 1;
 					}
 					break;
-
 				case RULE_SYLLABLE:
 					/* more than specified number of vowels to the left */
 					syllable_count = 1;
 					else
 						failed = 1;
 					break;
-
 				case RULE_STRESSED:
 					if (tr->word_stressed_count > 0)
 						add_points = 19;
 					else
 						failed = 1;
 					break;
-
 				case RULE_NOVOWELS:
 				{
 					char *p = pre_ptr - letter_xbytes - 1;
 					if (!failed)
 						add_points = 3;
 				}
-				break;
-
+					break;
 				case RULE_IFVERB:
 					if (tr->expect_verb)
 						add_points = 1;
 					else
 						failed = 1;
 					break;
-
 				case RULE_CAPITAL:
 					if (word_flags & FLAG_FIRST_UPPER)
 						add_points = 1;
 					else
 						failed = 1;
 					break;
-
 				case '.':
 					// dot in pre- section, match on any dot before this point in the word
 					for (p = pre_ptr; *p != ' '; p--) {
 					if (*p == ' ')
 						failed = 1;
 					break;
-
 				case '-':
 					if ((letter == '-') || ((letter == ' ') && (word_flags & FLAG_HYPHEN)))
 						add_points = (22-distance_right);       // one point more than match against space
 					else
 						failed = 1;
 					break;
-
 				default:
 					if (letter == rb) {
 						if (letter == RULE_SPACE)
 	memcpy(match_out, &best, sizeof(MatchRecord));
 }
 
-
-
-
 int TranslateRules(Translator *tr, char *p_start, char *phonemes, int ph_size, char *end_phonemes, int word_flags, unsigned int *dict_flags)
 {
 	/* Translate a word bounded by space characters
 	}
 	word_copy[ix] = 0;
 
-
 	if ((option_phonemes & espeakPHONEMES_TRACE) && ((word_flags & FLAG_NO_TRACE) == 0)) {
 		char wordbuf[120];
 		unsigned int ix;
 	return 0;
 }
 
-
 void ApplySpecialAttribute2(Translator *tr, char *phonemes, int dict_flags)
 {
 // apply after the translation is complete
 	}
 }
 
-
-
 int TransposeAlphabet(Translator *tr, char *text)
 {
 // transpose cyrillic alphabet (for example) into ascii (single byte) character codes
 	int bufix;
 	char buf[N_WORD_BYTES+1];
 
-
 	offset = tr->transpose_min - 1;
 	min = tr->transpose_min;
 	max = tr->transpose_max;
 	return strlen(text);
 }
 
-
-
-
 /* Find an entry in the word_dict file for a specified word.
    Returns NULL if no match, else returns 'word_end'
 
 	return 0;
 }
 
-
-
 /* Lookup a specified word in the word dictionary.
    Returns phonetic data in 'phonetic' and bits in 'flags'
 
 
 	found = LookupDict2(tr, word, word1, ph_out, flags, end_flags, wtab);
 
-
 	if (flags[0] & FLAG_MAX3) {
 		if (strcmp(ph_out, tr->phonemes_repeat) == 0) {
 			tr->phonemes_repeat_count++;
 	} else
 		tr->phonemes_repeat_count = 0;
 
-
 	if ((found == 0) && (flags[1] & FLAG_ACCENT)) {
 		int letter;
 		word2 = word;
 	return 0;
 }
 
-
 extern char word_phonemes[N_WORD_PHONEMES];    // a word translated into phoneme codes
 
 int Lookup(Translator *tr, const char *word, char *ph_out)
 	return flags0;
 }
 
-
 int LookupFlags(Translator *tr, const char *word, unsigned int **flags_out)
 {
 	char buf[100];
 	return flags[0];
 }
 
-
-
 int RemoveEnding(Translator *tr, char *word, int end_type, char *word_copy)
 {
 /* Removes a standard suffix from a word, once it has been indicated by the dictionary rules.

src/libespeak-ng/espeak_command.c

 				free(the_command->u.my_text.text);
 			}
 			break;
-
 		case ET_MARK:
 			if (the_command->u.my_mark.text)
 				free(the_command->u.my_mark.text);
 			if (the_command->u.my_mark.index_mark)
 				free((void *)(the_command->u.my_mark.index_mark));
 			break;
-
 		case ET_TERMINATED_MSG:
 		{
 			// if the terminated msg is pending,
 				sync_espeak_terminated_msg(data->unique_identifier, data->user_data);
 			}
 		}
-		break;
-
+			break;
 		case ET_KEY:
 			if (the_command->u.my_key.key_name)
 				free((void *)(the_command->u.my_key.key_name));
 			break;
-
 		case ET_CHAR:
 		case ET_PARAMETER:
 			// No allocation
 			break;
-
 		case ET_PUNCTUATION_LIST:
 			if (the_command->u.my_punctuation_list)
 				free((void *)(the_command->u.my_punctuation_list));
 			break;
-
 		case ET_VOICE_NAME:
 			if (the_command->u.my_voice_name)
 				free((void *)(the_command->u.my_voice_name));
 			break;
-
 		case ET_VOICE_SPEC:
 		{
 			espeak_VOICE *data = &(the_command->u.my_voice_spec);
 			if (data->identifier)
 				free((void *)data->identifier);
 		}
-		break;
-
+			break;
 		default:
 			assert(0);
 		}
 		                  data->position, data->position_type,
 		                  data->end_position, data->flags, data->user_data);
 	}
-	break;
-
+		break;
 	case ET_MARK:
 	{
 		t_espeak_mark *data = &(the_command->u.my_mark);
 		                       data->index_mark, data->end_position, data->flags,
 		                       data->user_data);
 	}
-	break;
-
+		break;
 	case ET_TERMINATED_MSG:
 	{
 		t_espeak_terminated_msg *data = &(the_command->u.my_terminated_msg);
 		sync_espeak_terminated_msg(data->unique_identifier, data->user_data);
 	}
-	break;
-
+		break;
 	case ET_KEY:
 	{
 		const char *data = the_command->u.my_key.key_name;
 		sync_espeak_Key(data);
 	}
-	break;
-
+		break;
 	case ET_CHAR:
 	{
 		const wchar_t data = the_command->u.my_char.character;
 		sync_espeak_Char(data);
 	}
-	break;
-
+		break;
 	case ET_PARAMETER:
 	{
 		t_espeak_parameter *data = &(the_command->u.my_param);
 		SetParameter(data->parameter, data->value, data->relative);
 	}
-	break;
-
+		break;
 	case ET_PUNCTUATION_LIST:
 	{
 		const wchar_t *data = the_command->u.my_punctuation_list;
 		sync_espeak_SetPunctuationList(data);
 	}
-	break;
-
+		break;
 	case ET_VOICE_NAME:
 	{
 		const char *data = the_command->u.my_voice_name;
 		SetVoiceByName(data);
 	}
-	break;
-
+		break;
 	case ET_VOICE_SPEC:
 	{
 		espeak_VOICE *data = &(the_command->u.my_voice_spec);
 		SetVoiceByProperties(data);
 	}
-	break;
-
+		break;
 	default:
 		assert(0);
 		break;
 		t_espeak_text *data = &(the_command->u.my_text);
 		SHOW("display_espeak_command > (0x%x) uid=%d, TEXT=%s, user_data=0x%x\n", the_command, data->unique_identifier, (char *)data->text, (int)(data->user_data));
 	}
-	break;
-
+		break;
 	case ET_MARK:
 	{
 		t_espeak_mark *data = &(the_command->u.my_mark);
 		SHOW("display_espeak_command > (0x%x) uid=%d, MARK=%s, user_data=0x%x\n", the_command, data->unique_identifier, (char *)data->text, (int)(data->user_data));
 	}
-	break;
-
+		break;
 	case ET_KEY:
 	{
 		const char *data = the_command->u.my_key.key_name;
 		SHOW("display_espeak_command > (0x%x) KEY=%c\n", the_command, data);
 	}
-	break;
-
+		break;
 	case ET_TERMINATED_MSG:
 	{
 		t_espeak_terminated_msg *data = &(the_command->u.my_terminated_msg);
 		     the_command, data->unique_identifier, data->user_data,
 		     the_command->state);
 	}
-	break;
-
+		break;
 	case ET_CHAR:
 	{
 		const wchar_t data = the_command->u.my_char.character;
 		SHOW("display_espeak_command > (0x%x) CHAR=%c\n", the_command, (char)data);
 	}
-	break;
-
+		break;
 	case ET_PARAMETER:
 	{
 		t_espeak_parameter *data = &(the_command->u.my_param);
 		SHOW("display_espeak_command > (0x%x) PARAMETER=%d, value=%d, relative=%d\n",
 		     the_command, data->parameter, data->value, data->relative);
 	}
-	break;
-
+		break;
 	case ET_PUNCTUATION_LIST:
 	{
 		const wchar_t *data = the_command->u.my_punctuation_list;
 		sync_espeak_SetPunctuationList(data);
 		SHOW("display_espeak_command > (0x%x) PUNCTLIST=%s\n", the_command, (char *)data);
 	}
-	break;
-
+		break;
 	case ET_VOICE_NAME:
 	{
 		const char *data = the_command->u.my_voice_name;
 		SHOW("display_espeak_command > (0x%x) VOICE_NAME=%s\n", the_command, data);
 	}
-	break;
-
+		break;
 	case ET_VOICE_SPEC:
 	{
 		SHOW("display_espeak_command > (0x%x) VOICE_SPEC", the_command);
 	}
-	break;
-
+		break;
 	default:
 		assert(0);
 		break;

src/libespeak-ng/event.c

 	   ACTIVITY_TIMEOUT = 50, // in ms, check that the stream is active
 	   MAX_ACTIVITY_CHECK = 6 };
 
-
 typedef struct t_node {
 	void *data;
 	struct t_node *next;
 			my_callback(NULL, 0, events);
 			a_old_uid = event->unique_identifier;
 			break;
-
 		case espeakEVENT_MSG_TERMINATED:
 		case espeakEVENT_MARK:
 		case espeakEVENT_WORD:
 			my_callback(NULL, 0, events);
 			a_old_uid = event->unique_identifier;
 		}
-		break;
-
-		default:
+			break;
 		case espeakEVENT_LIST_TERMINATED:
 		case espeakEVENT_PLAY:
+		default:
 			break;
 		}
 	}
 	case espeakEVENT_MSG_TERMINATED:
 		event_notify(event);
 		break;
-
 	case espeakEVENT_MARK:
 	case espeakEVENT_PLAY:
 		if (event->id.name)
 			free((void *)(event->id.name));
 		break;
-
 	default:
 		break;
 	}

src/libespeak-ng/fifo.c

 #include "wave.h"
 #include "debug.h"
 
-
 // my_mutex: protects my_thread_is_talking,
 // my_stop_is_required, and the command fifo
 static pthread_mutex_t my_mutex;

src/libespeak-ng/intonation.c

 #include "voice.h"
 #include "translate.h"
 
-
 /* Note this module is mostly old code that needs to be rewritten to
    provide a more flexible intonation system.
  */
 
 static SYLLABLE *syllable_tab;
 
-
 static int tone_pitch_env;    /* used to return pitch envelope */
 
-
-
 /* Pitch data for tone types */
 /*****************************/
 
-
 #define    PITCHfall   0
 #define    PITCHrise   2
 #define    PITCHfrise  4   // and 3 must be for the variant preceded by 'r'
 	0x50, 0x5a, 0x64, 0x70, 0x7c, 0x83, 0x85, 0x88, 0x8a, 0x8c, 0x8e, 0x8f, 0x91, 0x92, 0x93, 0x93
 };
 
-
-
-
 unsigned char *envelope_data[N_ENVELOPE_DATA] = {
 	env_fall,  env_fall,
 	env_rise,  env_rise,
 	env_risefallrise, env_risefallrise
 };
 
-
-
 /* indexed by stress */
 static int min_drop[] =  { 6, 7, 9, 9, 20, 20, 20, 25 };
 
 static signed char oflow_emf[] = { 10, 52, 32, 20, 10 };
 static signed char oflow_less[] = { 6, 38, 24, 14, 4 };
 
-
 #define N_TONE_HEAD_TABLE  13
 #define N_TONE_NUCLEUS_TABLE  13
 
-
 typedef struct {
 	unsigned char pre_start;
 	unsigned char pre_end;
 	signed char *overflow;
 } TONE_HEAD;
 
-
 typedef struct {
 	unsigned char pitch_env0;     /* pitch envelope, tonic syllable at end */
 	unsigned char tonic_max0;
 	{ PITCHfall,   70, 18,  PITCHfall,   70, 24, NULL, 32, 20, 0 },    // 12 test
 };
 
-
-
 /* index by 0=. 1=, 2=?, 3=! 4=none, 5=emphasized */
 unsigned char punctuation_to_tone[INTONATION_TYPES][PUNCT_INTONATIONS] = {
 	{ 0, 1, 2, 3, 0, 4 },
 	{ 12, 12, 12, 12, 0, 0 }
 };
 
-
 int n_tunes = 0;
 TUNE *tunes = NULL;
 
-
 #define SECONDARY  3
 #define PRIMARY    4
 #define PRIMARY_STRESSED 6
 #define PRIMARY_LAST 7
 
-
 static int number_pre;
 static int number_body;
 static int number_tail;
 static int tone_posn2;
 static int no_tonic;
 
-
 static void count_pitch_vowels(int start, int end, int clause_end)
 {
 	int ix;
 
 			last_primary = ix;
 		}
-
 	}
 
 	if (number_pre < 0)
 	}
 }
 
-
-
-
 /* Count number of primary stresses up to tonic syllable or body_reset */
 static int count_increments(int ix, int end_ix, int min_stress)
 {
 	return count;
 }
 
-
-
-
 // Set the pitch of a vowel in syllable_tab
 static void set_pitch(SYLLABLE *syl, int base, int drop)
 {
 	syl->flags |= flags;
 }
 
-
 static int CountUnstressed(int start, int end, int limit)
 {
 	int ix;
 					increment = pitch_range / (n_steps -1);
 				else
 					increment = 0;
-
 			} else if (syl_ix == head_final) {
 				// a pitch has been specified for the last primary stress before the nucleus
 				pitch = tune->head_last << 8;
 		syl_ix++;
 	}
 	return syl_ix;
-
 }
 
-
-
 /* Calculate pitches until next RESET or tonic syllable, or end.
     Increment pitch if stress is >= min_stress.
     Used for tonic segment */
 	return ix;
 }
 
-
-
 static void SetPitchGradient(int start_ix, int end_ix, int start_pitch, int end_pitch)
 {
 // Set a linear pitch change over a number of syllables.
 	}
 }
 
-
-
 // Calculate pitch values for the vowels in this tone group
 static int calc_pitches2(int start, int end,  int tune_number)
 {
 	return tone_pitch_env;
 }
 
-
-
 // Calculate pitch values for the vowels in this tone group
 static int calc_pitches(int control, int start, int end,  int tune_number)
 {
 	return tone_pitch_env;
 }
 
-
-
-
-
-
 static void CalcPitches_Tone(Translator *tr, int clause_tone)
 {
 //  clause_tone: 0=. 1=, 2=?, 3=! 4=none
 			p->tone_ph = PhonemeCode('7');   // change default tone (tone 1) to falling tone at end of clause
 	}
 
-
 	pause = 1;
 	tone_promoted = 0;
 
 
 					p->tone_ph = tone_ph;
 					tph = phoneme_tab[tone_ph];
-
 				} else
 					tone_promoted = 0;
 
 			p->pitch2 = pitch_adjust + phoneme_tab[tone_ph]->end_type;
 		}
 	}
-
-
 }
 
-
-
 void CalcPitches(Translator *tr, int clause_type)
 {
 //  clause_type: 0=. 1=, 2=?, 3=! 4=none
 	if (n_st == 0)
 		return;  // nothing to do
 
-
-
 	if (tr->langopts.tone_language == 1) {
 		CalcPitches_Tone(tr, clause_type);
 		return;
 	}
 
-
 	option = tr->langopts.intonation_group;
 	if (option >= INTONATION_TYPES)
 		option = 1;
 		calc_pitches(option, st_start, st_ix, group_tone);
 	}
 
-
 	// unpack pitch data
 	st_ix = 0;
 	for (ix = ph_start; ix < ph_end; ix++) {
 			st_ix++;
 		}
 	}
-
 }

src/libespeak-ng/klatt.c

 static int nsamples;
 static int sample_count;
 
-
 #ifdef _MSC_VER
 #define getrandom(min, max) ((rand()%(int)(((max)+1)-(min)))+(min))
 #else
 #define getrandom(min, max) ((rand()%(long)(((max)+1)-(min)))+(min))
 #endif
 
-
 /* function prototypes for functions private to this file */
 
 static void flutter(klatt_frame_ptr);
 	return (double)x;
 }
 
-
-
 static double antiresonator2(resonator_ptr r, double input)
 {
 	register double x = (double)r->a * (double)input + (double)r->b * (double)r->p1 + (double)r->c * (double)r->p2;
 	return (double)x;
 }
 
-
-
 /*
    function FLUTTER
 
 	time_count++;
 }
 
-
-
 /*
    function SAMPLED_SOURCE
 
 	return result;
 }
 
-
-
-
 /*
    function PARWAVE
 
    Converts synthesis parameters to a waveform.
  */
 
-
 static int parwave(klatt_frame_ptr frame)
 {
 	double temp;
 	return 0;
 }
 
-
-
-
-
 void KlattReset(int control)
 {
 	int r_ix;
 			kt_globals.rsn[r_ix].p1 = 0;
 			kt_globals.rsn[r_ix].p2 = 0;
 		}
-
 	}
 
 	for (r_ix = 0; r_ix <= R6p; r_ix++) {
 	}
 }
 
-
 /*
    function FRAME_INIT
 
 	kt_globals.rsn[F_NZ].b_inc = (kt_globals.rsn_next[F_NZ].b - kt_globals.rsn[F_NZ].b) / 64.0;
 	kt_globals.rsn[F_NZ].c_inc = (kt_globals.rsn_next[F_NZ].c - kt_globals.rsn[F_NZ].c) / 64.0;
 
-
 	/* Set coefficients of parallel resonators, and amplitude of outputs */
 
 	for (ix = 0; ix <= 6; ix++) {
 	/* output low-pass filter */
 
 	setabc((long)0.0, (long)(kt_globals.samrate/2), &(kt_globals.rsn[Rout]));
-
 }
 
-
-
 /*
    function IMPULSIVE_SOURCE
 
    to Kopen.
  */
 
-
 static double impulsive_source()
 {
 	static double doublet[] = { 0.0, 13000000.0, -13000000.0 };
 	return resonator(&(kt_globals.rsn[RGL]), vwave);
 }
 
-
-
 /*
    function NATURAL_SOURCE
 
 	return 0.0;
 }
 
-
-
-
-
 /*
    function PITCH_SYNC_PAR_RESET
 
 			kt_globals.nopen = 40;
 		}
 
-
 		/* Reset a & b, which determine shape of "natural" glottal waveform */
 
 		kt_globals.pulse_shape_b = B0[kt_globals.nopen-40];
 	}
 }
 
-
-
 /*
    function SETABC
 
    equation constants.
  */
 
-
 static void setabc(long int f, long int bw, resonator_ptr rp)
 {
 	double r;
 	rp->a = 1.0 - rp->b - rp->c;
 }
 
-
 /*
    function SETZEROABC
 
 	}
 }
 
-
 /*
    function GEN_NOISE
 
    the origin in the z-plane, i.e. output = input + (0.75 * lastoutput)
  */
 
-
 static double gen_noise(double noise)
 {
 	long temp;
 	return noise;
 }
 
-
 /*
    function DBTOLIN
 
    steps.
  */
 
-
 static double DBtoLIN(long dB)
 {
 	static short amptable[88] = {
 	return (double)(amptable[dB]) * 0.001;
 }
 
-
-
-
-
 extern voice_t *wvoice;
 static klatt_peaks_t peaks[N_PEAKS];
 static int end_wave;
 static double klattp1[N_KLATTP];
 static double klattp_inc[N_KLATTP];
 
-
-
-
 int Wavegen_Klatt(int resume)
 {
 	int pk;
 	return 0;
 }
 
-
 void SetSynth_Klatt(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v, int control)
 {
 	int ix;
 	}
 }
 
-
 int Wavegen_Klatt2(int length, int modulation, int resume, frame_t *fr1, frame_t *fr2)
 {
 	if (resume == 0)
 	return Wavegen_Klatt(resume);
 }
 
-
-
 void KlattInit()
 {
 

src/libespeak-ng/mbrowrap.c

 
 #include "mbrowrap.h"
 
-
 /*
  * mbrola instance parameters
  */

src/libespeak-ng/numbers.c

 #include "voice.h"
 #include "translate.h"
 
-
 #define M_LIGATURE  0x8000
 #define M_NAME      0
 #define M_SMALLCAP  1
 #define M_RETROFLEX 20
 #define M_HOOK      21
 
-
 #define M_MIDDLE_DOT  M_DOT_ABOVE  // duplicate of M_DOT_ABOVE
 #define M_IMPLOSIVE   M_HOOK
 
 static int speak_missing_thousands;
 static int number_control;
 
-
 typedef struct {
 	const char *name;
 	int accent_flags;    // bit 0, say before the letter name
 	{ "_hok", 0 },  // hook
 };
 
-
 #define CAPITAL  0
 #define LETTER(ch, mod1, mod2) (ch-59)+(mod1 << 6)+(mod2 << 11)
 #define LIGATURE(ch1, ch2, mod1) (ch1-59)+((ch2-59) << 6)+(mod1 << 12)+M_LIGATURE
 #define L_RTAP    72 // U+27E
 #define L_RLONG   73 // U+27C
 
-
 static const short non_ascii_tab[] = {
 	0, 0x3b1, 0x259, 0x25b, 0x3b3, 0x3b9, 0x153, 0x3c9,
 	0x3c6, 0x283, 0x3c5, 0x292, 0x294, 0x27e, 0x27c
 };
 
-
 // characters U+00e0 to U+017f
 static const unsigned short letter_accents_0e0[] = {
 	LETTER('a', M_GRAVE, 0),   // U+00e0
 	CAPITAL,
 	LETTER('z', M_CARON, 0),
 	LETTER('s', M_NAME, 0), // long-s  // U+17f
-
 };
 
-
 // characters U+0250 to U+029F
 static const unsigned short letter_accents_250[] = {
 	LETTER('a', M_TURNED, 0),     // U+250
 	return ph_buf[0];
 }
 
-
 void LookupAccentedLetter(Translator *tr, unsigned int letter, char *ph_buf)
 {
 	// lookup the character in the accents table
 			accent2 = (accent_data >> 11) & 0xf;
 		}
 
-
 		if ((accent1 == 0) && !(accent_data & M_LIGATURE)) {
 			// just a letter name, not an accented character or ligature
 			return;
 		}
 
 		if ((flags1 = Lookup(tr, accents_tab[accent1].name, ph_accent1)) != 0) {
-
 			if (LookupLetter2(tr, basic_letter, ph_letter1) != 0) {
 				if (accent2 != 0) {
 					flags2 = Lookup(tr, accents_tab[accent2].name, ph_accent2);
 	}
 }
 
-
-
 void LookupLetter(Translator *tr, unsigned int letter, int next_byte, char *ph_buf1, int control)
 {
 // control, bit 0:  not the first letter of a word
 	dict_flags[0] = 0;
 	dict_flags[1] = 0;
 	SetWordStress(tr, ph_buf1, dict_flags, -1, control & 1);
-
 }
 
-
 // unicode ranges for non-ascii digits 0-9
 static const int number_ranges[] = {
 	0x660, 0x6f0,  // arabic
 	0
 };        // these must be in ascending order
 
-
 int NonAsciiNumber(int letter)
 {
 // Change non-ascii digit into ascii digit '0' to '9', (or -1 if not)
 	0, 0
 };
 
-
 static const char *hex_letters[] = { "'e:j", "b'i:", "s'i:", "d'i:", "'i:", "'ef" };  // names, using phonemes available to all languages
 
-
 int IsSuperscript(int letter)
 {
 // is this a subscript or superscript letter ?
 	return 0;
 }
 
-
-
 int TranslateLetter(Translator *tr, char *word, char *phonemes, int control)
 {
 // get pronunciation for an isolated letter
 		}
 	}
 
-
 // caution: SetWordStress() etc don't expect phonSWITCH + phoneme table number
 
 	if (ph_buf[0] == 0) {
 	return n_bytes;
 }
 
-
-
 void SetSpellingStress(Translator *tr, char *phonemes, int control, int n_chars)
 {
 // Individual letter names, reduce the stress of some.
 	*phonemes = 0;
 }
 
-
-
 // Numbers
 
 static char ph_ordinal2[12];
 static char ph_ordinal2x[12];
 
-
 static int CheckDotOrdinal(Translator *tr, char *word, char *word_end, WORD_TAB *wtab, int roman)
 {
-
 	int ordinal = 0;
 	int c2;
 	int nextflags;
 	return ordinal;
 }
 
-
 static int hu_number_e(const char *word, int thousandplex, int value)
 {
 // lang-hu: variant form of numbers when followed by hyphen and a suffix starting with 'a' or 'e' (but not a, e, az, ez, azt, ezt, att. ett
 	return 0;
 }
 
-
-
 int TranslateRoman(Translator *tr, char *word, char *ph_out, WORD_TAB *wtab)
 {
 	int c;
 	if (acc > tr->langopts.max_roman)
 		return 0;
 
-
 	Lookup(tr, "_roman", ph_roman);   // precede by "roman" if _rom is defined in *_list
 	p = &ph_out[0];
 
 	return 1;
 }
 
-
 static const char *M_Variant(int value)
 {
 	// returns M, or perhaps MA or MB for some cases
 		if ((teens == 0) && ((value % 10) == 1))
 			return "1M";
 		break;
-
 	case 2:  // lang=cs,sk
 		if ((value >= 2) && (value <= 4))
 			return "0MA";
 		break;
-
 	case 3:  // lang=pl
 		if ((teens == 0) && (((value % 10) >= 2) && ((value % 10) <= 4)))
 			return "0MA";
 		break;
-
 	case 4:  // lang=lt
 		if ((teens == 1) || ((value % 10) == 0))
 			return "0MB";
 		if ((value % 10) == 1)
 			return "0MA";
 		break;
-
 	case 5:  // lang=bs,hr,sr
 		if (teens == 0) {
 			if ((value % 10) == 1)
 	return "0M";
 }
 
-
 static int LookupThousands(Translator *tr, int value, int thousandplex, int thousands_exact, char *ph_out)
 {
 // thousands_exact:  bit 0  no hundreds,tens,or units,  bit 1  ordinal numberr
 	return found_value;
 }
 
-
 static int LookupNum2(Translator *tr, int value, int thousandplex, const int control, char *ph_out)
 {
 // Lookup a 2 digit number
 			if (found) {
 				ph_tens[0] = 0;
 			} else {
-
 				if (is_ordinal) {
 					sprintf(string, "_%dX%c", tens, ord_type);
 					if (Lookup(tr, string, ph_tens) != 0) {
 	return used_and;
 }
 
-
 static int LookupNum3(Translator *tr, int value, char *ph_out, int suppress_null, int thousandplex, int control)
 {
 // Translate a 3 digit number
 		}
 	}
 
-
 	buf2[0] = 0;
 
 	if ((tensunits != 0) || (suppress_null == 0)) {
 	return 0;
 }
 
-
 bool CheckThousandsGroup(char *word, int group_len)
 {
 // Is this a group of 3 digits which looks like a thousands group?
 	return true;
 }
 
-
 static int TranslateNumber_1(Translator *tr, char *word, char *ph_out, unsigned int *flags, WORD_TAB *wtab, int control)
 {
 //  Number translation with various options
 	ph_append[0] = 0;
 	ph_buf2[0] = 0;
 
-
 	if ((word[0] == '0') && (prev_thousands == 0) && (word[1] != ' ') && (word[1] != tr->langopts.decimal_sep)) {
 		if ((n_digits == 2) && (word[3] == ':') && IsDigit09(word[5]) && isspace(word[7])) {
 			// looks like a time 02:30, omit the leading zero
 		{
 		case NUM_DFRACTION_4:
 			max_decimal_count = 5;
+			// fallthrough
 		case NUM_DFRACTION_2:
 			// French/Polish decimal fraction
 			while (word[n_digits] == '0') {
 				n_digits += decimal_count;
 			}
 			break;
-
 		case NUM_DFRACTION_1:       // italian, say "hundredths" if leading zero
 		case NUM_DFRACTION_5:       // hungarian, always say "tenths" etc.
 		case NUM_DFRACTION_6:       // kazakh, always say "tenths" etc, before the decimal fraction
 			strcat(ph_out, ph_buf);
 			n_digits += decimal_count;
 			break;
-
 		case NUM_DFRACTION_3:
 			// Romanian decimal fractions
 			if ((decimal_count <= 4) && (word[n_digits] != '0')) {
 				n_digits += decimal_count;
 			}
 			break;
-
 		case NUM_DFRACTION_7:
 			// alternative form of decimal fraction digits, except the final digit
 			while (decimal_count-- > 1) {
 	return 1;
 }
 
-
-
 int TranslateNumber(Translator *tr, char *word1, char *ph_out, unsigned int *flags, WORD_TAB *wtab, int control)
 {
 	if ((option_sayas == SAYAS_DIGITS1) || (wtab[0].flags & FLAG_INDIVIDUAL_DIGITS))

src/libespeak-ng/phonemelist.c

 #include "synthesize.h"
 #include "translate.h"
 
-
 const unsigned char pause_phonemes[8] = { 0, phonPAUSE_VSHORT, phonPAUSE_SHORT, phonPAUSE, phonPAUSE_LONG, phonGLOTTALSTOP, phonPAUSE_LONG, phonPAUSE_LONG };
 
-
 extern int n_ph_list2;
 extern PHONEME_LIST2 ph_list2[N_PHONEME_LIST];  // first stage of text->phonemes
 
-
-
 static int SubstitutePhonemes(Translator *tr, PHONEME_LIST *plist_out)
 {
 // Copy the phonemes list and perform any substitutions that are required for the
 	return n_plist_out;
 }
 
-
-
 void MakePhonemeList(Translator *tr, int post_pause, int start_sentence)
 {
-
 	int ix = 0;
 	int j;
 	int insert_ph = 0;

src/libespeak-ng/readclause.c

 #include <locale.h>
 #define N_XML_BUF   500
 
-
 static const char *xmlbase = "";    // base URL from <speak>
 
 static int namedata_ix = 0;
 static int n_namedata = 0;
 char *namedata = NULL;
 
-
 static FILE *f_input = NULL;
 static int ungot_char2 = 0;
 unsigned char *p_textinput;
 
 	                                          0 };
 
-
 // indexed by (entry num. in punct_chars) + 1
 // bits 0-7 pause x 10mS, bits 12-14 intonation type, bit 15 don't need following space or bracket
 static const unsigned int punct_attributes[] = { 0,
 	                                             CLAUSE_SEMICOLON,  // spare
 	                                             0 };
 
-
 // stack for language and voice properties
 // frame 0 is for the defaults, before any ssml tags.
 typedef struct {
 static char base_voice_variant_name[40] = { 0 };
 static char current_voice_id[40] = { 0 };
 
-
 #define N_PARAM_STACK  20
 static int n_param_stack;
 PARAM_STACK param_stack[N_PARAM_STACK];
 	0,    // voice type
 };
 
-
 // additional Latin characters beyond the ascii character set
 #define MAX_WALPHA  0x24f
 // indexed by character - 0x80
 	0, 0
 };
 
-
 #ifdef NEED_WCHAR_FUNCTIONS
 
 // use ctype.h functions for Latin1 (character < 0x100)
 }
 #endif
 
-
 // use internal data for iswalpha up to U+024F
 // iswalpha() on Windows is unreliable  (U+AA, U+BA).
 int iswalpha2(int c)
 	return 0;
 }
 
-
 static void GetC_unget(int c)
 {
 // This is only called with UTF8 input, not wchar input
 	return end_of_input;
 }
 
-
 static int GetC_get(void)
 {
 	unsigned int c;
 	return 0;
 }
 
-
 static int GetC(void)
 {
 // Returns a unicode wide character
 	return c1;
 }
 
-
 static void UngetC(int c)
 {
 	ungot_char = c;
 }
 
-
 const char *WordToString2(unsigned int word)
 {
 // Convert a language mnemonic word into a string
 	return buf;
 }
 
-
 static const char *LookupSpecial(Translator *tr, const char *string, char *text_out)
 {
 	unsigned int flags[2];
 	return NULL;
 }
 
-
 static const char *LookupCharName(Translator *tr, int c, int only)
 {
 // Find the phoneme string (in ascii) to speak the name of character c
 	return acc;
 }
 
-
 static int LoadSoundFile(const char *fname, int index)
 {
 	FILE *f;
 	return 0;
 }
 
-
 static int LookupSoundicon(int c)
 {
 // Find the sound icon number for a punctuation chatacter
 	return -1;
 }
 
-
 static int LoadSoundFile2(const char *fname)
 {
 // Load a sound file into one of the reserved slots in the sound icon table
 	return slot;
 }
 
-
-
 static int AnnouncePunctuation(Translator *tr, int c1, int *c2_ptr, char *output, int *bufix, int end_clause)
 {
 	// announce punctuation names
 // these tags have no effect if they are self-closing, eg. <voice />
 static char ignore_if_self_closing[] = { 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0 };
 
-
 static MNEM_TAB ssmltags[] = {
 	{ "speak", SSML_SPEAK },
 	{ "voice", SSML_VOICE },
 	{ NULL, 0 }
 };
 
-
-
-
 static const char *VoiceFromStack()
 {
 // Use the voice properties from the SSML stack to choose a voice, and switch
 	return v_id;
 }
 
-
-
 static void ProcessParamStack(char *outbuf, int *outix)
 {
 // Set the speech parameters from the parameter stack
 	int new_parameters[N_SPEECH_PARAM];
 	static char cmd_letter[N_SPEECH_PARAM] = { 0, 'S', 'A', 'P', 'R', 0, 'C', 0, 0, 0, 0, 0, 'F' };  // embedded command letters
 
-
 	for (param = 0; param < N_SPEECH_PARAM; param++)
 		new_parameters[param] = -1;
 
 			case espeakPUNCTUATION:
 				option_punctuation = value-1;
 				break;
-
 			case espeakCAPITALS:
 				option_capitals = value;
 				break;
-
 			case espeakRATE:
 			case espeakVOLUME:
 			case espeakPITCH:
 	}
 }
 
-
 static PARAM_STACK *PushParamStack(int tag_type)
 {
 	int ix;
 	return sp;
 }
 
-
 static void PopParamStack(int tag_type, char *outbuf, int *outix)
 {
 	// unwind the stack up to and including the previous tag of this type
 	ProcessParamStack(outbuf, outix);
 }
 
-
-
 static wchar_t *GetSsmlAttribute(wchar_t *pw, const char *name)
 {
 // Gets the value string for an attribute.
 	return NULL;
 }
 
-
 static int attrcmp(const wchar_t *string1, const char *string2)
 {
 	int ix;
 	return 1;
 }
 
-
 static int attrlookup(const wchar_t *string1, const MNEM_TAB *mtab)
 {
 	int ix;
 	return mtab[ix].value;
 }
 
-
 static int attrnumber(const wchar_t *pw, int default_value, int type)
 {
 	int value = 0;
 	return value;
 }
 
-
-
 static int attrcopy_utf8(char *buf, const wchar_t *pw, int len)
 {
 // Convert attribute string into utf8, write to buf, and return its utf8 length
 	return ix;
 }
 
-
-
 static int attr_prosody_value(int param_type, const wchar_t *pw, int *value_out)
 {
 	int sign = 0;
 	return sign;   // -1, 0, or 1
 }
 
-
 int AddNameData(const char *name, int wide)
 {
 // Add the name to the namedata and return its position
 	return ix;
 }
 
-
 void SetVoiceStack(espeak_VOICE *v, const char *variant_name)
 {
 	SSML_STACK *sp;
 	memcpy(&base_voice, &current_voice_selected, sizeof(base_voice));
 }
 
-
 static int GetVoiceAttributes(wchar_t *pw, int tag_type)
 {
 // Determines whether voice attribute are specified in this tag, and if so, whether this means
 	return 0;
 }
 
-
 static void SetProsodyParameter(int param_type, wchar_t *attr1, PARAM_STACK *sp)
 {
 	int value;
 		NULL, mnem_rate, mnem_volume, mnem_pitch, mnem_range
 	};
 
-
 	if ((value = attrlookup(attr1, mnem_tabs[param_type])) >= 0) {
 		// mnemonic specifies a value as a percentage of the base pitch/range/rate/volume
 		sp->parameter[param_type] = (param_stack[0].parameter[param_type] * value)/100;
 	}
 }
 
-
 static int ReplaceKeyName(char *outbuf, int index, int *outix)
 {
 // Replace some key-names by single characters, so they can be pronounced in different languages
 	return 0;
 }
 
-
 static int ProcessSsmlTag(wchar_t *xml_buf, char *outbuf, int *outix, int n_outbuf, int self_closing)
 {
 // xml_buf is the tag and attributes with a zero terminator in place of the original '>'
 			return 0;
 	}
 
-
 	voice_change_flag = 0;
 	terminator = CLAUSE_NONE;
 	ssml_sp = &ssml_stack[n_ssml_stack-1];
 		}
 		ProcessParamStack(outbuf, outix);
 		break;
-
 	case SSML_PROSODY:
 		sp = PushParamStack(tag_type);
 
 
 		ProcessParamStack(outbuf, outix);
 		break;
-
 	case SSML_EMPHASIS:
 		sp = PushParamStack(tag_type);
 		value = 3;   // default is "moderate"
 		}
 		ProcessParamStack(outbuf, outix);
 		break;
-
 	case SSML_STYLE + SSML_CLOSE:
 	case SSML_PROSODY + SSML_CLOSE:
 	case SSML_EMPHASIS + SSML_CLOSE:
 		PopParamStack(tag_type, outbuf, outix);
 		break;
-
 	case SSML_PHONEME:
 		attr1 = GetSsmlAttribute(px, "alphabet");
 		attr2 = GetSsmlAttribute(px, "ph");
 			outbuf[(*outix)++] = ']';
 		}
 		break;
-
 	case SSML_SAYAS:
 		attr1 = GetSsmlAttribute(px, "interpret-as");
 		attr2 = GetSsmlAttribute(px, "format");
 		sayas_start = *outix;
 		sayas_mode = value;   // punctuation doesn't end clause during SAY-AS
 		break;
-
 	case SSML_SAYAS + SSML_CLOSE:
 		if (sayas_mode == SAYAS_KEY) {
 			outbuf[*outix] = 0;
 		outbuf[(*outix)++] = 'Y';
 		sayas_mode = 0;
 		break;
-
 	case SSML_SUB:
 		if ((attr1 = GetSsmlAttribute(px, "alias")) != NULL) {
 			// use the alias  rather than the text
 			*outix += attrcopy_utf8(&outbuf[*outix], attr1, n_outbuf-*outix);
 		}
 		break;
-
 	case SSML_IGNORE_TEXT:
 		ignore_text = 1;
 		break;
-
 	case SSML_SUB + SSML_CLOSE:
 	case SSML_IGNORE_TEXT + SSML_CLOSE:
 		ignore_text = 0;
 		break;
-
 	case SSML_MARK:
 		if ((attr1 = GetSsmlAttribute(px, "name")) != NULL) {
 			// add name to circular buffer of marker names
 			}
 		}
 		break;
-
 	case SSML_AUDIO:
 		sp = PushParamStack(tag_type);
 
 		else
 			audio_text = 1;
 		return CLAUSE_NONE;
-
 	case SSML_AUDIO + SSML_CLOSE:
 		PopParamStack(tag_type, outbuf, outix);
 		audio_text = 0;
 		return CLAUSE_NONE;
-
 	case SSML_BREAK:
 		value = 21;
 		terminator = CLAUSE_NONE;
 			return terminator + value;
 		}
 		break;
-
 	case SSML_SPEAK:
 		if ((attr1 = GetSsmlAttribute(px, "xml:base")) != NULL) {
 			attrcopy_utf8(buf, attr1, sizeof(buf));
 		if (GetVoiceAttributes(px, tag_type) == 0)
 			return 0;   // no voice change
 		return CLAUSE_VOICE;
-
 	case SSML_VOICE:
 		if (GetVoiceAttributes(px, tag_type) == 0)
 			return 0;   // no voice change
 		return CLAUSE_VOICE;
-
 	case SSML_SPEAK + SSML_CLOSE:
 		// unwind stack until the previous <voice> or <speak> tag
 		while ((n_ssml_stack > 1) && (ssml_stack[n_ssml_stack-1].tag_type != SSML_SPEAK))
 			n_ssml_stack--;
 		return CLAUSE_PERIOD + GetVoiceAttributes(px, tag_type);
-
 	case SSML_VOICE + SSML_CLOSE:
 		// unwind stack until the previous <voice> or <speak> tag
 		while ((n_ssml_stack > 1) && (ssml_stack[n_ssml_stack-1].tag_type != SSML_VOICE))
 
 		terminator = 0; // ??  Sentence intonation, but no pause ??
 		return terminator + GetVoiceAttributes(px, tag_type);
-
 	case HTML_BREAK:
 	case HTML_BREAK + SSML_CLOSE:
 		return CLAUSE_COLON;
-
 	case SSML_SENTENCE:
 		if (ssml_sp->tag_type == SSML_SENTENCE) {
 			// new sentence implies end-of-sentence
 		}
 		voice_change_flag |= GetVoiceAttributes(px, tag_type);
 		return CLAUSE_PARAGRAPH + voice_change_flag;
-
-
 	case SSML_PARAGRAPH:
 		if (ssml_sp->tag_type == SSML_SENTENCE) {
 			// new paragraph implies end-of-sentence or end-of-paragraph
 		}
 		voice_change_flag |= GetVoiceAttributes(px, tag_type);
 		return CLAUSE_PARAGRAPH + voice_change_flag;
-
-
 	case SSML_SENTENCE + SSML_CLOSE:
 		if (ssml_sp->tag_type == SSML_SENTENCE) {
 			// end of a sentence which specified a language
 			voice_change_flag = GetVoiceAttributes(px, tag_type);
 		}
 		return CLAUSE_PERIOD + voice_change_flag;
-
-
 	case SSML_PARAGRAPH + SSML_CLOSE:
 		if ((ssml_sp->tag_type == SSML_SENTENCE) || (ssml_sp->tag_type == SSML_PARAGRAPH)) {
 			// End of a paragraph which specified a language.
 	return 0;
 }
 
-
 static void RemoveChar(char *p)
 {
 // Replace a UTF-8 character by spaces
 	memset(p, ' ', utf8_in(&c, p));
 }
 
-
 static MNEM_TAB xml_char_mnemonics[] = {
 	{ "gt", '>' },
 	{ "lt", 0xe000 + '<' },   // private usage area, to avoid confusion with XML tag
 	{ NULL, -1 }
 };
 
-
 int ReadClause(Translator *tr, FILE *f_in, char *buf, short *charix, int *charix_top, int n_buf, int *tone_type, char *voice_change)
 {
 /* Find the end of the current clause.
 	return CLAUSE_EOF;   //  end of file
 }
 
-
 void InitNamedata(void)
 {
 	namedata_ix = 0;
 	}
 }
 
-
 void InitText2(void)
 {
 	int param;

src/libespeak-ng/setlengths.c

 extern void DoSonicSpeed(int value);
 extern int saved_parameters[];
 
-
 // convert from words-per-minute to internal speed factor
 // Use this to calibrate speed for wpm 80-350
 static unsigned char speed_lookup[] = {
 	9,   9,   8,   8,   8,  // 355
 };
 
-
 // speed_factor1 adjustments for speeds 350 to 374: pauses
 static unsigned char pause_factor_350[] = {
 	22, 22, 22, 22, 22, 22, 22, 21, 21, 21, // 350
 static int speed2 = 121;
 static int speed3 = 118;
 
-
-
 #if HAVE_SONIC_H
 
 void SetSpeed(int control)
 		embedded_value[EMBED_S2] = new_value;
 		SetSpeed(3);
 		break;
-
 	case espeakVOLUME:
 		embedded_value[EMBED_A] = new_value;
 		GetAmplitude();
 		break;
-
 	case espeakPITCH:
 		if (new_value > 99) new_value = 99;
 		if (new_value < 0) new_value = 0;
 		embedded_value[EMBED_P] = new_value;
 		break;
-
 	case espeakRANGE:
 		if (new_value > 99) new_value = 99;
 		embedded_value[EMBED_R] = new_value;
 		break;
-
 	case espeakLINELENGTH:
 		option_linelength = new_value;
 		break;
-
 	case espeakWORDGAP:
 		option_wordgap = new_value;
 		break;
-
 	case espeakINTONATION:
 		if ((new_value & 0xff) != 0)
 			translator->langopts.intonation_group = new_value & 0xff;
 		option_tone_flags = new_value;
 		break;
-
 	default:
 		break;
 	}
 }
 
-
-
 static void DoEmbedded2(int *embix)
 {
 	// There were embedded commands in the text at this point
 	} while ((word & 0x80) == 0);
 }
 
-
 void CalcLengths(Translator *tr)
 {
 	int ix;
 		case phPAUSE:
 			last_pitch = 0;
 			break;
-
 		case phSTOP:
 			last_pitch = 0;
 			if (prev->type == phFRICATIVE)
 			if (p->synthflags & SFLAG_LENGTHEN)
 				p->prepause += tr->langopts.long_stop;
 			break;
-
 		case phVFRICATIVE:
 		case phFRICATIVE:
 			if (p->newword) {
 					p->length = (255 + prev->length)/2;
 			}
 			break;
-
 		case phVSTOP:
 			if (prev->type == phVFRICATIVE || prev->type == phFRICATIVE || (prev->ph->phflags & phSIBILANT) || (prev->type == phLIQUID))
 				p->prepause = 30;
 			}
 			if ((tr->langopts.word_gap & 0x10) && (p->newword) && (p->prepause < 20))
 				p->prepause = 20;
-
 			break;
-
 		case phLIQUID:
 		case phNASAL:
 			p->amp = tr->stress_amps[0];  // unless changed later
 				pre_voiced = 0;
 			}
 			break;
-
 		case phVOWEL:
 			min_drop = 0;
 			next2 = &phoneme_list[ix+2];
 				}
 			}
 
-
 			if ((end_of_clause == 2) && !(tr->langopts.stress_flags & S_NO_EOC_LENGTHEN)) {
 				// this is the last syllable in the clause, lengthen it - more for short vowels
 				len = (p->ph->std_length * 2);

src/libespeak-ng/speak_lib.c

 char path_home[N_PATH_HOME];   // this is the espeak-data directory
 extern int saved_parameters[N_SPEECH_PARAM]; // Parameters saved on synthesis start
 
-
 void WVoiceChanged(voice_t *wvoice)
 {
 // Voice change in wavegen
 	voice_samplerate = wvoice->samplerate;
 }
 
-
 #ifdef USE_ASYNC
 
 static int dispatch_audio(short *outbuf, int length, espeak_EVENT *event)
 			a_wave_can_be_played = fifo_is_command_enabled();
 		}
 	}
-	break;
-
+		break;
 	case AUDIO_OUTPUT_RETRIEVAL:
 		if (synth_callback)
 			synth_callback(outbuf, length, event);
 		break;
-
 	case AUDIO_OUTPUT_SYNCHRONOUS:
 	case AUDIO_OUTPUT_SYNCH_PLAYBACK:
 		break;
 	return a_wave_can_be_played == 0; // 1 = stop synthesis, -1 = error
 }
 
-
-
 static int create_events(short *outbuf, int length, espeak_EVENT *event, uint32_t the_write_pos)
 {
 	int finished;
 	return finished;
 }
 
-
 int sync_espeak_terminated_msg(uint32_t unique_identifier, void *user_data)
 {
 	ENTER("sync_espeak_terminated_msg");
 
 #endif
 
-
 static void select_output(espeak_AUDIO_OUTPUT output_type)
 {
 	my_mode = output_type;
 		// wave_init() is now called just before the first wave_write()
 		synchronous_mode = 0;
 		break;
-
 	case AUDIO_OUTPUT_RETRIEVAL:
 		synchronous_mode = 0;
 		break;
-
 	case AUDIO_OUTPUT_SYNCHRONOUS:
 		break;
-
 	case AUDIO_OUTPUT_SYNCH_PLAYBACK:
 		option_waveout = 0;
 		WavegenInitSound();
 	}
 }
 
-
-
-
 #pragma GCC visibility push(default)
 int GetFileLength(const char *filename)
 {
 }
 #pragma GCC visibility pop
 
-
 char *Alloc(int size)
 {
 	char *p;
 		free(ptr);
 }
 
-
-
 static void init_path(const char *path)
 {
 #ifdef PLATFORM_WINDOWS
 	RegQueryValueExA(RegKey, "path", 0, &var_type, buf, &size);
 
 	sprintf(path_home, "%s\\espeak-data", buf);
-
 #else
 	char *env;
 
 	return 0;
 }
 
-
 static espeak_ERROR Synthesize(unsigned int unique_identifier, const void *text, int flags)
 {
 	// Fill the buffer with output sound
 };
 #endif
 
-
 void MarkerEvent(int type, unsigned int char_position, int value, int value2, unsigned char *out_ptr)
 {
 	// type: 1=word, 2=sentence, 3=named mark, 4=play audio, 5=end, 7=phoneme
 		ep->id.number = value;
 }
 
-
-
-
 espeak_ERROR sync_espeak_Synth(unsigned int unique_identifier, const void *text, size_t size,
                                unsigned int position, espeak_POSITION_TYPE position_type,
                                unsigned int end_position, unsigned int flags, void *user_data)
 {
-
 #ifdef DEBUG_ENABLED
 	ENTER("sync_espeak_Synth");
 	SHOW("sync_espeak_Synth > position=%d, position_type=%d, end_position=%d, flags=%d, user_data=0x%x, text=%s\n", position, position_type, end_position, flags, user_data, text);
 	case POS_CHARACTER:
 		skip_characters = position;
 		break;
-
 	case POS_WORD:
 		skip_words = position;
 		break;
-
 	case POS_SENTENCE:
 		skip_sentences = position;
 		break;
 	return aStatus;
 }
 
-
-
-
 espeak_ERROR sync_espeak_Synth_Mark(unsigned int unique_identifier, const void *text, size_t size,
                                     const char *index_mark, unsigned int end_position,
                                     unsigned int flags, void *user_data)
 
 	end_character_position = end_position;
 
-
 	aStatus = Synthesize(unique_identifier, text, flags | espeakSSML);
 	SHOW_TIME("LEAVE sync_espeak_Synth_Mark");
 
 	return aStatus;
 }
 
-
-
 void sync_espeak_Key(const char *key)
 {
 	// symbolic name, symbolicname_character  - is there a system resource of symbolic names per language?
 	Synthesize(0, key, 0);   // speak key as a text string
 }
 
-
 void sync_espeak_Char(wchar_t character)
 {
 	// is there a system resource of character names per language?
 	Synthesize(0, buf, espeakSSML);
 }
 
-
-
 void sync_espeak_SetPunctuationList(const wchar_t *punctlist)
 {
 	// Set the list of punctuation which are spoken for "some".
 	}
 }
 
-
-
-
 #pragma GCC visibility push(default)
 
-
 ESPEAK_API void espeak_SetSynthCallback(t_espeak_callback *SynthCallback)
 {
 	ENTER("espeak_SetSynthCallback");
 	uri_callback = UriCallback;
 }
 
-
 ESPEAK_API void espeak_SetPhonemeCallback(int (*PhonemeCallback)(const char *))
 {
 	phoneme_callback = PhonemeCallback;
 	return samplerate;
 }
 
-
-
 ESPEAK_API espeak_ERROR espeak_Synth(const void *text, size_t size,
                                      unsigned int position,
                                      espeak_POSITION_TYPE position_type,
 		delete_espeak_command(c1);
 		delete_espeak_command(c2);
 	}
-
 #endif
 	return a_error;
 }
 
-
-
 ESPEAK_API espeak_ERROR espeak_Synth_Mark(const void *text, size_t size,
                                           const char *index_mark,
                                           unsigned int end_position,
 	if (f_logespeak)
 		fprintf(f_logespeak, "\nSYNTH MARK %s posn %d flags 0x%x\n%s\n", index_mark, end_position, flags, (const char *)text);
 
-
 	if (unique_identifier == NULL)
 		unique_identifier = &temp_identifier;
 	*unique_identifier = 0;
 		delete_espeak_command(c1);
 		delete_espeak_command(c2);
 	}
-
 #endif
 	return a_error;
 }
 
-
-
 ESPEAK_API espeak_ERROR espeak_Key(const char *key)
 {
 	ENTER("espeak_Key");
 	a_error = fifo_add_command(c);
 	if (a_error != EE_OK)
 		delete_espeak_command(c);
-
 #endif
 	return a_error;
 }
 
-
 ESPEAK_API espeak_ERROR espeak_Char(wchar_t character)
 {
 	ENTER("espeak_Char");
 #endif
 }
 
-
 ESPEAK_API espeak_ERROR espeak_SetVoiceByName(const char *name)
 {
 	ENTER("espeak_SetVoiceByName");
 	return SetVoiceByName(name);
 }
 
-
-
 ESPEAK_API espeak_ERROR espeak_SetVoiceByProperties(espeak_VOICE *voice_selector)
 {
 	ENTER("espeak_SetVoiceByProperties");
 	return SetVoiceByProperties(voice_selector);
 }
 
-
 ESPEAK_API int espeak_GetParameter(espeak_PARAMETER parameter, int current)
 {
 	ENTER("espeak_GetParameter");
 	return param_defaults[parameter];
 }
 
-
 ESPEAK_API espeak_ERROR espeak_SetParameter(espeak_PARAMETER parameter, int value, int relative)
 {
 	ENTER("espeak_SetParameter");
 #endif
 }
 
-
 ESPEAK_API espeak_ERROR espeak_SetPunctuationList(const wchar_t *punctlist)
 {
 	ENTER("espeak_SetPunctuationList");
 #endif
 }
 
-
 ESPEAK_API void espeak_SetPhonemeTrace(int phonememode, FILE *stream)
 {
 	ENTER("espeak_SetPhonemes");
 	f_trans = stream;
 	if (stream == NULL)
 		f_trans = stderr;
-
 }
 
-
 ESPEAK_API const char *espeak_TextToPhonemes(const void **textptr, int textmode, int phonememode)
 {
 	/* phoneme_mode
 	return GetTranslatedPhonemeString(phonememode);
 }
 
-
 ESPEAK_API void espeak_CompileDictionary(const char *path, FILE *log, int flags)
 {
 	ENTER("espeak_CompileDictionary");
 	CompileDictionary(path, dictionary_name, log, NULL, flags);
 }
 
-
 ESPEAK_API espeak_ERROR espeak_Cancel(void)
 {
 #ifdef USE_ASYNC
 	return EE_OK;
 }
 
-
 ESPEAK_API int espeak_IsPlaying(void)
 {
 #ifdef USE_ASYNC
 #endif
 }
 
-
 ESPEAK_API espeak_ERROR espeak_Synchronize(void)
 {
 	espeak_ERROR berr = err;
 	return berr;
 }
 
-
 extern void FreePhData(void);
 extern void FreeVoiceList(void);
 
 		wave_terminate();
 		out_samplerate = 0;
 	}
-
 #endif
 	Free(event_list);
 	event_list = NULL;

src/libespeak-ng/spect.c

 	return y;
 }
 
-
 static SpectFrame *SpectFrameCreate()
 {
 	int ix;
 	free(frame);
 }
 
-
-
 int LoadFrame(SpectFrame *frame, FILE *stream, int file_format_type)
 {
 	short ix;
 	return 0;
 }
 
-
-
 double GetFrameRms(SpectFrame *frame, int seq_amplitude)
 {
 	int h;
 	return frame->rms;
 }
 
-
 SpectSeq *SpectSeqCreate()
 {
 	SpectSeq *spect = malloc(sizeof(SpectSeq));
 	free(spect);
 }
 
-
 static float GetFrameLength(SpectSeq *spect, int frame)
 {
 	int ix;
 	return (spect->frames[ix]->time - spect->frames[frame]->time) * 1000.0 + adjust;
 }
 
-
-
 int LoadSpectSeq(SpectSeq *spect, const char *filename)
 {
 	short n, temp;
 	frame_width = (int)((FRAME_WIDTH*spect->max_x)/MAX_DISPLAY_FREQ);
 	if (frame_width > FRAME_WIDTH) frame_width = FRAME_WIDTH;
 
-
 	// start times from zero
 	time_offset = spect->frames[0]->time;
 	for (ix = 0; ix < spect->numframes; ix++)

src/libespeak-ng/synth_mbrola.c

 #include "translate.h"
 #include "voice.h"
 
-
 #ifdef INCLUDE_MBROLA
 
 extern int Read4Bytes(FILE *f);
 PROCIV getFreq_MBR;
 PROCVF setVolumeRatio_MBR;
 
-
-
 HINSTANCE hinstDllMBR = NULL;
 
-
 BOOL load_MBR()
 {
 	if (hinstDllMBR != NULL)
 	return TRUE;
 }
 
-
 void unload_MBR()
 {
 	if (hinstDllMBR) {
 
 #endif   // windows
 
-
 static MBROLA_TAB *mbrola_tab = NULL;
 static int mbrola_control = 0;
 static int mbr_name_prefix = 0;
 	return EE_OK;
 }
 
-
 static int GetMbrName(PHONEME_LIST *plist, PHONEME_TAB *ph, PHONEME_TAB *ph_prev, PHONEME_TAB *ph_next, int *name2, int *split, int *control)
 {
 // Look up a phoneme in the mbrola phoneme name translation table
 	return mnem;
 }
 
-
 static char *WritePitch(int env, int pitch1, int pitch2, int split, int final)
 {
 // final=1:  only give the final pitch value.
 	output[0] = 0;
 	pitch_env = envelope_data[env];
 
-
 	SetPitch2(voice, pitch1, pitch2, &pitch_base, &pitch_range);
 
-
 	env_split = (split * 128)/100;
 	if (env_split < 0)
 		env_split = 0-env_split;
 	p1 = ((pitch_env[0]*pitch_range)>>8) + pitch_base;   // Hz << 12
 	p_end = ((pitch_env[127]*pitch_range)>>8) + pitch_base;
 
-
 	if (split >= 0) {
 		sprintf(buf, " 0 %d", p1/4096);
 		strcat(output, buf);
 	return output;
 }
 
-
 int MbrolaTranslate(PHONEME_LIST *plist, int n_phonemes, int resume, FILE *f_mbrola)
 {
 // Generate a mbrola pho file
 			}
 			done = 1;
 			break;
-
 		case phSTOP:
 			released = 0;
 			if (next->type == phVOWEL) released = 1;
 			len = (len * 1000)/samplerate;  // convert to mS
 			len += PauseLength(p->prepause, 1);
 			break;
-
 		case phVSTOP:
 			len = (80 * speed.wav_factor)/256;
 			break;
-
 		case phFRICATIVE:
 			len = 0;
 			InterpretPhoneme(NULL, 0, p, &phdata, NULL);
 
 			len = (len * 1000)/samplerate;  // convert to mS
 			break;
-
 		case phNASAL:
 			if (next->type != phVOWEL) {
 				memset(&fmtp, 0, sizeof(fmtp));
 				final_pitch = WritePitch(p->env, p->pitch1, p->pitch2, 0, 1);
 			}
 			break;
-
 		case phLIQUID:
 			if (next->type == phPAUSE) {
 				len += 50;
 	return 0;
 }
 
-
 int MbrolaGenerate(PHONEME_LIST *phoneme_list, int *n_ph, int resume)
 {
 	FILE *f_mbrola = NULL;
 	return again;
 }
 
-
 int MbrolaFill(int length, int resume, int amplitude)
 {
 // Read audio data from Mbrola (length is in millisecs)
 	return n_samples ? 1 : 0;
 }
 
-
 void MbrolaReset(void)
 {
 // Reset the Mbrola engine and flush the pending audio
 {
 }
 
-
 #endif  // INCLUDE_MBROLA

src/libespeak-ng/synthdata.c

 #include <stdint.h>
 #endif
 
-
 #include "speak_lib.h"
 #include "speech.h"
 #include "phoneme.h"
 
 int FormantTransition2(frameref_t *seq, int *n_frames, unsigned int data1, unsigned int data2, PHONEME_TAB *other_ph, int which);
 
-
-
 static char *ReadPhFile(void *ptr, const char *fname, int *size)
 {
 	FILE *f_in;
 	return p;
 }
 
-
 int LoadPhData(int *srate)
 {
 	int ix;
 	return result;
 }
 
-
 void FreePhData(void)
 {
 	Free(phoneme_tab_data);
 	tunes = NULL;
 }
 
-
 int PhonemeCode(unsigned int mnem)
 {
 	int ix;
 	return 0;
 }
 
-
 int LookupPhonemeString(const char *string)
 {
 	int ix;
 	return PhonemeCode(mnem);
 }
 
-
-
-
 frameref_t *LookupSpect(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params,  int *n_frames, PHONEME_LIST *plist)
 {
 	int ix;
 	seqk = (SPECT_SEQK *)seq;
 	nf = seq->n_frames;
 
-
 	if (nf >= N_SEQ_FRAMES)
 		nf = N_SEQ_FRAMES - 1;
 
 	return frames;
 }
 
-
-
 unsigned char *GetEnvelope(int index)
 {
 	if (index == 0) {
 	return (unsigned char *)&phondata_ptr[index];
 }
 
-
 static void SetUpPhonemeTable(int number, int recursing)
 {
 	int ix;
 	}
 }
 
-
 void SelectPhonemeTable(int number)
 {
 	n_phoneme_tab = 0;
 	current_phoneme_table = number;
 }
 
-
 int LookupPhonemeTable(const char *name)
 {
 	int ix;
 	return ix;
 }
 
-
 int SelectPhonemeTableName(const char *name)
 {
 // Look up a phoneme set by name, and select it if it exists
 	return ix;
 }
 
-
-
-
 void LoadConfig(void)
 {
 // Load configuration file, if one exists
 	fclose(f);
 }
 
-
-
-
 PHONEME_DATA this_ph_data;
 
-
 static void InvalidInstn(PHONEME_TAB *ph, int instn)
 {
 	fprintf(stderr, "Invalid instruction %.4x for phoneme '%s'\n", instn, WordToString(ph->mnemonic));
 }
 
-
 static bool StressCondition(Translator *tr, PHONEME_LIST *plist, int condition, int control)
 {
 // condition:
 
 }
 
-
 static int CountVowelPosition(PHONEME_LIST *plist)
 {
 	int count = 0;
 	return count;
 }
 
-
 static bool InterpretCondition(Translator *tr, int control, PHONEME_LIST *plist, USHORT *p_prog, WORD_PH_DATA *worddata)
 {
 	int which;
 				return false;
 		}
 
-
 		switch (which)
 		{
 		case 0:  // prevPh
 			plist--;
 			check_endtype = 1;
 			break;
-
 		case 1:  // thisPh
 			break;
-
 		case 2:  // nextPh
 		case 4:  // nextPhW
 			plist++;
 			break;
-
 		case 3:  // next2Ph
 		case 6:  // next2PhW
 			plist += 2;
 			break;
-
 		case 7:
 			// nextVowel, not word boundary
 			for (which = 1;; which++) {
 				}
 			}
 			break;
-
 		case 8:  // prevVowel in this word
 			if ((worddata == NULL) || (worddata->prev_vowel.ph == NULL))
 				return false;   // no previous vowel
 			plist = &(worddata->prev_vowel);
 			check_endtype = 1;
 			break;
-
 		case 9:  // next3PhW
 			for (ix = 1; ix <= 3; ix++) {
 				if (plist[ix].sourceix)
 			}
 			plist = &plist[3];
 			break;
-
 		case 10: // prev2PhW
 			if ((plist[0].sourceix) || (plist[-1].sourceix))
 				return false;
 			// phoneme type, vowel, nasal, fricative, etc
 			return ph->type == data;
 			break;
-
 		case 0x20:
 			// place of articulation
 			return ((ph->phflags >> 16) & 0xf) == data;
 			break;
-
 		case 0x40:
 			// is a bit set in phoneme flags
 			return (ph->phflags & (1 << data)) != 0;
 			break;
-
 		case 0x80:
 			switch (data)
 			{
 			case 3:
 			case 4:
 				return StressCondition(tr, plist, data, 0);
-
 			case 5:  // isBreak, Either pause phoneme, or (stop/vstop/vfric not followed by vowel or (liquid in same word))
 				return (ph->type == phPAUSE) || (plist_this->synthflags & SFLAG_NEXT_PAUSE);
-
 			case 6:  // isWordStart
 				return plist->sourceix != 0;
-
 			case 7:  // notWordStart
 				return plist->sourceix == 0;
-
 			case 8:  // isWordEnd
 				return plist[1].sourceix || (plist[1].ph->type == phPAUSE);
 				break;
-
 			case 9:  // isAfterStress
 				if (plist->sourceix != 0)
 					return false;
 
 				} while (plist->sourceix == 0);
 				break;
-
 			case 10:  // isNotVowel
 				return ph->type != phVOWEL;
-
 			case 11:  // isFinalVowel
 				for (;;) {
 					plist++;
 						return false;
 				}
 				break;
-
 			case 12:  // isVoiced
 				return (ph->type == phVOWEL) || (ph->type == phLIQUID) || (ph->phflags & phVOICED);
-
 			case 13:  // isFirstVowel
 				return CountVowelPosition(plist) == 1;
-
 			case 14:  // isSecondVowel
 				return CountVowelPosition(plist) == 2;
-
 			case 15:  // isSeqFlag1
 				// is this preceded  by a sequence if 1 or more vowels which have 'flag1' ?  (lang=hi)
 				if (plist->sourceix != 0)
 						break;
 				}
 				return count > 0;
-
 			case 0x10:  //  isTranslationGiven
 				return (plist->synthflags & SFLAG_DICTIONARY) != 0;
 			}
 	return false;
 }
 
-
 static void SwitchOnVowelType(PHONEME_LIST *plist, PHONEME_DATA *phdata, USHORT **p_prog, int instn_type)
 {
 	USHORT *prog;
 	*p_prog += 12;
 }
 
-
 int NumInstnWords(USHORT *prog)
 {
 	int instn;
 			return n+1;
 		}
 		return 1;
-
 	case 6:
 		type2 = (instn & 0xf00) >> 9;
 		if ((type2 == 5) || (type2 == 6))
 			return 12;  // switch on vowel type
 		return 1;
-
 	case 2:
 	case 3:
 		// a condition, check for a 2-word instruction
 		if (((n = instn & 0x0f00) == 0x600) || (n == 0x0d00))
 			return 2;
 		return 1;
-
 	default:
 		// instn_type 11 to 15, 2 words
 		instn2 = prog[2];
 	}
 }
 
-
-
 void InterpretPhoneme(Translator *tr, int control, PHONEME_LIST *plist, PHONEME_DATA *phdata, WORD_PH_DATA *worddata)
 {
 // control:
 			} else
 				InvalidInstn(ph, instn);
 			break;
-
 		case 1:
 			if (tr == NULL)
 				break;   // ignore if in synthesis stage
 				}
 			}
 			break;
-
 		case 2:
 		case 3:
 			// conditions
 			}
 			prog--;
 			break;
-
 		case 6:
 			// JUMP
 			switch (instn2 >> 1)
 				break;
 			}
 			break;
-
 		case 9:
 			data = ((instn & 0xf) << 16) + prog[1];
 			prog++;
 					prog = &phoneme_index[data] - 1;
 				}
 				break;
-
 			case 2:
 				// pitch envelope
 				phdata->pitch_env = data;
 				break;
-
 			case 3:
 				// amplitude envelope
 				phdata->amp_env = data;
 				break;
 			}
 			break;
-
 		case 10:   //  Vowelin, Vowelout
 			if (instn2 == 1)
 				ix = 0;
 			phdata->vowel_transition[ix+1] = (prog[2] << 16) + prog[3];
 			prog += 3;
 			break;
-
 		case 11:   // FMT
 		case 12:   // WAV
 		case 13:   // VowelStart
 				}
 			}
 			break;
-
 		default:
 			InvalidInstn(ph, instn);
 			break;
 	}
 }
 
-
 void InterpretPhoneme2(int phcode, PHONEME_DATA *phdata)
 {
 // Examine the program of a single isolated phoneme

src/libespeak-ng/synthesize.c

 #include "voice.h"
 #include "translate.h"
 
-
 extern FILE *f_log;
 static void SmoothSpect(void);
 
-
 // list of phonemes in a clause
 int n_phoneme_list = 0;
 PHONEME_LIST phoneme_list[N_PHONEME_LIST+1];
 
 #define VOWEL_FRONT_LENGTH  50
 
-
-
 // a dummy phoneme_list entry which looks like a pause
 static PHONEME_LIST next_pause;
 
-
 const char *WordToString(unsigned int word)
 {
 // Convert a phoneme mnemonic word into a string
 	return buf;
 }
 
-
-
 void SynthesizeInit()
 {
 	last_pitch_cmd = 0;
 	next_pause.newword = 0;
 }
 
-
-
 static void EndAmplitude(void)
 {
 	if (amp_length > 0) {
 	}
 }
 
-
-
 static void EndPitch(int voice_break)
 {
 	// posssible end of pitch envelope, fill in the length
 	}
 }
 
-
-
 static void DoAmplitude(int amp, unsigned char *amp_env)
 {
 	intptr_t *q;
 	WcmdqInc();
 }
 
-
-
 static void DoPitch(unsigned char *env, int pitch1, int pitch2)
 {
 	intptr_t *q;
 	WcmdqInc();
 }
 
-
-
 int PauseLength(int pause, int control)
 {
 	unsigned int len;
 	return len;
 }
 
-
 static void DoPause(int length, int control)
 {
 // length in nominal mS
 	}
 }
 
-
 extern int seq_len_adjust;   // temporary fix to advance the start point for playing the wav sample
 
-
 static int DoSample2(int index, int which, int std_length, int control, int length_mod, int amp)
 {
 	int length;
 	q[3] = wav_scale + (amp << 8);
 	WcmdqInc();
 
-
 	while (length > len4*3) {
 		x = len4;
 		if (wav_scale == 0)
 	return length;
 }
 
-
-
 int DoSample3(PHONEME_DATA *phdata, int length_mod, int amp)
 {
 	int amp2;
 	return len;
 }
 
-
-
-
 static frame_t *AllocFrame()
 {
 	// Allocate a temporary spectrum frame for the wavegen queue. Use a pool which is big
 	return &frame_pool[ix];
 }
 
-
 static void set_frame_rms(frame_t *fr, int new_rms)
 {
 // Each frame includes its RMS amplitude value, so to set a new
 	}
 }
 
-
-
 static void formants_reduce_hf(frame_t *fr, int level)
 {
 //  change height of peaks 2 to 8, percentage
 	}
 }
 
-
 static frame_t *CopyFrame(frame_t *frame1, int copy)
 {
 //  create a copy of the specified frame in temporary buffer
 	return frame2;
 }
 
-
 static frame_t *DuplicateLastFrame(frameref_t *seq, int n_frames, int length)
 {
 	frame_t *fr;
 	return fr;
 }
 
-
 static void AdjustFormants(frame_t *fr, int target, int min, int max, int f1_adj, int f3_adj, int hf_reduce, int flags)
 {
 	int x;
 	formants_reduce_hf(fr, hf_reduce);
 }
 
-
 static int VowelCloseness(frame_t *fr)
 {
 // return a value 0-3 depending on the vowel's f1
 	return 0;
 }
 
-
 int FormantTransition2(frameref_t *seq, int *n_frames, unsigned int data1, unsigned int data2, PHONEME_TAB *other_ph, int which)
 {
 	int ix;
 	return 0;
 }
 
-
-
 static void SmoothSpect(void)
 {
 	// Limit the rate of frequence change of formants, to reduce chirping
 			break;
 
 		if (q[0] <= WCMD_SPECT2) {
-
 			len = q[1] & 0xffff;
 
 			frame1 = (frame_t *)q[2];
 	syllable_start = syllable_end;
 }
 
-
 static void StartSyllable(void)
 {
 	// start of syllable, if not already started
 		syllable_end = wcmdq_tail;
 }
 
-
-
 int DoSpect2(PHONEME_TAB *this_ph, int which, FMT_PARAMS *fmt_params,  PHONEME_LIST *plist, int modulation)
 {
 	// which:  0 not a vowel, 1  start of vowel,   2 body and end of vowel
 		WcmdqInc();
 	}
 
-
 	return total_len;
 }
 
-
-
-
 void DoMarker(int type, int char_posn, int length, int value)
 {
 // This could be used to return an index to the word currently being spoken
 	}
 }
 
-
 void DoPhonemeMarker(int type, int char_posn, int length, char *name)
 {
 // This could be used to return an index to the word currently being spoken
 	}
 }
 
-
 #if HAVE_SONIC_H
 void DoSonicSpeed(int value)
 {
 }
 #endif
 
-
 void DoVoiceChange(voice_t *v)
 {
 // allocate memory for a copy of the voice data, and free it in wavegenfill()
 	WcmdqInc();
 }
 
-
 void DoEmbedded(int *embix, int sourceix)
 {
 	// There were embedded commands in the text at this point
 			SetEmbedded((command & 0x60) + EMBED_S2, value);   // adjusts embedded_value[EMBED_S2]
 			SetSpeed(2);
 			break;
-
 		case EMBED_I:   // play dynamically loaded wav data (sound icon)
 			if ((int)value < n_soundicon_tab) {
 				if (soundicon_tab[value].length != 0) {
 				}
 			}
 			break;
-
 		case EMBED_M:   // named marker
 			DoMarker(espeakEVENT_MARK, (sourceix & 0x7ff) + clause_start_char, 0, value);
 			break;
-
 		case EMBED_U:   // play sound
 			DoMarker(espeakEVENT_PLAY, count_characters+1, 0, value);  // always occurs at end of clause
 			break;
-
 		default:
 			DoPause(10, 0);   // ensure a break in the speech
 			wcmdq[wcmdq_tail][0] = WCMD_EMBEDDED;
 	} while ((word & 0x80) == 0);
 }
 
-
-
 int Generate(PHONEME_LIST *phoneme_list, int *n_ph, int resume)
 {
 	static int ix;
 			DoPause(p->length, 0);
 			p->std_length = p->ph->std_length;
 			break;
-
 		case phSTOP:
 			released = 0;
 			ph = p->ph;
 			phdata.pd_control |= pd_DONTLENGTHEN;
 			DoSample3(&phdata, 0, 0);
 			break;
-
 		case phFRICATIVE:
 			InterpretPhoneme(NULL, 0, p, &phdata, &worddata);
 
 				DoSample3(&phdata, p->length, 0);  // play it twice for [s:] etc.
 			DoSample3(&phdata, p->length, 0);
 			break;
-
 		case phVSTOP:
 			ph = p->ph;
 			memset(&fmtp, 0, sizeof(fmtp));
 					DoPause(12, 0);
 			}
 			break;
-
 		case phVFRICATIVE:
 			if (next->type == phVOWEL) {
 				DoAmplitude(p->amp, NULL);
 				DoSpect2(p->ph, 0, &fmtp, p, 0);
 			DoSpect2(p->ph, 0, &fmtp, p, 0);
 			break;
-
 		case phNASAL:
 			memset(&fmtp, 0, sizeof(fmtp));
 			if (!(p->synthflags & SFLAG_SEQCONTINUE)) {
 			}
 
 			break;
-
 		case phLIQUID:
 			memset(&fmtp, 0, sizeof(fmtp));
 			modulation = 0;
 			fmtp.wav_addr = phdata.sound_addr[pd_ADDWAV];
 			fmtp.wav_amp = phdata.sound_param[pd_ADDWAV];
 			DoSpect2(p->ph, 0, &fmtp, p, modulation);
-
 			break;
-
 		case phVOWEL:
 			ph = p->ph;
 			stress = p->stresslevel & 0xf;
 			}
 
 			DoSpect2(ph, 2, &fmtp, p, modulation);
-
 			break;
 		}
 		ix++;
 	return 0;  // finished the phoneme list
 }
 
-
-
-
 static int timer_on = 0;
 static int paused = 0;
 
 	return 0;
 }
 
-
 int SynthStatus()
 {
 	return timer_on | paused;
 }
 
-
-
 int SpeakNextClause(FILE *f_in, const void *text_in, int control)
 {
 // Speak text from file (f_in) or memory (text_in)

src/libespeak-ng/tr_languages.c

 #include "synthesize.h"
 #include "translate.h"
 
-
-
 #define L_qa   0x716100
 #define L_grc  0x677263   // grc  Ancient Greek
 #define L_jbo  0x6a626f   // jbo  Lojban
 #define OFFSET_KOREAN   0x1100
 #define OFFSET_ETHIOPIC 0x1200
 
-
 // character ranges must be listed in ascending unicode order
 ALPHABET alphabets[] = {
 	{ "_el",    OFFSET_GREEK,    0x380, 0x3ff,  L('e', 'l'), AL_DONT_NAME | AL_NOT_LETTERS | AL_WORDS },
 	{ NULL, 0, 0, 0, 0, 0 }
 };
 
-
 ALPHABET *AlphabetFromName(const char *name)
 {
 	ALPHABET *alphabet;
 	return NULL;
 }
 
-
 ALPHABET *AlphabetFromChar(int c)
 {
 	// Find the alphabet from a character.
 	return NULL;
 }
 
-
-
 static void Translator_Russian(Translator *tr);
 
-
-
 static void SetLetterVowel(Translator *tr, int c)
 {
 	tr->letter_bits[c] = (tr->letter_bits[c] & 0x40) | 0x81;  // keep value for group 6 (front vowels e,i,y)
 
 const char string_ordinal[] = { 0xc2, 0xba, 0 };  // masculine ordinal character, UTF-8
 
-
 static Translator *NewTranslator(void)
 {
 	Translator *tr;
 	SetLetterBits(tr, 6, "eiy");   // Letter group Y, front vowels
 	SetLetterBits(tr, 7, "aeiouy");  // vowels, including y
 
-
 	tr->char_plus_apostrophe = empty_wstring;
 	tr->punct_within_word = punct_in_word;
 	tr->chars_ignore = chars_ignore_default;
 	0x7fff
 };
 
-
-
 static const unsigned int replace_cyrillic_latin[] =
 { 0x430, 'a',
   0x431, 'b',
   0x45c, 0x107,
   0 }; // ѓ  ѕ  ќ
 
-
 static const unsigned char ru_vowels[] = { 0x10, 0x15, 0x31, 0x18, 0x1e, 0x23, 0x2b, 0x2d, 0x2e, 0x2f,  0xb9, 0xc9, 0x91, 0x8f, 0x36, 0 };  // also kazakh
 static const unsigned char ru_consonants[] = { 0x11, 0x12, 0x13, 0x14, 0x16, 0x17, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1f, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2c, 0x73, 0x7b, 0x83, 0x9b, 0 };
 
 	SetLetterBits(tr, LETTERGP_VOWEL2, (char *)ru_vowels);
 }
 
-
 void SetIndicLetters(Translator *tr)
 {
 	// Set letter types for Indic scripts, Devanagari, Tamill, etc
 	tr->langopts.suffix_add_e = tr->letter_bits_offset + 0x4d;   // virama
 }
 
-
 void SetupTranslator(Translator *tr, const short *lengths, const unsigned char *amps)
 {
 	if (lengths != NULL)
 		memcpy(tr->stress_amps, amps, sizeof(tr->stress_amps));
 }
 
-
 Translator *SelectTranslator(const char *name)
 {
 	int name2 = 0;
 		tr->langopts.numbers = NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_SINGLE_AND | NUM_ROMAN | NUM_1900;
 		tr->langopts.accents = 1;
 	}
-	break;
-
+		break;
 	case L('a', 'm'):  // Amharic, Ethiopia
 	{
 		SetupTranslator(tr, stress_lengths_fr, stress_amps_fr);
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1;       // disable check for unpronouncable words
 		tr->langopts.numbers = NUM_OMIT_1_HUNDRED;
 	}
-	break;
-
-
-
-
+		break;
 	case L('a', 'r'):   // Arabic
 		tr->transpose_min = 0x620;      // for ar_list, use 6-bit character codes
 		tr->transpose_max = 0x65f;
 		tr->langopts.numbers = NUM_SWAP_TENS | NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_AND_HUNDRED | NUM_THOUSAND_AND | NUM_OMIT_1_THOUSAND;
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1;       // disable check for unpronouncable words
 		break;
-
 	case L('b', 'g'):  // Bulgarian
 	{
 		SetCyrillicLetters(tr);
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_SINGLE_AND | NUM_ROMAN | NUM_ROMAN_ORDINAL | NUM_ROMAN_CAPITALS;
 		tr->langopts.thousands_sep = ' ';       // don't allow dot as thousands separator
 	}
-	break;
-
+		break;
 	case L('b', 'n'):  // Bengali
 	case L('a', 's'):  // Assamese
 	case L_mni:  // Manipuri  (temporary placement - it's not indo-european)
 		}
 
 	}
-	break;
-
+		break;
 	case L('b', 'o'):  // Tibet
 	{
 		tr->langopts.stress_rule = STRESSPOSN_1L;
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1;       // disable check for unpronouncable words
 		tr->langopts.numbers = 1;
 	}
-	break;
-
+		break;
 	case L('c', 'y'):   // Welsh
 	{
 		static const short stress_lengths_cy[8] = { 170, 220, 180, 180, 0, 0, 250, 270 };
 		SetLetterVowel(tr, 'w');      // add letter to vowels and remove from consonants
 		SetLetterVowel(tr, 'y');
 	}
-	break;
-
+		break;
 	case L('d', 'a'):  // Danish
 	{
 		static const short stress_lengths_da[8] = { 160, 140, 200, 200, 0, 0, 220, 230 };
 		SetLetterVowel(tr, 'y');
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_ORDINAL_DOT | NUM_1900 | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_ORDINAL;
 	}
-	break;
-
-
+		break;
 	case L('d', 'e'):
 	{
 		static const short stress_lengths_de[8] = { 150, 130, 200, 200,  0, 0, 270, 270 };
 		SetLetterVowel(tr, 'y');
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2;       // use de_rules for unpronouncable rules
 	}
-	break;
-
+		break;
 	case L('d', 'v'):   // Divehi (Maldives)
 	{
 		SetupTranslator(tr, stress_lengths_ta, stress_amps_ta);
 		tr->langopts.break_numbers = 0x14a8;      // 1000, 100,000  10,000,000
 		tr->langopts.numbers = 1;
 	}
-	break;
-
+		break;
 	case L('e', 'n'):
 	{
 		static const short stress_lengths_en[8] = { 182, 140, 220, 220, 0, 0, 248, 275 };
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2;       // use en_rules for unpronouncable rules
 		SetLetterBits(tr, 6, "aeiouy");      // Group Y: vowels, including y
 	}
-	break;
-
+		break;
 	case L('e', 'l'):   // Greek
 	case L_grc:        // Ancient Greek
 	{
 			tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1;
 		}
 	}
-	break;
-
+		break;
 	case L('e', 'o'):
 	{
 		static const short stress_lengths_eo[8] = { 150, 140,  180, 180,    0,   0,  200, 200 };
 
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_ALLOW_SPACE | NUM_ROMAN;
 	}
-	break;
-
+		break;
 	case L('e', 's'):   // Spanish
 	case L('a', 'n'):   // Aragonese
 	case L('c', 'a'):   // Catalan
 		} else
 			tr->langopts.param[LOPT_UNPRONOUNCABLE] = 2;       // use es_rules for unpronouncable rules
 	}
-	break;
-
+		break;
 	case L('e', 'u'):  // basque
 	{
 		static const short stress_lengths_eu[8] = { 200, 200,  200, 200,  0, 0,  210, 230 };      // very weak stress
 		tr->langopts.param[LOPT_SUFFIX] = 1;
 		tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_VIGESIMAL;
 	}
-	break;
-
-
+		break;
 	case L('f', 'a'):   // Farsi
 	{
 		// Convert characters in the range 0x620 to 0x6cc to the range 1 to 63.
 
 		tr->chars_ignore = chars_ignore_zwnj_hyphen;       // replace ZWNJ by hyphen
 	}
-	break;
-
-
+		break;
 	case L('e', 't'):   // Estonian
 		tr->charset_a0 = charsets[4];       // ISO-8859-4
-	// drop through to Finnish
+		// drop through to Finnish
 	case L('f', 'i'):   // Finnish
 	{
 		static const unsigned char stress_amps_fi[8] = { 18, 16, 22, 22, 20, 22, 22, 22 };
 		tr->langopts.spelling_stress = 1;
 		tr->langopts.intonation_group = 3;      // less intonation, don't raise pitch at comma
 	}
-	break;
-
+		break;
 	case L('f', 'r'):  // french
 	{
 		SetupTranslator(tr, stress_lengths_fr, stress_amps_fr);
 		tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED | NUM_NOPAUSE | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_AFTER | NUM_VIGESIMAL | NUM_DFRACTION_4;
 		SetLetterVowel(tr, 'y');
 	}
-	break;
-
+		break;
 	case L('g', 'a'):   // irish
 	case L('g', 'd'):   // scots gaelic
 	{
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 3;      // don't count apostrophe
 		tr->langopts.param[LOPT_IT_LENGTHEN] = 1;        // remove [:] phoneme from non-stressed syllables (Lang=gd)
 	}
-	break;
-
+		break;
 	case L('h', 'i'):    // Hindi
 	case L('n', 'e'):    // Nepali
 	case L('o', 'r'):    // Oriya
 			tr->letter_bits_offset = OFFSET_ORIYA;
 		SetIndicLetters(tr);
 	}
-	break;
-
-
+		break;
 	case L('h', 'r'):   // Croatian
 	case L('b', 's'):   // Bosnian
 	case L('s', 'r'):   // Serbian
 		SetLetterVowel(tr, 'y');
 		SetLetterVowel(tr, 'r');
 	}
-	break;
-
-
+		break;
 	case L('h', 't'):  // Haitian Creole
 		tr->langopts.stress_rule = STRESSPOSN_1R;          // stress on final syllable
 		tr->langopts.stress_flags = S_NO_AUTO_2 | S_FINAL_DIM;      // don't use secondary stress
 		tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_OMIT_1_HUNDRED | NUM_NOPAUSE | NUM_ROMAN | NUM_VIGESIMAL | NUM_DFRACTION_4;
 		break;
-
-
 	case L('h', 'u'):   // Hungarian
 	{
 		static const unsigned char stress_amps_hu[8] = { 17, 17, 19, 19, 20, 22, 22, 21 };
 		tr->langopts.spelling_stress = 1;
 		SetLengthMods(tr, 3); // all equal
 	}
-	break;
-
+		break;
 	case L('h', 'y'):   // Armenian
 	{
 		static const short stress_lengths_hy[8] = { 250, 200,  250, 250,  0, 0,  250, 250 };
 		tr->langopts.max_initial_consonants = 6;
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_OMIT_1_HUNDRED;
 	}
-	break;
-
+		break;
 	case L('i', 'd'):   // Indonesian
 	case L('m', 's'):   // Malay
 	{
 		tr->langopts.stress_flags =  S_FINAL_DIM_ONLY | S_FINAL_NO_2;
 		tr->langopts.accents = 2;      // "capital" after letter name
 	}
-	break;
-
+		break;
 	case L('i', 's'):   // Icelandic
 	{
 		static const short stress_lengths_is[8] = { 180, 160, 200, 200, 0, 0, 240, 250 };
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SINGLE_AND | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_1900;
 		tr->langopts.numbers2 = 0x2;
 	}
-	break;
-
+		break;
 	case L('i', 't'):   // Italian
 	{
 		static const short stress_lengths_it[8] =
 		tr->langopts.accents = 2;       // Say "Capital" after the letter.
 		SetLetterVowel(tr, 'y');
 	}
-	break;
-
+		break;
 	case L_jbo:   // Lojban
 	{
 		static const short stress_lengths_jbo[8] = { 145, 145, 170, 160, 0, 0, 330, 350 };
 		SetLetterVowel(tr, 'y');
 		tr->langopts.max_lengthmod = 368;
 	}
-	break;
-
+		break;
 	case L('k', 'a'):   // Georgian
 	{
 		// character codes offset by 0x1080
 		tr->langopts.alt_alphabet = OFFSET_CYRILLIC;
 		tr->langopts.alt_alphabet_lang = L('r', 'u');
 	}
-	break;
-
+		break;
 	case L('k', 'k'):   // Kazakh
 	{
 		static const unsigned char stress_amps_tr[8] = { 18, 16, 20, 21, 20, 21, 21, 20 };
 		tr->langopts.max_initial_consonants = 2;
 		SetLengthMods(tr, 3); // all equal
 	}
-	break;
-
+		break;
 	case L('k', 'l'):   // Greenlandic
 	{
 		SetupTranslator(tr, stress_lengths_equal, stress_amps_equal);
 		tr->langopts.stress_flags = S_NO_AUTO_2;
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_SWAP_TENS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_ORDINAL_DOT | NUM_1900 | NUM_ROMAN | NUM_ROMAN_CAPITALS | NUM_ROMAN_ORDINAL;
 	}
-	break;
-
+		break;
 	case L('k', 'o'):   // Korean, TEST
 	{
 		static const char ko_ivowels[] = { 0x63, 0x64, 0x67, 0x68, 0x6d, 0x72, 0x74, 0x75, 0 };      // y and i vowels
 		tr->langopts.break_numbers = 0x1111110;
 		tr->langopts.max_digits = 20;
 	}
-	break;
-
+		break;
 	case L('k', 'u'):   // Kurdish
 	{
 		static const unsigned char stress_amps_ku[8] = { 18, 18, 20, 20, 20, 22, 22, 21 };
 		tr->langopts.numbers = NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_OMIT_1_HUNDRED | NUM_AND_HUNDRED;
 		tr->langopts.max_initial_consonants = 2;
 	}
-	break;
-
+		break;
 	case L('l', 'a'):  // Latin
 	{
 		tr->charset_a0 = charsets[4];       // ISO-8859-4, includes a,e,i,o,u-macron
 		tr->langopts.numbers = NUM_ROMAN;
 		tr->langopts.max_roman = 5000;
 	}
-	break;
-
+		break;
 	case L('l', 't'): // Lithuanian
 	{
 		tr->charset_a0 = charsets[4];     // ISO-8859-4
 		tr->langopts.numbers2 = NUM2_THOUSANDS_VAR4;
 		tr->langopts.max_roman = 5000;
 	}
-	break;
-
+		break;
 	case L('l', 'v'):  // latvian
 	{
 		static const unsigned char stress_amps_lv[8] = { 17, 13, 20, 20, 20, 22, 22, 21 };
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_DFRACTION_4 | NUM_ORDINAL_DOT;
 		tr->langopts.stress_flags = S_FINAL_DIM_ONLY | S_FINAL_NO_2 | S_EO_CLAUSE1;
 	}
-	break;
-
+		break;
 	case L('m', 'k'):   // Macedonian
 	{
 		static wchar_t vowels_cyrillic[] = { 0x440,      // also include 'р' [R]
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_AND_UNITS | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_2;
 		tr->langopts.numbers2 = 0x8a;      // variant numbers before thousands,milliards
 	}
-	break;
-
+		break;
 	case L('m', 't'):  // Maltese
 	{
 		tr->charset_a0 = charsets[3];       // ISO-8859-3
 		tr->langopts.stress_rule = STRESSPOSN_2R;       // penultimate
 		tr->langopts.numbers = 1;
 	}
-	break;
-
+		break;
 	case L('n', 'l'):  // Dutch
 	{
 		static const short stress_lengths_nl[8] = { 160, 135, 210, 210,  0, 0, 260, 280 };
 		tr->langopts.stress_flags = S_FIRST_PRIMARY;
 		memcpy(tr->stress_lengths, stress_lengths_nl, sizeof(tr->stress_lengths));
 	}
-	break;
-
+		break;
 	case L('n', 'o'):  // Norwegian
 	{
 		static const short stress_lengths_no[8] = { 160, 140, 200, 200, 0, 0, 220, 230 };
 		SetLetterVowel(tr, 'y');
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_ALLOW_SPACE | NUM_1900 | NUM_ORDINAL_DOT;
 	}
-	break;
-
+		break;
 	case L('o', 'm'): // Oromo
 	{
 		static const unsigned char stress_amps_om[] = { 18, 15, 20, 20, 20, 22, 22, 22 };
 		tr->langopts.numbers = NUM_OMIT_1_HUNDRED | NUM_HUNDRED_AND;
 		tr->langopts.numbers2 = 0x200;      // say "thousands" before its number
 	}
-	break;
-
+		break;
 	case L('p', 'l'):   // Polish
 	{
 		static const short stress_lengths_pl[8] = { 160, 190,  175, 175,  0, 0,  200, 210 };
 		tr->langopts.param[LOPT_COMBINE_WORDS] = 4 + 0x100;      // combine 'nie' (marked with $alt2) with some 1-syllable (and 2-syllable) words (marked with $alt)
 		SetLetterVowel(tr, 'y');
 	}
-	break;
-
+		break;
 	case L('p', 't'):  // Portuguese
 	{
 		static const short stress_lengths_pt[8] = { 170, 115,  210, 240,  0, 0,  260, 280 };
 		tr->langopts.param[LOPT_ALT] = 2;          // call ApplySpecialAttributes2() if a word has $alt or $alt2
 		tr->langopts.accents = 2;      // 'capital' after letter name
 	}
-	break;
-
+		break;
 	case L('r', 'o'):  // Romanian
 	{
 		static const short stress_lengths_ro[8] = { 170, 170,  180, 180,  0, 0,  240, 260 };
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_DFRACTION_3 | NUM_AND_UNITS | NUM_ROMAN;
 		tr->langopts.numbers2 = 0x1e;      // variant numbers before all thousandplex
 	}
-	break;
-
+		break;
 	case L('r', 'u'):  // Russian
 		Translator_Russian(tr);
 		break;
-
 	case L('r', 'w'):   // Kiryarwanda
 	{
 		tr->langopts.stress_rule = STRESSPOSN_2R;
 		tr->langopts.numbers = NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_DFRACTION_2 | NUM_AND_HUNDRED;
 		tr->langopts.numbers2 = 0x200;      // say "thousands" before its number
 	}
-	break;
-
+		break;
 	case L('s', 'k'):   // Slovak
 	case L('c', 's'):   // Czech
 	{
 		ResetLetterBits(tr, 0x20);
 		SetLetterBits(tr, 5, sk_voiced);
 	}
-	break;
-
+		break;
 	case L('s', 'i'):  // Sinhala
 	{
 		SetupTranslator(tr, stress_lengths_ta, stress_amps_ta);
 		tr->langopts.numbers2 =  NUM2_PERCENT_BEFORE;
 		tr->langopts.break_numbers = 0x14aa8;      // for languages which have numbers for 100,000 and 100,00,000, eg Hindi
 	}
-	break;
-
+		break;
 	case L('s', 'l'):  // Slovenian
 		tr->charset_a0 = charsets[2];       // ISO-8859-2
 		tr->langopts.stress_rule = STRESSPOSN_2R;       // Temporary
 		tr->langopts.thousands_sep = ' ';       // don't allow dot as thousands separator
 		tr->langopts.replace_chars = replace_cyrillic_latin;
 		break;
-
 	case L('s', 'q'):  // Albanian
 	{
 		static const short stress_lengths_sq[8] = { 150, 150,  180, 180,  0, 0,  300, 300 };
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND | NUM_AND_UNITS | NUM_DFRACTION_4;
 		tr->langopts.accents = 2;      // "capital" after letter name
 	}
-	break;
-
-
+		break;
 	case L('s', 'v'):  // Swedish
 	{
 		static const unsigned char stress_amps_sv[] = { 16, 16, 20, 20, 20, 22, 22, 21 };
 		tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_ALLOW_SPACE | NUM_1900;
 		tr->langopts.accents = 1;
 	}
-	break;
-
+		break;
 	case L('s', 'w'):  // Swahili
 	case L('t', 'n'):  // Setswana
 	{
 		tr->langopts.numbers = NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_SINGLE_AND | NUM_OMIT_1_HUNDRED;
 		tr->langopts.break_numbers = 0x49249268;      // for languages which have numbers for 100,000 and 1,000,000
 	}
-	break;
-
+		break;
 	case L('t', 'a'):  // Tamil
 	case L('k', 'n'):  // Kannada
 	case L('m', 'l'):  // Malayalam
 		SetIndicLetters(tr);       // call this after setting OFFSET_
 		SetLetterBitsRange(tr, LETTERGP_B, 0x4e, 0x4e);       // chillu-virama (unofficial)
 	}
-	break;
-
+		break;
 	case L('t', 'r'):   // Turkish
 	case L('a', 'z'):   // Azerbaijan
 	{
 			tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_2;
 		tr->langopts.max_initial_consonants = 2;
 	}
-	break;
-
+		break;
 	case L('t', 't'):   // Tatar
 	{
 		SetCyrillicLetters(tr);
 		tr->langopts.stress_flags = S_NO_AUTO_2;      // no automatic secondary stress
 		tr->langopts.numbers = NUM_SINGLE_STRESS | NUM_DECIMAL_COMMA | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_DFRACTION_4;
 	}
-	break;
-
+		break;
 	case L('u', 'k'):   // Ukrainian
 	{
 		SetCyrillicLetters(tr);
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 0x432;        // [v]  don't count this character at start of word
 	}
-	break;
-
+		break;
 	case L('u', 'r'):   // Urdu
 	case L('s', 'd'):   // Sindhi
 	{
 		tr->langopts.numbers = NUM_SWAP_TENS;
 		tr->langopts.break_numbers = 0x52a8;      // for languages which have numbers for 100,000 and 100,00,000, eg Hindi
 	}
-	break;
-
+		break;
 	case L('v', 'i'):  // Vietnamese
 	{
 		static const short stress_lengths_vi[8] = { 150, 150,  180, 180,  210, 230,  230, 240 };
 		tr->langopts.numbers = NUM_DECIMAL_COMMA | NUM_HUNDRED_AND_DIGIT | NUM_DFRACTION_4 | NUM_ZERO_HUNDRED;
 
 	}
-	break;
-
+		break;
 	case L('w', 'o'):
 		tr->langopts.stress_rule = STRESSPOSN_1L;
 		tr->langopts.numbers = NUM_AND_UNITS | NUM_HUNDRED_AND | NUM_OMIT_1_HUNDRED | NUM_OMIT_1_THOUSAND | NUM_SINGLE_STRESS;
 		break;
-
 	case L('z', 'h'):
 	case L_zhy:
 	{
 			tr->langopts.break_numbers = 0x00018;
 		}
 	}
-	break;
-
+		break;
 	default:
 		tr->langopts.param[LOPT_UNPRONOUNCABLE] = 1;   // disable check for unpronouncable words
 		break;
 	return tr;
 }
 
-
 void ProcessLanguageOptions(LANGUAGE_OPTIONS *langopts)
 {
 	if (langopts->numbers & NUM_DECIMAL_COMMA) {
 		langopts->thousands_sep = 0;   // don't allow thousands separator, except space
 }
 
-
 static void Translator_Russian(Translator *tr)
 {
 	static const unsigned char stress_amps_ru[] = { 16, 16, 18, 18, 20, 24, 24, 22 };
 	tr->langopts.numbers2 = 0x2 + NUM2_THOUSANDS_VAR1;  // variant numbers before thousands
 	tr->langopts.phoneme_change = 1;
 	tr->langopts.testing = 2;
-
 }

src/libespeak-ng/translate.c

 
 #define WORD_STRESS_CHAR   '*'
 
-
 Translator *translator = NULL;    // the main translator
 Translator *translator2 = NULL;   // secondary translator for certain words
 static char translator2_language[20] = { 0 };
 int pre_pause;
 ALPHABET *current_alphabet;
 
-
 // these were previously in translator class
 #ifdef PLATFORM_WINDOWS
 char word_phonemes[N_WORD_PHONEMES*2];    // longer, because snprint() is not available
 int n_ph_list2;
 PHONEME_LIST2 ph_list2[N_PHONEME_LIST]; // first stage of text->phonemes
 
-
-
 wchar_t option_punctlist[N_PUNCTLIST] = { 0 };
 char ctrl_embedded = '\001';    // to allow an alternative CTRL for embedded commands
 int option_multibyte = espeakCHARS_AUTO;   // 0=auto, 1=utf8, 2=8bit, 3=wchar, 4=16bit
 int n_replace_phonemes;
 REPLACE_PHONEMES replace_phonemes[N_REPLACE_PHONEMES];
 
-
 // brackets, also 0x2014 to 0x021f which don't need to be in this list
 static const unsigned short brackets[] = {
 	'(', ')', '[', ']', '{', '}', '<', '>', '"', '\'', '`',
 	110, 120, 100, 110, 110, 110, 110, 110, 110, 110
 };
 
-
 static unsigned char *length_mod_tabs[6] = {
 	length_mods_en,
 	length_mods_en,     // 1
 	length_mods_equal   // 5
 };
 
-
 void SetLengthMods(Translator *tr, int value)
 {
 	int value2;
 		tr->langopts.length_mods0 = length_mod_tabs[value2];
 }
 
-
-
 int IsAlpha(unsigned int c)
 {
 // Replacement for iswalph() which also checks for some in-word symbols
 	return iswspace(c);
 }
 
-
 void DeleteTranslator(Translator *tr)
 {
 	if (tr->data_dictlist != NULL)
 	Free(tr);
 }
 
-
 int lookupwchar(const unsigned short *list, int c)
 {
 // Is the character c in the list ?
 	return 0;
 }
 
-
 int lookupwchar2(const unsigned short *list, int c)
 {
 // Replace character c by another character.
 	return 0;
 }
 
-
 int IsBracket(int c)
 {
 	if ((c >= 0x2014) && (c <= 0x201f))
 	return lookupwchar(brackets, c);
 }
 
-
 int utf8_out(unsigned int c, char *buf)
 {
 // write a unicode character into a buffer as utf8
 	return n_bytes+1;
 }
 
-
 int utf8_nbytes(const char *buf)
 {
 // Returns the number of bytes for the first UTF-8 character in buf
 	return 4;
 }
 
-
 int utf8_in2(int *c, const char *buf, int backwards)
 {
 // Read a unicode characater from a UTF8 string
 	return n_bytes+1;
 }
 
-
 #pragma GCC visibility push(default)
 int utf8_in(int *c, const char *buf)
 {
 }
 #pragma GCC visibility pop
 
-
 char *strchr_w(const char *s, int c)
 {
 // return NULL for any non-ascii character
 	return strchr((char *)s, c);    // (char *) is needed for Borland compiler
 }
 
-
 int IsAllUpper(const char *word)
 {
 	int c;
 	return 1;
 }
 
-
 static char *SpeakIndividualLetters(Translator *tr, char *word, char *phonemes, int spell_word)
 {
 	int posn = 0;
 	return word;
 }
 
-
-
 static int CheckDottedAbbrev(char *word1, WORD_TAB *wtab)
 {
 	int wc;
 	return count;
 }
 
-
 extern char *phondata_ptr;
 
 int ChangeEquivalentPhonemes(Translator *tr, int lang2, char *phonemes)
 	return 1;
 }
 
-
-
-
 int TranslateWord(Translator *tr, char *word_start, int next_pause, WORD_TAB *wtab, char *word_out)
 {
 // word1 is terminated by space (0x20) character
 		if (!found)
 			found = LookupDictList(tr, &word1, phonemes, dictionary_flags, FLAG_ALLOW_TEXTMODE, wtab);   // the original word
 
-
 		if ((dictionary_flags[0] & (FLAG_ALLOW_DOT | FLAG_NEEDS_DOT)) && (wordx[1] == '.'))
 			wordx[1] = ' ';   // remove a Dot after this word
 
 			}
 		}
 
-
 		// if textmode, LookupDictList() replaces word1 by the new text and returns found=0
 
 		if (phonemes[0] == phonSWITCH) {
 				}
 			}
 
-
-
-
 			if ((end_type != 0) && !(end_type & SUFX_P)) {
 				end_type1 = end_type;
 				strcpy(phonemes2, phonemes);
 				memcpy(wordx, word_copy, strlen(word_copy));
 			}
 
-
-
-
 			wordx[-1] = c_temp;
 		}
 	}
 
 	wflags |= emphasize_allcaps;
 
-
 	/* determine stress pattern for this word */
 	/******************************************/
 	add_suffix_phonemes = 0;
 			ChangeWordStress(tr, word_phonemes, 3);
 	}
 
-
 	// dictionary flags for this word give a clue about which alternative pronunciations of
 	// following words to use.
 	if (end_type1 & SUFX_F) {
 	return dictionary_flags[0];
 }
 
-
-
 static void SetPlist2(PHONEME_LIST2 *p, unsigned char phcode)
 {
 	p->phcode = phcode;
 	return count;
 }
 
-
 void Word_EmbeddedCmd()
 {
 // Process embedded commands for emphasis, sayas, and break
 	} while (((embedded_cmd & 0x80) == 0) && (embedded_read < embedded_ix));
 }
 
-
 int SetTranslator2(const char *new_language)
 {
 // Set translator2 to a second language
 	return new_phoneme_tab;
 }
 
-
-
 static int TranslateWord2(Translator *tr, char *word, WORD_TAB *wtab, int pre_pause, int next_pause)
 {
 	int flags = 0;
 	return flags;
 }
 
-
-
 static int EmbeddedCommand(unsigned int *source_index_out)
 {
 	// An embedded command to change the pitch, volume, etc.
 	return 1;
 }
 
-
-
 static int SubstituteChar(Translator *tr, unsigned int c, unsigned int next_in, int *insert, int *wordflags)
 {
 	int ix;
 
 	*wordflags |= FLAG_CHAR_REPLACED;
 	return new_c;
-
 }
 
-
 static int TranslateChar(Translator *tr, char *ptr, int prev_in, unsigned int c, unsigned int next_in, int *insert, int *wordflags)
 {
 	// To allow language specific examination and replacement of characters
 	case L('n', 'l'):
 		// look for 'n  and replace by a special character (unicode: schwa)
 
-
 		if (!iswalpha2(prev_in)) {
 			utf8_in(&next2, &ptr[1]);
 
 	return SubstituteChar(tr, c, next_in, insert, wordflags);
 }
 
-
 static const char *UCase_ga[] = { "bp", "bhf", "dt", "gc", "hA", "mb", "nd", "ng", "ts", "tA", "nA", NULL };
 
 int UpperCaseInWord(Translator *tr, char *word, int c)
 	return 0;
 }
 
-
 void *TranslateClause(Translator *tr, FILE *f_text, const void *vp_input, int *tone_out, char **voice_change)
 {
 	int ix;
 	}
 	words[0].flags |= FLAG_FIRST_WORD;
 
-
 	for (ix = 0; ix < word_count; ix++) {
 		int nx;
 		int c_temp;
 		embedded_list[embedded_ix] = 0x80;
 	}
 
-
 	prev_clause_pause = clause_pause;
 
 	if (tone_out != NULL)
 	if (terminator & CLAUSE_BIT_SENTENCE)
 		new_sentence = 1;  // next clause is a new sentence
 
-
 	if (voice_change != NULL) {
 		// return new voice name if an embedded voice change command terminated the clause
 		if (terminator & CLAUSE_BIT_VOICE)
 		return (void *)p_textinput;
 }
 
-
-
-
-
 void InitText(int control)
 {
 	count_sentences = 0;

src/libespeak-ng/voices.c

 #include "voice.h"
 #include "translate.h"
 
-
 MNEM_TAB genders[] = {
 	{ "unknown", 0 },
 	{ "male", 1 },
 static int formant_rate_22050[9] = { 240, 170, 170, 170, 170, 170, 170, 170, 170 };  // values for 22kHz sample rate
 int formant_rate[9];         // values adjusted for actual sample rate
 
-
-
 #define DEFAULT_LANGUAGE_PRIORITY  5
 #define N_VOICES_LIST  250
 static int n_voices_list = 0;
 
 espeak_VOICE current_voice_selected;
 
-
 enum {
 	V_NAME = 1,
 	V_LANGUAGE,
 	V_CONSONANTS
 };
 
-
-
 static MNEM_TAB options_tab[] = {
 	{ "reduce_t",  LOPT_REDUCE_T },
 	{ "bracket", LOPT_BRACKET_PAUSE },
 	{ NULL,   0 }
 };
 
-
 #define N_VOICE_VARIANTS   12
 const char variants_either[N_VOICE_VARIANTS] = { 1, 2, 12, 3, 13, 4, 14, 5, 11, 0 };
 const char variants_male[N_VOICE_VARIANTS] = { 1, 2, 3, 4, 5, 6, 0 };
 static voice_t voicedata;
 voice_t *voice = &voicedata;
 
-
 static char *fgets_strip(char *buf, int size, FILE *f_in)
 {
 // strip trailing spaces, and truncate lines at // comment
 	return buf;
 }
 
-
 static int LookupTune(const char *name)
 {
 	int ix;
 	return -1;
 }
 
-
-
 static void SetToneAdjust(voice_t *voice, int *tone_pts)
 {
 	int ix;
 	}
 }
 
-
 void ReadTonePoints(char *string, int *tone_pts)
 {
 // tone_pts[] is int[12]
 	       &tone_pts[8], &tone_pts[9]);
 }
 
-
-
-
 static espeak_VOICE *ReadVoiceFile(FILE *f_in, const char *fname, const char *leafname)
 {
 // Read a Voice file, allocate a VOICE_DATA and set data from the
 	char vlanguage[80];
 	char languages[300];  // allow space for several alternate language names and priorities
 
-
 	unsigned int len;
 	int langix = 0;
 	int n_languages = 0;
 	return voice_data;
 }
 
-
-
-
 void VoiceReset(int tone_only)
 {
 // Set voice to the default values
 	}
 }
 
-
 static void VoiceFormant(char *p)
 {
 	// Set parameters for a formant
 	voice->freqadd[formant] = freqadd;
 }
 
-
-
-
-
 static void PhonemeReplacement(int type, char *p)
 {
 	int n;
 	replace_phonemes[n_replace_phonemes++].type = flags;
 }
 
-
-
 static int Read8Numbers(char *data_in, int *data)
 {
 // Read 8 integer numbers
 	              &data[0], &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], &data[7]);
 }
 
-
 static unsigned int StringToWord2(const char *string)
 {
 // Convert a language name string to a word such as L('e','n')
 	return value;
 }
 
-
 voice_t *LoadVoice(const char *vname, int control)
 {
 // control, bit 0  1= no_default
 	static const char *voices_europe =
 	    "an bg bs ca cs cy da de el en en-us es et eu fi fr fr-be ga hr hu is it lt lv mk nl no pl pt-pt ro ru sk sq sr sv ";
 
-
 	strncpy0(voicename, vname, sizeof(voicename));
 	if (control & 0x10) {
 		strcpy(buf, vname);
 	strcpy(new_dictionary, language_type);
 	strcpy(phonemes_name, language_type);
 
-
 	if (!tone_only) {
 		voice = &voicedata;
 		strncpy0(voice_identifier, vname, sizeof(voice_identifier));
 	if (!tone_only)
 		SelectPhonemeTableName(phonemes_name);  // set up phoneme_tab
 
-
 	while ((f_voice != NULL) && (fgets_strip(buf, sizeof(buf), f_voice) != NULL)) {
 		// isolate the attribute name
 		for (p = buf; (*p != 0) && !isspace(*p); p++) ;
 				strncpy0(voice->language_name, language_name, sizeof(voice->language_name));
 			}
 		}
-		break;
-
+			break;
 		case V_NAME:
 			if (tone_only == 0) {
 				while (isspace(*p)) p++;
 				strncpy0(voice_name, p, sizeof(voice_name));
 			}
 			break;
-
 		case V_GENDER:
 		{
 			int age = 0;
 			current_voice_selected.gender = LookupMnem(genders, vgender);
 			current_voice_selected.age = age;
 		}
-		break;
-
+			break;
 		case V_TRANSLATOR:
 			if (tone_only) break;
 
 			new_translator = SelectTranslator(translator_name);
 			langopts = &new_translator->langopts;
 			break;
-
 		case V_DICTIONARY:        // dictionary
 			sscanf(p, "%s", new_dictionary);
 			break;
-
 		case V_PHONEMES:        // phoneme table
 			sscanf(p, "%s", phonemes_name);
 			break;
-
 		case V_FORMANT:
 			VoiceFormant(p);
 			break;
-
 		case V_PITCH:
 		{
 			double factor;
 			factor = (double)(pitch1 - 82)/82;
 			voice->formant_factor = (int)((1+factor/4) * 256);  // nominal formant shift for a different voice pitch
 		}
-		break;
-
+			break;
 		case V_STRESSLENGTH:   // stressLength
 			stress_lengths_set = Read8Numbers(p, stress_lengths);
 			break;
-
 		case V_STRESSAMP:   // stressAmp
 			stress_amps_set = Read8Numbers(p, stress_amps);
 			break;
-
 		case V_STRESSADD:   // stressAdd
 			stress_add_set = Read8Numbers(p, stress_add);
 			break;
-
 		case V_INTONATION:   // intonation
 			sscanf(p, "%d %d", &option_tone_flags, &option_tone2);
 			if ((option_tone_flags & 0xff) != 0)
 				langopts->intonation_group = option_tone_flags & 0xff;
 			break;
-
 		case V_TUNES:
 			n = sscanf(p, "%s %s %s %s %s %s", names[0], names[1], names[2], names[3], names[4], names[5]);
 			langopts->intonation_group = 0;
 					langopts->tunes[ix] = value;
 			}
 			break;
-
 		case V_DICTRULES:   // conditional dictionary rules and list entries
 		case V_NUMBERS:
 		case V_STRESSOPT:
 			}
 			ProcessLanguageOptions(langopts);
 			break;
-
 		case V_REPLACE:
 			if (phonemes_set == 0) {
 				// must set up a phoneme table before we can lookup phoneme mnemonics
 			}
 			PhonemeReplacement(key, p);
 			break;
-
 		case V_WORDGAP:   // words
 			sscanf(p, "%d %d", &langopts->word_gap, &langopts->vowel_pause);
 			break;
-
 		case V_STRESSRULE:
 			sscanf(p, "%d %d %d %d", &langopts->stress_rule,
 			       &langopts->stress_flags,
 			       &langopts->unstressed_wd1,
 			       &langopts->unstressed_wd2);
 			break;
-
 		case V_CHARSET:
 			if ((sscanf(p, "%d", &value) == 1) && (value < N_CHARSETS))
 				new_translator->charset_a0 = charsets[value];
 			break;
-
 		case V_OPTION:
 			value2 = 0;
 			if (((sscanf(p, "%s %d %d", option_name, &value, &value2) >= 2) && ((ix = LookupMnem(options_tab, option_name)) >= 0)) ||
 			} else
 				fprintf(stderr, "Bad voice option: %s %s\n", buf, p);
 			break;
-
 		case V_ECHO:
 			// echo.  suggest: 135mS  11%
 			value = 0;
 			voice->echo_amp = 0;
 			sscanf(p, "%d %d", &voice->echo_delay, &voice->echo_amp);
 			break;
-
 		case V_FLUTTER:   // flutter
 			if (sscanf(p, "%d", &value) == 1)
 				voice->flutter = value * 32;
 			break;
-
 		case V_ROUGHNESS:   // roughness
 			if (sscanf(p, "%d", &value) == 1)
 				voice->roughness = value;
 			break;
-
 		case V_CLARITY:  // formantshape
 			if (sscanf(p, "%d", &value) == 1) {
 				if (value > 4) {
 				voice->n_harmonic_peaks = 1+value;
 			}
 			break;
-
 		case V_TONE:
 		{
 			int tone_data[12];
 			ReadTonePoints(p, tone_data);
 			SetToneAdjust(voice, tone_data);
 		}
-		break;
-
+			break;
 		case V_VOICING:
 			if (sscanf(p, "%d", &value) == 1)
 				voice->voicing = (value * 64)/100;
 			break;
-
 		case V_BREATH:
 			voice->breath[0] = Read8Numbers(p, &voice->breath[1]);
 			for (ix = 1; ix < 8; ix++) {
 					voice->breath[ix] = -voice->breath[ix];
 			}
 			break;
-
 		case V_BREATHW:
 			voice->breathw[0] = Read8Numbers(p, &voice->breathw[1]);
 			break;
-
 		case V_CONSONANTS:
 			value = sscanf(p, "%d %d", &voice->consonant_amp, &voice->consonant_ampv);
 			break;
-
 		case V_SPEED:
 			sscanf(p, "%d", &voice->speed_percent);
 			break;
-
 		case V_MBROLA:
 		{
 			int srate = 16000;
 			}
 			voice->samplerate = srate;
 		}
-		break;
-
+			break;
 		case V_KLATT:
 			voice->klattv[0] = 1;  // default source: IMPULSIVE
 			Read8Numbers(p, voice->klattv);
 			voice->klattv[KLATT_Kopen] -= 40;
 			break;
-
 		case V_FAST:
 			Read8Numbers(p, speed.fast_settings);
 			SetSpeed(3);
 			break;
-
 		case V_DICTMIN:
 			sscanf(p, "%d", &dict_min);
 			break;
-
 		case V_ALPHABET2:
 		{
 			ALPHABET *alphabet;
 			} else
 				fprintf(stderr, "alphabet name '%s' not found\n", name1);
 		}
-		break;
-
+			break;
 		case V_DICTDIALECT:
 			// specify a dialect to use for foreign words, eg, en-us for _^_EN
 			if (sscanf(p, "%s", name1) == 1) {
 					fprintf(stderr, "dictdialect name '%s' not recognized\n", name1);
 			}
 			break;
-
 		default:
 			if ((key & 0xff00) == 0x100)
 				sscanf(p, "%d", &langopts->param[key &0xff]);
 	return voice;
 }
 
-
 static char *ExtractVoiceVariantName(char *vname, int variant_num, int add_dir)
 {
 // Remove any voice variant suffix (name or number) from a voice name
 	return variant_name;
 }
 
-
-
 voice_t *LoadVoiceVariant(const char *vname, int variant_num)
 {
 // Load a voice file.
 	return v;
 }
 
-
-
 static int __cdecl VoiceNameSorter(const void *p1, const void *p2)
 {
 	int ix;
 	espeak_VOICE *v1 = *(espeak_VOICE **)p1;
 	espeak_VOICE *v2 = *(espeak_VOICE **)p2;
 
-
 	if ((ix = strcmp(&v1->languages[1], &v2->languages[1])) != 0)  // primary language name
 		return ix;
 	if ((ix = v1->languages[0] - v2->languages[0]) != 0)  // priority number
 	return strcmp(v1->name, v2->name);
 }
 
-
 static int __cdecl VoiceScoreSorter(const void *p1, const void *p2)
 {
 	int ix;
 	return strcmp(v1->name, v2->name);
 }
 
-
 static int ScoreVoice(espeak_VOICE *voice_spec, const char *spec_language, int spec_n_parts, int spec_lang_len, espeak_VOICE *voice)
 {
 	int ix;
 	return score;
 }
 
-
 static int SetVoiceScores(espeak_VOICE *voice_select, espeak_VOICE **voices, int control)
 {
 // control: bit0=1  include mbrola voices
 			language[lang_len] = 0;
 			n_parts = -1;
 		}
-
 	}
 
 	// select those voices which match the specified language
 	return nv;
 }
 
-
-
-
 espeak_VOICE *SelectVoiceByName(espeak_VOICE **voices, const char *name2)
 {
 	int ix;
 	return voices[match_name];
 }
 
-
-
-
 char const *SelectVoice(espeak_VOICE *voice_select, int *found)
 {
 // Returns a path within espeak-voices, with a possible +variant suffix
 	return vp->identifier;
 }
 
-
-
 static void GetVoices(const char *path)
 {
 	FILE *f_voice;
 		}
 	} while (FindNextFileA(hFind, &FindFileData) != 0);
 	FindClose(hFind);
-
 #else
 	DIR *dir;
 	struct dirent *ent;
 #endif
 }
 
-
-
 espeak_ERROR SetVoiceByName(const char *name)
 {
 	espeak_VOICE *v;
 	return EE_INTERNAL_ERROR;   // voice name not found
 }
 
-
-
 espeak_ERROR SetVoiceByProperties(espeak_VOICE *voice_selector)
 {
 	const char *voice_id;
 	return EE_OK;
 }
 
-
 void FreeVoiceList()
 {
 	int ix;
 	n_voices_list = 0;
 }
 
-
 #pragma GCC visibility push(default)
 
-
 ESPEAK_API const espeak_VOICE **espeak_ListVoices(espeak_VOICE *voice_spec)
 {
 	char path_voices[sizeof(path_home)+12];
 
-
 #ifdef PLATFORM_RISCOS
 	if (n_voices_list == 0) {
 		sprintf(path_voices, "%s%cvoices", path_home, PATHSEP);
 		voices_list[n_voices_list] = NULL;  // voices list terminator
 	}
 	return (const espeak_VOICE **)voices_list;
-
 #else
 	int ix;
 	int j;
 	qsort(voices_list, n_voices_list, sizeof(espeak_VOICE *),
 	      (int(__cdecl *)(const void *, const void *))VoiceNameSorter);
 
-
 	if (voice_spec) {
 		// select the voices which match the voice_spec, and sort them by preference
 		SetVoiceScores(voice_spec, voices, 1);
 #endif
 }
 
-
-
 ESPEAK_API espeak_VOICE *espeak_GetCurrentVoice(void)
 {
 	return &current_voice_selected;

src/libespeak-ng/wave.c

 };
 #endif /* HAVE_STRUCT_TIMESPEC */
 
-
 enum { ONE_BILLION = 1000000000 };
 
 #ifdef USE_PORTAUDIO
 #define USE_PORTAUDIO   18
 #endif
 
-
-
-
 #ifdef USE_PULSEAUDIO
 // create some wrappers for runtime detection
 
 
 #endif  // USE_PULSEAUDIO
 
-
 static t_wave_callback *my_callback_is_output_enabled = NULL;
 
 #define N_WAV_BUF   10
 	return aResult;
 }
 
-
 void wave_flush(void *theHandler)
 {
 	ENTER("wave_flush");
 		out_channels = 1;
 
 #if USE_PORTAUDIO == 18
-
 		PaDeviceID playbackDevice = Pa_GetDefaultOutputDeviceID();
 
 		PaError err = Pa_OpenStream(&pa_stream,
 
 	SHOW("wave_is_busy: %d\n", active);
 
-
 	return active == 1;
 }
 
 	ENTER("wave_terminate");
 
 	Pa_Terminate();
-
 }
 
 uint32_t wave_get_read_position(void *theHandler)
 	return myWrite;
 }
 
-
 #else
 
-
 int wave_init(int srate) {
 	return 1;
 }
 	ts->tv_nsec = (long int)t_ns;
 }
 
-
 #endif   // USE_ASYNC

src/libespeak-ng/wave_pulse.c

 	case PA_CONTEXT_FAILED:
 		pa_threaded_mainloop_signal(mainloop, 0);
 		break;
-
 	case PA_CONTEXT_UNCONNECTED:
 	case PA_CONTEXT_CONNECTING:
 	case PA_CONTEXT_AUTHORIZING:
 
 	switch (pa_stream_get_state(s))
 	{
-
 	case PA_STREAM_READY:
 	case PA_STREAM_FAILED:
 	case PA_STREAM_TERMINATED:
 		pa_threaded_mainloop_signal(mainloop, 0);
 		break;
-
 	case PA_STREAM_UNCONNECTED:
 	case PA_STREAM_CREATING:
 		break;
 static void pulse_write(void *ptr, int length) {
 	ENTER(__FUNCTION__);
 
-
 	SHOW("pulse_write > length=%d\n", length);
 
 	CHECK_CONNECTED_NO_RETVAL();
 
 	do_trigger = 0;
 	written += length;
-
 fail:
-
 	pa_threaded_mainloop_unlock(mainloop);
 }
 
 		SHOW("pa_stream_drain() failed: %s\n", pa_strerror(pa_context_errno(context)));
 	else
 		ret = PULSE_OK;
-
 fail:
 	SHOW_TIME("pa_operation_unref (call)");
 	if (o)
 	return ret;
 }
 
-
 static void pulse_close(void) {
 
 	ENTER(__FUNCTION__);
 
 }
 
-
 static int pulse_open()
 {
 	ENTER(__FUNCTION__);
 	SHOW_TIME("pulse_open (ret true)");
 
 	return PULSE_OK;
-
 unlock_and_fail:
-
 	if (o)
 		pa_operation_unref(o);
 
 	pa_threaded_mainloop_unlock(mainloop);
-
 fail:
-
 	if (ret == PULSE_NO_CONNECTION) {
 		if (context) {
 			SHOW_TIME("pa_context_disconnect (call)");
 	SHOW_TIME("pulse_open (ret false)");
 
 	return ret;
-
 }
 
 void wave_flush(void *theHandler)
 	}
 
 	pulse_write(aBuffer, bytes_to_write);
-
 terminate:
 	pthread_mutex_unlock(&pulse_mutex);
 	SHOW("wave_write: theSize=%d", theSize);
 	return NULL;
 }
 
-
 #else
 
-
 int wave_init(return 1; ) {
 }
 void *wave_open(const char *the_api) {
 }
 #endif  // ifndef USE_PORTAUDIO
 
-
 #endif   // USE_ASYNC

src/libespeak-ng/wavegen.c

 #include <stdint.h>
 #endif
 
-
-
 #include "speak_lib.h"
 #include "speech.h"
 #include "phoneme.h"
 #define N_SINTAB  2048
 #include "sintab.h"
 
-
 #define PI  3.1415927
 #define PI2 6.283185307
 #define N_WAV_BUF   10
 
 static int harm_sqrt_n = 0;
 
-
 #define N_LOWHARM  30
 static int harm_inc[N_LOWHARM];    // only for these harmonics do we interpolate amplitude between steps
 static int *harmspect;
 static int glottal_flag = 0;
 static int glottal_reduce = 0;
 
-
 WGEN_DATA wdata;
 
 static int amp_ix;
 static double minus_pi_t;
 static double two_pi_t;
 
-
 unsigned char *out_ptr;
 unsigned char *out_start;
 unsigned char *out_end;
 	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 };
 
-
 // set from y = pow(2,x) * 128,  x=-1 to 1
 unsigned char pitch_adjust_tab[MAX_PITCH_VALUE+1] = {
 	64, 65, 66, 67, 68, 69, 70, 71,
 	242, 246, 249, 252, 254, 255
 };
 
-
 void WcmdqStop()
 {
 	wcmdq_head = 0;
 		MbrolaReset();
 }
 
-
 int WcmdqFree()
 {
 	int i;
 	return N_WCMDQ - WcmdqFree();
 }
 
-
 void WcmdqInc()
 {
 	wcmdq_tail++;
 	if (wcmdq_head >= N_WCMDQ) wcmdq_head = 0;
 }
 
-
-
 #define PEAKSHAPEW 256
 
 unsigned char pk_shape1[PEAKSHAPEW+1] = {
 
 static unsigned char *pk_shape;
 
-
 #ifdef USE_PORTAUDIO
 // PortAudio interface
 
 unsigned char *outbuffer = NULL;
 int outbuffer_size = 0;
 
-
 #if USE_PORTAUDIO == 18
 static int WaveCallback(void *inputBuffer, void *outputBuffer,
                         unsigned long framesPerBuffer, PaTimestamp outTime, void *userData)
 #else
 	return result;
 #endif
-
 }
 
-
 #if USE_PORTAUDIO == 19
 /* This is a fixed version of Pa_OpenDefaultStream() for use if the version in portaudio V19
    is broken */
 }
 #endif
 
-
 int WavegenOpenSound()
 {
 	PaError err, err2;
 	return 0;
 }
 
-
-
 int WavegenCloseSound()
 {
 	PaError active;
 	return 0;
 }
 
-
 int WavegenInitSound()
 {
 	PaError err;
 }
 #endif
 
-
 void WavegenInit(int rate, int wavemult_fact)
 {
 	int ix;
 	for (ix = 0; ix < N_EMBEDDED_VALUES; ix++)
 		embedded_value[ix] = embedded_default[ix];
 
-
 	// set up window to generate a spread of harmonics from a
 	// single peak for HF peaks
 	wavemult_max = (samplerate * wavemult_fact)/(256 * 50);
 #endif
 }
 
-
 int GetAmplitude(void)
 {
 	int amp;
 	return general_amplitude;
 }
 
-
 static void WavegenSetEcho(void)
 {
 	int delay;
 	general_amplitude = ((general_amplitude * (500-amp))/500);
 }
 
-
-
 int PeaksToHarmspect(wavegen_peaks_t *peaks, int pitch, int *htab, int control)
 {
 // Calculate the amplitude of each  harmonics from the formants
 	return hmax;  // highest harmonic number
 }
 
-
-
 static void AdvanceParameters()
 {
 // Called every 64 samples to increment the formant freq, height, and widths
 #endif
 }
 
-
 #ifndef PLATFORM_RISCOS
 static double resonator(RESONATOR *r, double input)
 {
 	return x;
 }
 
-
-
 static void setresonator(RESONATOR *rp, int freq, int bwidth, int init)
 {
 // freq    Frequency of resonator in Hz
 }
 #endif
 
-
 void InitBreath(void)
 {
 #ifndef PLATFORM_RISCOS
 #endif
 }
 
-
-
 static void SetBreath()
 {
 #ifndef PLATFORM_RISCOS
 #endif
 }
 
-
 static int ApplyBreath(void)
 {
 	int value = 0;
 	return value;
 }
 
-
-
 int Wavegen()
 {
 	unsigned short waveph;
 	return 0;
 }
 
-
 static int PlaySilence(int length, int resume)
 {
 	static int n_samples;
 	return 0;
 }
 
-
-
 static int PlayWave(int length, int resume, unsigned char *data, int scale, int amp)
 {
 	static int n_samples;
 	return 0;
 }
 
-
 static int SetWithRange0(int value, int max)
 {
 	if (value < 0)
 	return value;
 }
 
-
 static void SetPitchFormants()
 {
 	int ix;
 	wvoice->height[1] = (wvoice->height2[1] * (256 - factor))/256;
 }
 
-
 void SetEmbedded(int control, int value)
 {
 	// there was an embedded command in the text at this point
 	case EMBED_P:
 		SetPitchFormants();
 		break;
-
 	case EMBED_A:  // amplitude
 		general_amplitude = GetAmplitude();
 		break;
-
 	case EMBED_F:   // emphasis
 		general_amplitude = GetAmplitude();
 		break;
-
 	case EMBED_H:
 		WavegenSetEcho();
 		break;
 	}
 }
 
-
 void WavegenSetVoice(voice_t *v)
 {
 	static voice_t v2;
 	MarkerEvent(espeakEVENT_SAMPLERATE, 0, wvoice->samplerate, 0, out_ptr);
 }
 
-
 static void SetAmplitude(int length, unsigned char *amp_env, int value)
 {
 	amp_ix = 0;
 	amplitude_env = amp_env;
 }
 
-
 void SetPitch2(voice_t *voice, int pitch1, int pitch2, int *pitch_base, int *pitch_range)
 {
 	int x;
 	*pitch_range = base + (pitch2 * range)/2 - *pitch_base;
 }
 
-
 void SetPitch(int length, unsigned char *env, int pitch1, int pitch2)
 {
 // length in samples
 	wdata.pitch = ((wdata.pitch_env[0] * wdata.pitch_range) >>8) + wdata.pitch_base;   // Hz << 12
 
 	flutter_amp = wvoice->flutter;
-
 }
 
-
-
-
-
 void SetSynth(int length, int modn, frame_t *fr1, frame_t *fr2, voice_t *v)
 {
 	int ix;
 	}
 }
 
-
 static int Wavegen2(int length, int modulation, int resume, frame_t *fr1, frame_t *fr2)
 {
 	if (resume == 0)
 	}
 }
 
-
-
 int WavegenFill2(int fill_zeros)
 {
 // Pick up next wavegen commands from the queue
 		case WCMD_PITCH:
 			SetPitch(length, (unsigned char *)q[2], q[3] >> 16, q[3] & 0xffff);
 			break;
-
 		case WCMD_PAUSE:
 			if (resume == 0)
 				echo_complete -= length;
 #endif
 			result = PlaySilence(length, resume);
 			break;
-
 		case WCMD_WAVE:
 			echo_complete = echo_length;
 			wdata.n_mix_wavefile = 0;
 #endif
 			result = PlayWave(length, resume, (unsigned char *)q[2], q[3] & 0xff, q[3] >> 8);
 			break;
-
 		case WCMD_WAVE2:
 			// wave file to be played at the same time as synthesis
 			wdata.mix_wave_amp = q[3] >> 8;
 			wdata.mix_wavefile_offset = 0;
 			wdata.mix_wavefile = (unsigned char *)q[2];
 			break;
-
 		case WCMD_SPECT2:   // as WCMD_SPECT but stop any concurrent wave file
 			wdata.n_mix_wavefile = 0;   // ... and drop through to WCMD_SPECT case
 		case WCMD_SPECT:
 			echo_complete = echo_length;
 			result = Wavegen2(length & 0xffff, q[1] >> 16, resume, (frame_t *)q[2], (frame_t *)q[3]);
 			break;
-
 #ifdef INCLUDE_KLATT
 		case WCMD_KLATT2:   // as WCMD_SPECT but stop any concurrent wave file
 			wdata.n_mix_wavefile = 0;   // ... and drop through to WCMD_SPECT case
 			result = Wavegen_Klatt2(length & 0xffff, q[1] >> 16, resume, (frame_t *)q[2], (frame_t *)q[3]);
 			break;
 #endif
-
 		case WCMD_MARKER:
 			marker_type = q[0] >> 8;
 			MarkerEvent(marker_type, q[1], q[2], q[3], out_ptr);
 			if (marker_type == 1) // word marker
 				current_source_index = q[1] & 0xffffff;
 			break;
-
 		case WCMD_AMPLITUDE:
 			SetAmplitude(length, (unsigned char *)q[2], q[3]);
 			break;
-
 		case WCMD_VOICE:
 			WavegenSetVoice((voice_t *)q[2]);
 			free((voice_t *)q[2]);
 			break;
-
 		case WCMD_EMBEDDED:
 			SetEmbedded(q[1], q[2]);
 			break;
-
 		case WCMD_MBROLA_DATA:
 			result = MbrolaFill(length, resume, (general_amplitude * wvoice->voicing)/64);
 			break;
-
 		case WCMD_FMT_AMPLITUDE:
 			if ((wdata.amplitude_fmt = q[1]) == 0)
 				wdata.amplitude_fmt = 100;  // percentage, but value=0 means 100%
 			break;
-
 #if HAVE_SONIC_H
 		case WCMD_SONIC_SPEED:
 			sonicSpeed = (double)q[1] / 1024;
 	return 0;
 }
 
-
 #if HAVE_SONIC_H
 /* Speed up the audio samples with libsonic. */
 static int SpeedUp(short *outbuf, int length_in, int length_out, int end_of_text)
 }
 #endif
 
-
 /* Call WavegenFill2, and then speed up the output samples. */
 int WavegenFill(int fill_zeros)
 {

src/speak-ng.c

 #include "voice.h"
 #include "translate.h"
 
-
-
 extern void Write4Bytes(FILE *f, int value);
 char path_home[N_PATH_HOME];    // this is the espeak-data directory
 
     "\t   List the available voices for the specified language.\n"
     "\t   If <language> is omitted, then list all voices.\n";
 
-
 void DisplayVoices(FILE *f_out, char *language);
 
 USHORT voice_pcnt[N_PEAKS+1][3];
 
-
-
 void DisplayVoices(FILE *f_out, char *language)
 {
 	int ix;
 	}
 }
 
-
 static int OpenWaveFile(const char *path, int rate)
 {
 	// Set the length of 0x7ffff000 for --stdout
 	return 1;
 }
 
-
-
-
 static void CloseWaveFile()
 {
 	unsigned int pos;
 
 	fclose(f_wave);
 	f_wave = NULL;
-
 }
 
-
-
-
 static int WavegenFile(void)
 {
 	int finished;
 	return finished;
 }
 
-
-
 static void init_path(char *argv0, char *path_specified)
 {
-
 	if (path_specified) {
 		sprintf(path_home, "%s/espeak-data", path_specified);
 		return;
 #endif
 }
 
-
 static int initialise(void)
 {
 	int param;
 	}
 #endif
 
-
 	if ((result = LoadPhData(&srate)) != 1) {
 		if (result == -1) {
 			fprintf(stderr, "Failed to load espeak-data\n");
 	return 0;
 }
 
-
-
 #ifdef NEED_GETOPT
 struct option {
 	char *name;
 			if ((sscanf(optarg2, "%d", &value) == 1) && (value <= 4))
 				option_multibyte = value;
 			break;
-
 		case 'h':
 			init_path(argv[0], data_path);
 			printf("\nspeak text-to-speech: %s   Data at: %s\n%s", version_string, path_home, help_text);
 			exit(0);
-
 		case 'k':
 			option_capitals = atoi(optarg2);
 			break;
-
 		case 'x':
 			phoneme_options |= espeakPHONEMES_SHOW;
 			break;
-
 		case 'X':
 			phoneme_options |= espeakPHONEMES_TRACE;
 			break;
-
 		case 'm':
 			option_ssml = 1;
 			break;
-
 		case 'p':
 			pitch_adjustment = atoi(optarg2);
 			if (pitch_adjustment > 99) pitch_adjustment = 99;
 			break;
-
 		case 'q':
 			quiet = 1;
 			break;
-
 		case 'f':
 			strncpy0(filename, optarg2, sizeof(filename));
 			break;
-
 		case 'l':
 			value = 0;
 			value = atoi(optarg2);
 			option_linelength = value;
 			break;
-
 		case 'a':
 			amp = atoi(optarg2);
 			break;
-
 		case 's':
 			speed = atoi(optarg2);
 			break;
-
 		case 'g':
 			wordgap = atoi(optarg2);
 			break;
-
 		case 'v':
 			strncpy0(voicename, optarg2, sizeof(voicename));
 			break;
-
 		case 'w':
 			option_waveout = 1;
 			strncpy0(wavefile, optarg2, sizeof(wavefile));
 			break;
-
 		case 'z':
 			option_endpause = 0;
 			break;
-
 		case 0x100:     // --stdin
 			flag_stdin = 1;
 			break;
-
 		case 0x105:     // --stdout
 			option_waveout = 1;
 			strcpy(wavefile, "stdout");
 			break;
-
 		case 0x101:    // --compile-debug
 		case 0x102:     // --compile
 			if (optarg2 != NULL)
 				strncpy0(voicename, optarg2, sizeof(voicename));
 			flag_compile = c;
 			break;
-
 		case 0x103:     // --punct
 			option_punctuation = 1;
 			if (optarg2 != NULL) {
 				option_punctuation = 2;
 			}
 			break;
-
 		case 0x104:   // --voices
 			init_path(argv[0], data_path);
 			DisplayVoices(stdout, optarg2);
 			exit(0);
-
 		case 0x106:   // -- split
 			if (optarg2 == NULL)
 				samples_split = 30;  // default 30 minutes
 			else
 				samples_split = atoi(optarg2);
 			break;
-
 		case 0x107:  // --path
 			data_path = optarg2;
 			break;
-
 		case 0x108:  // --phonout
 			if ((f_trans = fopen(optarg2, "w")) == NULL) {
 				fprintf(stderr, "Can't write to: %s\n", optarg2);
 				f_trans = stderr;
 			}
 			break;
-
 		case 0x109:  // --pho
 			phoneme_options |= espeakPHONEMES_MBROLA;
 			break;
-
 		case 0x10a:  // --ipa
 			phoneme_options |= espeakPHONEMES_IPA;
 			if (optarg2 != NULL) {
 					phoneme_options |= espeakPHONEMES_TIE;
 					break;
 				}
-
 			}
 			break;
-
 		case 0x10b:  // --version
 			init_path(argv[0], data_path);
 			printf("speak text-to-speech: %s   Data at: %s\n", version_string, path_home);
 			exit(0);
-
 		case 0x10c:  // --sep
 			phoneme_options |= espeakPHONEMES_SHOW;
 			if (optarg2 == 0)
 			if (phonemes_separator == 'z')
 				phonemes_separator = 0x200c;      // ZWNJ
 			break;
-
 		case 0x10d:  // --tie
 			phoneme_options |= (espeakPHONEMES_SHOW | espeakPHONEMES_TIE);
 			if (optarg2 == 0)
 			if (phonemes_separator == 'z')
 				phonemes_separator = 0x200d;      // ZWJ
 			break;
-
 		default:
 			exit(0);
 		}
 		exit(0);
 	}
 
-
 	SetParameter(espeakRATE, speed, 0);
 	SetParameter(espeakVOLUME, amp, 0);
 	SetParameter(espeakCAPITALS, option_capitals, 0);