code cleanup: fix -Wstrict-prototypes

src/libespeak-ng/event.c

 	return status;
 }
 
-espeak_ng_STATUS event_clear_all()
+espeak_ng_STATUS event_clear_all(void)
 {
 	espeak_ng_STATUS status;
 	if ((status = pthread_mutex_lock(&my_mutex)) != ENS_OK)
 	return ENS_OK;
 }
 
-static void *pop()
+static void *pop(void)
 {
 	void *the_data = NULL;
 
 }
 
 
-static void init()
+static void init(void)
 {
 	while (event_delete((espeak_EVENT *)pop()))
 		;
 	node_counter = 0;
 }
 
-void event_terminate()
+void event_terminate(void)
 {
 	if (thread_inited) {
 		my_terminate_is_required = true;

src/libespeak-ng/fifo.c

 	MAX_INACTIVITY_CHECK = 2
 };
 
-void fifo_init()
+void fifo_init(void)
 {
 	// security
 	pthread_mutex_init(&my_mutex, (const pthread_mutexattr_t *)NULL);
 	return ENS_OK;
 }
 
-espeak_ng_STATUS fifo_stop()
+espeak_ng_STATUS fifo_stop(void)
 {
 	if (!thread_inited) return ENS_OK;
 	espeak_ng_STATUS status;
 	return ENS_OK;
 }
 
-int fifo_is_busy()
+int fifo_is_busy(void)
 {
 	if (!thread_inited) return false;
 	pthread_mutex_lock(&my_mutex);
 	return running;
 }
 
-static int sleep_until_start_request_or_inactivity()
+static int sleep_until_start_request_or_inactivity(void)
 {
 	int a_start_is_required = false;
 
 	return a_start_is_required;
 }
 
-static espeak_ng_STATUS close_stream()
+static espeak_ng_STATUS close_stream(void)
 {
 	espeak_ng_STATUS status = pthread_mutex_lock(&my_mutex);
 	if (status != ENS_OK)
 	return NULL;
 }
 
-int fifo_is_command_enabled()
+int fifo_is_command_enabled(void)
 {
 	return 0 == my_stop_is_required;
 }
 	return ENS_OK;
 }
 
-static t_espeak_command *pop()
+static t_espeak_command *pop(void)
 {
 	t_espeak_command *the_command = NULL;
 
 	node_counter = 0;
 }
 
-void fifo_terminate()
+void fifo_terminate(void)
 {
 	if (!thread_inited) return;
 

src/libespeak-ng/klatt.c

    to Kopen.
  */
 
-static double impulsive_source()
+static double impulsive_source(void)
 {
 	static const double doublet[] = { 0.0, 13000000.0, -13000000.0 };
 	static double vwave;
    spectral zero around 800 Hz, magic constants a,b reset pitch synchronously.
  */
 
-static double natural_source()
+static double natural_source(void)
 {
 	double lgtemp;
 	static double vwave;
 	}
 }
 
-void KlattInit()
+void KlattInit(void)
 {
 
 	static const short formant_hz[10] = { 280, 688, 1064, 2806, 3260, 3700, 6500, 7000, 8000, 280 };

src/libespeak-ng/sPlayer.c

 	}
 }
 
-static bool isKlattFrameFollowing() {
+static bool isKlattFrameFollowing(void) {
 	// eSpeak implements its command queue with a circular buffer.
 	// Thus to walk it, we start from the head, walking to the tail, which may wrap around to the beginning of the buffer as it is circular.
 	for(int i=(wcmdq_head+1)%N_WCMDQ;i!=wcmdq_tail;i=(i+1)%N_WCMDQ) {
 	spFrame->endVoicePitch=spFrame->voicePitch;
 }
 
-void KlattInitSP() {
+void KlattInitSP(void) {
 	speechPlayerHandle=speechPlayer_initialize(22050);
 }
 
-void KlattFiniSP() {
+void KlattFiniSP(void) {
 	if (speechPlayerHandle)
 		speechPlayer_terminate(speechPlayerHandle);
 	speechPlayerHandle = NULL;
 }
 
-void KlattResetSP() {
+void KlattResetSP(void) {
 	KlattFiniSP();
 	KlattInitSP();
 }

src/libespeak-ng/spect.c

 	return y;
 }
 
-static SpectFrame *SpectFrameCreate()
+static SpectFrame *SpectFrameCreate(void)
 {
 	int ix;
 	SpectFrame *frame;
 }
 
 #pragma GCC visibility push(default)
-SpectSeq *SpectSeqCreate()
+SpectSeq *SpectSeqCreate(void)
 {
 	SpectSeq *spect = malloc(sizeof(SpectSeq));
 	if (!spect)

src/libespeak-ng/synthesize.c

 	return buf;
 }
 
-void SynthesizeInit()
+void SynthesizeInit(void)
 {
 	last_pitch_cmd = 0;
 	last_amp_cmd = 0;
 	return len;
 }
 
-static frame_t *AllocFrame()
+static frame_t *AllocFrame(void)
 {
 	// Allocate a temporary spectrum frame for the wavegen queue. Use a pool which is big
 	// enough to use a round-robin without checks.

src/libespeak-ng/translate.c

 	return count;
 }
 
-static void Word_EmbeddedCmd()
+static void Word_EmbeddedCmd(void)
 {
 	// Process embedded commands for emphasis, sayas, and break
 	int embedded_cmd;

src/libespeak-ng/voices.c

 
 #pragma GCC visibility pop
 
-void FreeVoiceList()
+void FreeVoiceList(void)
 {
 	int ix;
 	for (ix = 0; ix < n_voices_list; ix++) {

src/libespeak-ng/wavegen.c

 	242, 246, 249, 252, 254, 255
 };
 
-void WcmdqStop()
+void WcmdqStop(void)
 {
 	wcmdq_head = 0;
 	wcmdq_tail = 0;
 #endif
 }
 
-int WcmdqFree()
+int WcmdqFree(void)
 {
 	int i;
 	i = wcmdq_head - wcmdq_tail;
 	return i;
 }
 
-int WcmdqUsed()
+int WcmdqUsed(void)
 {
 	return N_WCMDQ - WcmdqFree();
 }
 
-void WcmdqInc()
+void WcmdqInc(void)
 {
 	wcmdq_tail++;
 	if (wcmdq_tail >= N_WCMDQ) wcmdq_tail = 0;
 }
 
-static void WcmdqIncHead()
+static void WcmdqIncHead(void)
 {
 	MAKE_MEM_UNDEFINED(&wcmdq[wcmdq_head], sizeof(wcmdq[wcmdq_head]));
 	wcmdq_head++;
 	return hmax; // highest harmonic number
 }
 
-static void AdvanceParameters()
+static void AdvanceParameters(void)
 {
 	// Called every 64 samples to increment the formant freq, height, and widths
 	if (wvoice == NULL)
 		setresonator(&rbreath[ix], 2000, 200, 1);
 }
 
-static void SetBreath()
+static void SetBreath(void)
 {
 	int pk;
 
 	return value;
 }
 
-static void SetPitchFormants()
+static void SetPitchFormants(void)
 {
 	if (wvoice == NULL)
 		return;
 	}
 }
 
-static int WavegenFill2()
+static int WavegenFill2(void)
 {
 	// Pick up next wavegen commands from the queue
 	// return: 0  output buffer has been filled