Exemple #1
0
void pressed_file_configure()
{
	spawn_dd tdata;
	spawn_row *rp;
	char txt[64], *s;
	int i, j;

	rp = tdata.strs = calloc(FACTION_ROWS_TOTAL, sizeof(spawn_row));
	if (!rp) return; // Not enough memory

	for (i = 1; i <= FACTION_ROWS_TOTAL; i++ , rp++)
	{
		for (j = 0; j < 3; j++)
		{
			sprintf(txt, faction_ini[j], i);
			s = inifile_get(txt, "");
			if (!j) strncpy0(rp->name, s, sizeof(rp->name));
			else if (j == 1) gtkuncpy(rp->cmd, s, sizeof(rp->cmd));
			else strncpy0(rp->dir, s, sizeof(rp->dir));
		}
	}

	tdata.name = tdata.cmd = "";
	tdata.dir[0] = '\0';
	tdata.idx = -1;
	tdata.nidx = 0;
	tdata.cnt = FACTION_ROWS_TOTAL;
	tdata.lock = FALSE;

	run_create(spawn_code, &tdata, sizeof(tdata));
}
static const char* s_AdjustNetParams(const char*    service,
                                     SConnNetInfo*  net_info,
                                     EReqMethod     req_method,
                                     const char*    cgi_path,
                                     const char*    cgi_args,
                                     const char*    args,
                                     const char*    static_header,
                                     EMIME_Type     mime_t,
                                     EMIME_SubType  mime_s,
                                     EMIME_Encoding mime_e,
                                     char*          dynamic_header/*freed!*/)
{
    const char *retval = 0;

    net_info->req_method = req_method;

    if (cgi_path)
        strncpy0(net_info->path, cgi_path, sizeof(net_info->path) - 1);

    if (args)
        strncpy0(net_info->args, args, sizeof(net_info->args) - 1);
    ConnNetInfo_DeleteAllArgs(net_info, cgi_args);

    if (ConnNetInfo_PrependArg(net_info, cgi_args, 0)) {
        size_t sh_len = static_header  ? strlen(static_header)  : 0;
        size_t dh_len = dynamic_header ? strlen(dynamic_header) : 0;
        char   c_t[MAX_CONTENT_TYPE_LEN];
        size_t ct_len, len;

        if (s_IsContentTypeDefined(service, net_info, mime_t, mime_s, mime_e)
            ||  !MIME_ComposeContentTypeEx(mime_t, mime_s, mime_e,
                                           c_t, sizeof(c_t))) {
            c_t[0] = '\0';
            ct_len = 0;
        } else
            ct_len = strlen(c_t);
        if ((len = sh_len + dh_len + ct_len) != 0) {
            char* temp = (char*) malloc(len + 1/*EOL*/);
            if (temp) {
                strcpy(temp,          static_header  ? static_header  : "");
                strcpy(temp + sh_len, dynamic_header ? dynamic_header : "");
                strcpy(temp + sh_len + dh_len, c_t);
                retval = temp;
            }
        } else
            retval = "";
    }

    if (dynamic_header)
        free(dynamic_header);
    return retval;
}
/*ARGSUSED*/
static const SLBSM_Sysinfo* s_GetSysinfo(const HOST_INFO hinfo,
                                         int/*bool*/     warn)
{
    const SLBSM_Sysinfo* si =
        (const SLBSM_Sysinfo*)((const char*) hinfo + sizeof(*hinfo));
    assert(hinfo);
#if defined(_DEBUG)  &&  !defined(NDEBUG)  &&  defined(NETDAEMONS_VERSION_INT)
    if (si->data.version < NETDAEMONS_VERSION_INT  &&  warn) {
        static int s_Warn = 0;
        if (s_Warn < 20) {
            char addr[64];
            if (SOCK_ntoa(hinfo->addr, addr, sizeof(addr)) != 0)
                strncpy0(addr, "unknown", sizeof(addr) - 1);
            CORE_LOGF(s_Warn++ < 5 ? eLOG_Warning : eLOG_Trace,
                      ("HINFO may be incorrect for obsolete daemon on %s"
                       " (detected=%hu.%hu.%hu, expected=%s+)", addr,
                       NETDAEMONS_MAJOR_OF(si->data.version),
                       NETDAEMONS_MINOR_OF(si->data.version),
                       NETDAEMONS_PATCH_OF(si->data.version),
                       NETDAEMONS_VERSION_STR));
        }
    }
#endif /*_DEBUG && !NDEBUG && NETDAEMONS_VERSION_INT*/
    return si;
}
Exemple #4
0
/*
 * 函数功能:读取授权机构代码
 * 入口参数:无
 * 出口参数:无
 * 返 回 值:NORMAL--成功
 *           EXCEPTION--失败
 */
int ProReadAuthOrgan(void)
{
    char szBuffer[30];
    char cRet;
    int nLen;

	if(strlen(TlvSendValue.szAuthOrgan)>0)
	{
        BUFCLR(szBuffer);
		memcpy(szBuffer,TlvSendValue.szAuthOrgan,11);
	}
	else
	{
	    PubClearAll();
	    PubDisplay(2, "输入授权机构代码:");

	    BUFCLR(szAuthOrgan);
	    do
	    {
	        BUFCLR(szBuffer);
	        cRet = PubGetNStr(4, 0, szBuffer, 11);
	        nLen = strlen(szBuffer);
	        if (cRet == CANCELED||cRet == APPTIMEOUT)
	            return EXCEPTION;
	    }
	    while (nLen != 11);
	}
//    strcpy(szAuthOrgan, szBuffer);
    strncpy0(szAuthOrgan, szBuffer, sizeof(szAuthOrgan));
    return NORMAL;
}
Exemple #5
0
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)
{//=========================================================================
	espeak_ERROR aStatus;

	InitText(flags);

	my_unique_identifier = unique_identifier;
	my_user_data = user_data;

	if(index_mark != NULL)
		{
		strncpy0(skip_marker, index_mark, sizeof(skip_marker));
		skipping_text = 1;
		}

	end_character_position = end_position;


	aStatus = Synthesize(unique_identifier, text, flags | espeakSSML);
	SHOW_TIME("LEAVE sync_espeak_Synth_Mark");

	return (aStatus);
}  //  end of sync_espeak_Synth_Mark
Exemple #6
0
/* !!! Expects that "txt" points to PATHBUF-sized buffer */
static void fpick_cleanse_path(char *txt)	// Clean up null terminated path
{
	char *src, *dest;

#ifdef WIN32
	// Unify path separators
	reseparate(txt);
#endif
	// Expand home directory
	if ((txt[0] == '~') && (txt[1] == DIR_SEP))
	{
		src = file_in_homedir(NULL, txt + 2, PATHBUF);
		strncpy0(txt, src, PATHBUF - 1);
		free(src);
	}
	// Remove multiple consecutive occurences of DIR_SEP
	if ((dest = src = strstr(txt, DIR_SEP_STR DIR_SEP_STR)))
	{
		while (*src)
		{
			if (*src == DIR_SEP) while (src[1] == DIR_SEP) src++;
			*dest++ = *src++;
		}
		*dest++ = '\0';
	}
}
Exemple #7
0
void CDROM::startTrack(const char *trackName) {
	if (!_LICbuffer)
		return;

	byte *matchPtr = getTrackBuffer(trackName);
	if (!matchPtr) {
		warning("CDROM: Track \"%s\" not found", trackName);
		return;
	}

	strncpy0(_curTrack, trackName, 15);

	stopPlaying();
	_curTrackBuffer = matchPtr;

	while (getTrackPos() >= 0)
		;

	uint32 start = READ_LE_UINT32(matchPtr + 12);
	uint32 end   = READ_LE_UINT32(matchPtr + 16);

	play(start, end);

	_startTime = g_system->getMillis();
	_trackStop = _startTime + (end - start + 1 + 150) * 40 / 3;
}
Exemple #8
0
/*
 * 函数功能:读取授权机构代码
 * 入口参数:无
 * 出口参数:无
 * 返 回 值:NORMAL--成功
 *           EXCEPTION--失败
 */
int ProReadAuthOrgan(void)
{
    char szBuffer[30];
    char cRet;
    int nLen;

    PubClearAll();
    PubDisplay(2, "输入授权机构代码:");

    BUFCLR(szAuthOrgan);
    do
    {
        BUFCLR(szBuffer);
        cRet = PubGetNStr(4, 0, szBuffer, 11);
        nLen = strlen(szBuffer);
        if (cRet == CANCELED||cRet == APPTIMEOUT)
            return EXCEPTION;
//add by baijz 20120625
		if(nLen == 11)
			break;
		PubDisplay(2, "位数不足,请重输:");
		PubDisplay(4, "");
//add end
    }
    while (nLen != 11);

//    strcpy(szAuthOrgan, szBuffer);
    strncpy0(szAuthOrgan, szBuffer, sizeof(szAuthOrgan));
    return NORMAL;
}
Exemple #9
0
static int
osip_boot_helper( int sel, int *args )
{
	char *ustr, *s, *p, *buf;
	
	switch( args[0] ) {
	case kBootHAscii2Unicode: /* unicode_dest, src, maxlen -- uni_strlen */
		ustr = transl_mphys( args[1] );
		s = transl_mphys( args[2] );
		if( !ustr || !s )
			return -1;
		return asc2uni( (unsigned char *)ustr, s, args[3] );

	case kBootHUnicode2Ascii: /* dest, uni_str, uni_strlen, maxlen -- strlen */
		s = transl_mphys( args[1] );
		ustr = transl_mphys( args[2] );
		if( !ustr || !s )
			return -1;
		return uni2asc( s, (unsigned char *)ustr, args[3], args[4] );

	case kBootHGetStrResInd: /* resname, buf, len, index, argnum */
		p = transl_mphys( args[1] );
		buf = transl_mphys( args[2] );
		if( !p || !(s=get_str_res_ind(p,args[4],args[5])) )
			return 0;
		if( args[2] && buf )
			strncpy0( buf, s, args[3] );
		return args[2];

	case kBootHGetRAMSize:
		return ram.size;
	}
	return -1;
}
Exemple #10
0
/* Scan directory, populate widgets; return 1 if success, 0 if total failure,
 * -1 if failed with original dir and scanned a different one */
static int fpick_scan_directory(fpick_dd *dt, char *name, char *select)
{
	DIR	*dp;
	char	*cp, *parent = NULL;
	char	full_name[PATHBUF];
	int len, fail, res = 1;


	strncpy0(full_name, name, PATHBUF - 1);
	len = strlen(full_name);
	/* Ensure the invariant */
	if (!len || (full_name[len - 1] != DIR_SEP))
		full_name[len++] = DIR_SEP , full_name[len] = 0;
	/* Step up the path till a searchable dir is found */
	fail = 0;
	while (!(dp = opendir(full_name)))
	{
		res = -1; // Remember that original path was invalid
		full_name[len - 1] = 0;
		cp = strrchr(full_name, DIR_SEP);
		// Try to go one level up
		if (cp) len = cp - full_name + 1;
		// No luck - restart with current dir
		else if (!fail++)
                {
			getcwd(full_name, PATHBUF - 1);
			len = strlen(full_name);
			full_name[len++] = DIR_SEP;
                }
		// If current dir hasn't helped either, give up
		else return (0);
		full_name[len] = 0;
	}

	/* If we're going up the path and want to show from where */
	if (!select)
	{
		if (!strncmp(dt->txt_directory, full_name, len) &&
			dt->txt_directory[len])
		{
			cp = strchr(dt->txt_directory + len, DIR_SEP); // Guaranteed
			parent = dt->txt_directory + len;
			select = parent = g_strndup(parent, cp - parent);
		}
	}
	/* If we've nothing to show */
	else if (!select[0]) select = NULL; 

	strncpy(dt->txt_directory, full_name, PATHBUF);
	fpick_directory_new(dt, full_name);	// Register directory in combo

	scan_dir(dt, dp, select);
	g_free(parent);
	closedir(dp);
	filter_dir(dt, dt->txt_mask);

	cmd_reset(dt->list, dt);

	return (res);
}
Exemple #11
0
static void faction_changed(spawn_dd *dt, void **wdata, int what, void **where)
{
	void *cause;
	spawn_row *rp;

	if (dt->lock) return;
	cause = cmd_read(where, dt);

	rp = dt->strs + dt->idx;
	if (cause == dt->dir) strncpy(rp->dir, dt->dir, sizeof(rp->dir));
	else
	{
		strncpy0(rp->name, dt->name, sizeof(rp->name));
		strncpy0(rp->cmd, dt->cmd, sizeof(rp->cmd));
		cmd_setv(dt->list, (void *)dt->idx, LISTC_RESET_ROW);
	}
}
Exemple #12
0
void DrawEnvelopes()
{//================
	int ix_env;
	int y_base;
	int x;
	FILE *f_txt=NULL;
	unsigned char *env;
	char name[200];

	wxBitmap bitmap(WD_ENV,HT_ENV*n_envelopes);

	// Create a memory DC
	wxMemoryDC dc;
	dc.SelectObject(bitmap);
	dc.SetBrush(*wxWHITE_BRUSH);
	dc.SetFont(*wxSWISS_FONT);
	dc.Clear();

	sprintf(name,"%s%s",path_source,"envelopes.txt");
//	f_txt = fopen(name,"w");

	for(ix_env=0; ix_env<n_envelopes; ix_env++)
	{
		y_base = HT_ENV * ix_env;
		dc.SetPen(*wxLIGHT_GREY_PEN);
		dc.DrawLine(0,y_base+0,256,y_base+0);
		dc.DrawLine(0,y_base+64,256,y_base+64);
		dc.DrawLine(0,y_base+128,256,y_base+128);
		dc.DrawLine(128,y_base+0,128,y_base+128);

		dc.SetPen(*wxBLACK_PEN);
		strncpy0(name,envelope_paths[ix_env],sizeof(name));
		dc.DrawText(wxString(name,wxConvLocal),1,y_base);

		env = envelope_dat[ix_env];
		y_base = y_base+128;
		for(x=0; x<127; x++)
		{
			dc.DrawLine(x*2, y_base-env[x]/2, (x+1)*2, y_base-env[x+1]/2);
		}

		if(f_txt != NULL)
		{
			fprintf(f_txt,"%s\n",name);
			for(x=0; x<128; x++)
			{
				fprintf(f_txt," 0x%.2x,",env[x]);
				if((x & 0xf) == 0xf)
					fputc('\n',f_txt);
			}
			fputc('\n',f_txt);
		}
	}

	bitmap.SaveFile(path_phsource+_T("/envelopes.png"),wxBITMAP_TYPE_PNG);
	if(f_txt != NULL)
		fclose(f_txt);
}
Exemple #13
0
espeak_ERROR SetVoiceByName(const char *name)
{//=========================================
	espeak_VOICE *v;
	int ix;
	espeak_VOICE voice_selector;
	char *variant_name;
	static char buf[60];

	strncpy0(buf,name,sizeof(buf));

	variant_name = ExtractVoiceVariantName(buf, 0, 1);

	for(ix=0; ; ix++)
	{
		// convert voice name to lower case  (ascii)
		if((buf[ix] = tolower(buf[ix])) == 0)
			break;
	}

	memset(&voice_selector,0,sizeof(voice_selector));
	voice_selector.name = (char *)name;  // include variant name in voice stack ??

	// first check for a voice with this filename
	// This may avoid the need to call espeak_ListVoices().

	if(LoadVoice(buf,1) != NULL)
	{
		if(variant_name[0] != 0)
		{
			LoadVoice(variant_name,2);
		}

		DoVoiceChange(voice);
		voice_selector.languages = voice->language_name;
		SetVoiceStack(&voice_selector, variant_name);
		return(EE_OK);
	}

	if(n_voices_list == 0)
		espeak_ListVoices(NULL);   // create the voices list

	if((v = SelectVoiceByName(voices_list,buf)) != NULL)
	{
		if(LoadVoice(v->identifier,0) != NULL)
		{
			if(variant_name[0] != 0)
			{
				LoadVoice(variant_name,2);
			}
			DoVoiceChange(voice);
			voice_selector.languages = voice->language_name;
			SetVoiceStack(&voice_selector, variant_name);
			return(EE_OK);
		}
	}
	return(EE_INTERNAL_ERROR);   // voice name not found
}  // end of SetVoiceByName
Exemple #14
0
static int
any_HOOK(TBUFF **rp, const char *vp, HOOK * hook)
{
    if (rp) {
	tb_scopy(rp, hook->proc);
	return TRUE;
    } else if (vp) {
	(void) strncpy0(hook->proc, vp, (size_t) NBUFN);
	return TRUE;
    } else {
	return FALSE;
    }
}
Exemple #15
0
espeak_VOICE *SelectVoiceByName(espeak_VOICE **voices, const char *name2)
{
	int ix;
	int match_fname = -1;
	int match_fname2 = -1;
	int match_name = -1;
	const char *id; // this is the filename within espeak-data/voices
	char *variant_name;
	int last_part_len;
	char last_part[41];
	char name[40];

	if (voices == NULL) {
		if (n_voices_list == 0)
			espeak_ListVoices(NULL); // create the voices list
		voices = voices_list;
	}

	strncpy0(name, name2, sizeof(name));
	if ((variant_name = strchr(name, '+')) != NULL) {
		*variant_name = 0;
		variant_name++;
	}

	sprintf(last_part, "%c%s", PATHSEP, name);
	last_part_len = strlen(last_part);

	for (ix = 0; voices[ix] != NULL; ix++) {
		if (strcasecmp(name, voices[ix]->name) == 0) {
			match_name = ix; // found matching voice name
			break;
		} else {
			id = voices[ix]->identifier;
			if (strcasecmp(name, id) == 0)
				match_fname = ix; // matching identifier, use this if no matching name
			else if (strcasecmp(last_part, &id[strlen(id)-last_part_len]) == 0)
				match_fname2 = ix;
		}
	}

	if (match_name < 0) {
		match_name = match_fname; // no matching name, try matching filename
		if (match_name < 0)
			match_name = match_fname2; // try matching just the last part of the filename
	}

	if (match_name < 0)
		return NULL;

	return voices[match_name];
}
Exemple #16
0
/* See documentation in header file. */
int
ini_parse(const char* filename, int
(*handler)(void*, const char*, const char*, const char*), void* user)
{
  FIL file;
  int error;

  if (f_open(&file, (TCHAR*) filename, FA_READ) != FR_OK)
    {
      strncpy0(ini_error, "f_open", 7);
      return -1;
    }
  error = ini_parse_file(&file, handler, user);
  f_close(&file);
  return error;
}
Exemple #17
0
static void s_MakeFrom(char* buf, size_t buf_size)
{
    size_t buf_len, hostname_len;

    if (!CORE_GetUsername(buf, buf_size)  ||  !*buf)
        strncpy0(buf, "anonymous", buf_size - 1);
    buf_len = strlen(buf);
    hostname_len = buf_size - buf_len;
    if (hostname_len-- > 1) {
        buf[buf_len++] = '@';
        if ((!SOCK_gethostbyaddr(0, &buf[buf_len], hostname_len)  ||
             !strchr(&buf[buf_len], '.'))
            &&  SOCK_gethostname(&buf[buf_len], hostname_len) != 0) {
            buf[--buf_len] = '\0';
        }
    }
}
Exemple #18
0
// reads a file from the SD card one line at a time
int fat_read_line(struct fat_file_struct* fd, uint8_t* buffer, uint8_t buffer_len)
{
	char internal[INI_MAX_LINE];
	int bytesRead, bytesToCopy;
	int32_t offset;
	char* pchar;
	
	bytesRead = fat_read_file(fd, internal, INI_MAX_LINE);
#if INI_DEBUG	
	printf("read_line start: bytesRead=%d\r\n", bytesRead);
#endif
	if(bytesRead > 0) { // 0 on EOF, bytes read for >0
		pchar = strchr(internal, '\n'); // return a pointer to the first newline
		if(pchar) { // if newline found, compute byte number for matching char
			bytesToCopy = pchar - internal + 1;
		}
		else { // if newline not found, copy all the bytes read
			bytesToCopy = bytesRead;
		}
		if(bytesToCopy > buffer_len) {
			// warn user or exit?
			bytesToCopy = buffer_len;
		}
		// copy the bytes to the destination buffer
		strncpy0(buffer, internal, bytesToCopy);

		// seek backwards from current file pointer to end of copied text
		offset = bytesToCopy - bytesRead;
		//offset = bytesToCopy;
#if INI_DEBUG		
		printf(	"offset=%d, bytesRead=%d, bytesToCopy=%d\r\n", 
				(int)offset, bytesRead, bytesToCopy);
#endif
		if(!fat_seek_file(fd, &offset, FAT_SEEK_CUR)) {
		//if(!fat_seek_file(fd, &offset, FAT_SEEK_SET)) {
#if INI_DEBUG			
			printf("fat_seek_file: failure\r\n");
#endif
		}
#if INI_DEBUG		
		printf("after seek: offset=%d\r\n", offset);
#endif
		return bytesToCopy;
	}
	return bytesRead;
}
Exemple #19
0
espeak_ng_STATUS sync_espeak_Synth_Mark(unsigned int unique_identifier, const void *text,
                                        const char *index_mark, unsigned int end_position,
                                        unsigned int flags, void *user_data)
{
	InitText(flags);

	my_unique_identifier = unique_identifier;
	my_user_data = user_data;

	if (index_mark != NULL) {
		strncpy0(skip_marker, index_mark, sizeof(skip_marker));
		skipping_text = true;
	}

	end_character_position = end_position;

	return Synthesize(unique_identifier, text, flags | espeakSSML);
}
Exemple #20
0
voice_t *LoadVoiceVariant(const char *vname, int variant_num)
{
	// Load a voice file.
	// Also apply a voice variant if specified by "variant", or by "+number" or "+name" in the "vname"

	voice_t *v;
	char *variant_name;
	char buf[60];

	strncpy0(buf, vname, sizeof(buf));
	variant_name = ExtractVoiceVariantName(buf, variant_num, 1);

	if ((v = LoadVoice(buf, 0)) == NULL)
		return NULL;

	if (variant_name[0] != 0)
		v = LoadVoice(variant_name, 2);
	return v;
}
Exemple #21
0
void Inter_v6::o6_openItk() {
	char fileName[32];

	_vm->_game->_script->evalExpr(0);
	strncpy0(fileName, _vm->_game->_script->getResultStr(), 27);
	if (!strchr(fileName, '.'))
		strcat(fileName, ".ITK");

	_vm->_dataIO->openDataFile(fileName, true);

	// WORKAROUND: The CD number detection in Urban Runner is quite daft
	// (it checks CD1.ITK - CD4.ITK and the first that's found determines
	// the CD number), while its NO_CD modus wants everything in CD1.ITK.
	// So we just open the other ITKs, too.
	if (_vm->_global->_noCd && !scumm_stricmp(fileName, "CD1.ITK")) {
		_vm->_dataIO->openDataFile("CD2.ITK", true);
		_vm->_dataIO->openDataFile("CD3.ITK", true);
		_vm->_dataIO->openDataFile("CD4.ITK", true);
	}
}
Exemple #22
0
static char *ExtractVoiceVariantName(char *vname, int variant_num)
{//===============================================================
// Remove any voice variant suffix (name or number) from a voice name
// Returns the voice variant name

	char *p;
	static char variant_name[20];
	char variant_prefix[5];

	variant_name[0] = 0;
	sprintf(variant_prefix,"!v%c",PATHSEP);

	if(vname != NULL)
	{
		if((p = strchr(vname,'+')) != NULL)
		{
			// The voice name has a +variant suffix
			*p++ = 0;   // delete the suffix from the voice name
			if(isdigit(*p))
			{
				variant_num = atoi(p);  // variant number
			}
			else
			{
				// voice variant name, not number
				strcpy(variant_name,variant_prefix);
				strncpy0(&variant_name[3],p,sizeof(variant_name)-3);
			}	
		}
	}
	
	if(variant_num > 0)
	{
		if(variant_num < 10)
			sprintf(variant_name,"%sm%d",variant_prefix, variant_num);  // male
		else
			sprintf(variant_name,"%sf%d",variant_prefix, variant_num-10);  // female
	}

	return(variant_name);
}  //  end of ExtractVoiceVariantName
Exemple #23
0
const char* DBLB_GetServerName(const char* lb_name,
                               char*       server_name_buf,
                               size_t      server_name_buflen,
                               const char* const skip_servers[],
                               char*       errmsg_buf,
                               size_t      errmsg_buflen)
{
    EDBLB_Status result;
    const char* retval =
        DBLB_GetServer(lb_name, fDBLB_None, 0/*preference*/, skip_servers,
                       0/*CP*/, server_name_buf, server_name_buflen,
                       &result);
    if (errmsg_buf) {
        const char* errstr;
        assert(errmsg_buflen);
        errstr = DBLB_StatusStr(result);
        strncpy0(errmsg_buf,
                 errstr ? errstr : "Unknown error", errmsg_buflen - 1);
    }
    return retval;
}
Exemple #24
0
void ProGetBaseDialFix(void)
{
    char szValue[100];
    char szGetBuf[30];
	int  i;
	uint nLen;

		// 银联商务要求每次都读主控应用的分机前缀
		BUFCLR(szValue);
		if(EA_ucParamFileFindPara("Base56x0", "parafile", "Base0004", &nLen, szValue) == EM_SUCCESS)
		{
			BUFCLR(szGetBuf);
			memcpy(szGetBuf, FV.gbNacInfo.szDialFix, 4);
			if (szValue[0] != 0)
			{
				strncpy0(szGetBuf + 4, szValue, sizeof(szGetBuf));
				for (i = 0; szGetBuf[i] != 0x0; i++)
					if (szGetBuf[i] == '.')
						szGetBuf[i] = ',';
			}
			strcpy(FV.gbNacInfo.szDialFix, szGetBuf);
		}

}
Exemple #25
0
static int/*bool*/ s_SockReadResponse(SOCK sock, int code, int alt_code,
                                      char* buf, size_t buf_size)
{
    int c = s_SockRead(sock, buf, buf_size);
    if (c <= 0) {
        const char* message = 0;
        switch (c) {
        case SMTP_READERR:
            message = "Read error";
            break;
        case SMTP_READTMO:
            message = "Read timed out";
            break;
        case SMTP_RESPERR:
            message = "Error reading response prefix";
            break;
        case SMTP_NOCODE:
            message = "No response code detected";
            break;
        case SMTP_BADCODE:
            message = "Response code doesn't match in lines";
            break;
        case SMTP_BADRESP:
            message = "Malformed response";
            break;
        default:
            message = "Unknown error";
            assert(0);
            break;
        }
        assert(message);
        strncpy0(buf, message, buf_size - 1);
    } else if (c == code  ||  (alt_code  &&  c == alt_code))
        return 1/*success*/;
    return 0/*failure*/;
}
Exemple #26
0
int write_final_state(control *c, params *p, state *s)
{
    /*
    Write the final state to the input param file so we can easily restart
    the model. This function copies the input param file with the exception
    of anything in the git hash and the state which it replaces with the updated
    stuff.

    */

    char line[STRING_LENGTH];
    char saved_line[STRING_LENGTH];
    char section[STRING_LENGTH] = "";
    char prev_name[STRING_LENGTH] = "";
    char *start;
    char *end;
    char *name;
    char *value;

    int error = 0;
    int line_number = 0;
    int match = FALSE;

    while (fgets(line, sizeof(line), c->ifp) != NULL) {
        strcpy(saved_line, line);
        line_number++;
        start = lskip(rstrip(line));
        if (*start == ';' || *start == '#') {
            /* Per Python ConfigParser, allow '#' comments at start of line */
        }
        else if (*start == '[') {
            /* A "[section]" line */
            end = find_char_or_comment(start + 1, ']');
            if (*end == ']') {
                *end = '\0';
                strncpy0(section, start + 1, sizeof(section));
                *prev_name = '\0';

            }
            else if (!error) {
                /* No ']' found on section line */
                error = line_number;

            }
        }
        else if (*start && *start != ';') {
            /* Not a comment, must be a name[=:]value pair */
            end = find_char_or_comment(start, '=');
            if (*end != '=') {
                end = find_char_or_comment(start, ':');
            }
            if (*end == '=' || *end == ':') {
                *end = '\0';
                name = rstrip(start);
                value = lskip(end + 1);
                end = find_char_or_comment(value, '\0');
                if (*end == ';')
                    *end = '\0';
                rstrip(value);

                /* Valid name[=:]value pair found, call handler */
                strncpy0(prev_name, name, sizeof(prev_name));

                if (!ohandler(section, name, value, c, p, s, &match) && !error)
                    error = line_number;
            }
            else if (!error) {
                /* No '=' or ':' found on name[=:]value line */
                error = line_number;
                break;
            }
        }
        if (match == FALSE)
            fprintf(c->ofp, "%s", saved_line);
        else
            match = FALSE; /* reset match flag */
    }
    return error;

}
Exemple #27
0
int ini_parse_string_impl(const std::string & s,
                          int (*handler)(void*, const char*, const char*,
                                         const char*),
                          void* user)
{
    std::istringstream input(s);

    /* Uses a fair bit of stack (use heap instead if you need to) */
    char section[MAX_INI_STRING] = "";

    bool has_group = false;
    int lineno = 0;
    int error = 0;

    /* Scan through file line by line */
    while (!at_end(input)) {
        std::string newline;
        get_line(input, newline);
        char * line = (char*)newline.c_str();
        lineno++;

        char * start = line;
        char * end;

        // UTF-8 BOM
        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
                           (unsigned char)start[1] == 0xBB &&
                           (unsigned char)start[2] == 0xBF) {
            start += 3;
        }

        start = lskip(rstrip(start));

        char c = *start;

        if (c == ';' || c == '#' || (c == '/' && start[1] == '/')) {
            /* Per Python ConfigParser, allow '#' comments at start of line */
        } else if (c == '[') {
            /* A "[section]" line */
            end = find_char_or_comment(start + 1, ']');
            if (*end == ']') {
                *end = '\0';
                strncpy0(section, start + 1, sizeof(section));
                has_group = true;
            } else if (!error) {
                /* No ']' found on section line */
                error = lineno;
            }
        } else if (c && c != ';' && has_group) {
            /* Not a comment, must be a name[=:]value pair */
            end = find_char_or_comment(start, '=');
            if (*end != '=') {
                end = find_char_or_comment(start, ':');
            }
            if (*end == '=' || *end == ':') {
                *end = '\0';
                char * name = rstrip(start);
                char * value = lskip(end + 1);
                end = find_char_or_comment(value, '\0');
                if (*end == ';')
                    *end = '\0';
                rstrip(value);

                /* Valid name[=:]value pair found, call handler */
                if (!handler(user, section, name, value) && !error)
                    error = lineno;
            } else if (!error) {
                /* No '=' or ':' found on name[=:]value line */
                error = lineno;
            }
        }
    }

    return error;
}
Exemple #28
0
/* See documentation in header file. */
int ini_parse_file(FILE* file,const struct IniConfig* config, void* user)
{
    /* Uses a fair bit of stack (use heap instead if you need to) */
#if INI_USE_STACK
    char line[INI_MAX_LINE];
#else
    char* line;
#endif
    char section[MAX_SECTION] = "";
    char prev_name[MAX_NAME] = "";

    char* start;
    char* end;
    char* name;
    char* value;
    int lineno = 0;
    int error = 0;

#if !INI_USE_STACK
    line = (char*)malloc(INI_MAX_LINE);
    if (!line) {
        return -2;
    }
#endif

    /* Scan through file line by line */
    while (fgets(line, INI_MAX_LINE, file) != NULL) {
        lineno++;

        start = line;
#if INI_ALLOW_BOM
        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
                           (unsigned char)start[1] == 0xBB &&
                           (unsigned char)start[2] == 0xBF) {
            start += 3;
        }
#endif
        start = lskip(rstrip(start));

        if (*start == ';' || *start == '#') {
        	start += 1;
        	if (!config->commentHandler(user, start) && !error)
        		error = lineno;
            /* Per Python ConfigParser, allow '#' comments at start of line */
        }

        else if (config->supportMultiline && *prev_name && *start && start > line) {
            /* Non-black line with leading whitespace, treat as continuation
               of previous name's value (as per Python ConfigParser). */
            if (!config->keyHandler(user, section, prev_name, start, 1) && !error)
                error = lineno;
        }
        else if (*start == '[') {
            /* A "[section]" line */
            end = find_char_or_comment(start + 1, ']');
            if (*end == ']') {
                *end = '\0';
                strncpy0(section, start + 1, sizeof(section));
                *prev_name = '\0';
                if(!config->sectionHandler(user, section) && !error)
                	error = lineno;
            }
            else if (!error) {
                /* No ']' found on section line */
                error = lineno;
            }
        }
        else if (*start && *start != ';') {
            /* Not a comment, must be a name[=:]value pair */
            end = find_char_or_comment(start, '=');
            if (*end != '=') {
                end = find_char_or_comment(start, ':');
            }
            if (*end == '=' || *end == ':') {
                *end = '\0';
                name = rstrip(start);
                value = lskip(end + 1);
                end = find_char_or_comment(value, '\0');
                if (*end == ';')
                    *end = '\0';
                rstrip(value);

                /* Valid name[=:]value pair found, call handler */
                strncpy0(prev_name, name, sizeof(prev_name));
                if (!config->keyHandler(user, section, name, value, 0) && !error)
                    error = lineno;
            }
            else if (!error) {
                /* No '=' or ':' found on name[=:]value line */
                error = lineno;
            }
        }

#if INI_STOP_ON_FIRST_ERROR
        if (error)
            break;
#endif
    }

#if !INI_USE_STACK
    free(line);
#endif

    return error;
}
Exemple #29
0
    // read and parse
    int load(const char* filename) {
        FILE *file = fopen(filename, "r");
        if(!file) return false;

        char *line = new char[INI_MAX_LINE];
        std::string prev_value, prev_name;
        char *section = new char [MAX_SECTION];
        *section = '\0';

        int  bMultiline = 0;
        int lineno = 0, error=0;
        char *start, *end, *name, *value;
        while (fgets(line, INI_MAX_LINE, file) != NULL) {
            lineno++;
            start = line;
            start = lskip(start);
            // remove comment
            end = find_char_or_comment(start, '\0');
            if( *end != '\0' )  // it points to a comment char
                *end = '\0';
            rstrip(start, &end);

            if( start == end )
                continue;

            if ( bMultiline ) {
                if( *(end-1) == '\\' && (end-1 == start || *(end-2) == ' ') )  { // continue reading next line
                    // remove " \"
                    *(--end) = '\0';
                    if( end > start && *(end-1) == ' ')
                        *(--end) = '\0';

                    prev_value += start;
                }
                else{
                    prev_value += start;
                    if( !handle_record(section, prev_name.c_str(), prev_value.c_str()) )
                        error = lineno;
                    bMultiline = 0;
                    prev_value = "";
                    prev_name = "";
                }
            }
            else if( *start == '[' ) { // found section
                end = find_char_or_comment(start + 1, ']');
                if (*end == ']') {
                    *end = '\0';
                    strncpy0(section, start + 1, MAX_SECTION);
                }
                else{
                    /* No ']' found on section line */
                    error = lineno;
                }
                bMultiline = false;
            }
            else {
                /* Not a comment, must be a name[=:]value pair */
                bMultiline = false;
                char *nend = find_char_or_comment(start, '=');
                if (*nend != '=') {
                    nend = find_char_or_comment(start, ':');
                }
                if (*nend == '=' || *nend == ':') {
                    *nend = '\0';
                    value = lskip(nend + 1);
                    name = rstrip(start, &nend);

                    /* Valid name[=:]value pair found, call handler */
                    if( *(end-1) == '\\' && (end-1 == value || *(end-2) == ' ') )  { // continue reading next line
                        // remove " \"
                        *(--end) = '\0';
                        if( end > value && *(end-1) == ' ')
                            *(--end) = '\0';

                        prev_value = value;
                        prev_name = name;
                        bMultiline = true;
                    }
                    if( !bMultiline ) if (!handle_record(section, name, value))
                        error = lineno;
                }
                else if (!error) {
                    /* No '=' or ':' found on name[=:]value line */
                    error = lineno;
                }
            }
            if (error)
                break;
        } // while getline

        fclose(file);
        delete [] line;
        delete [] section;
        return error;
    } // read function
Exemple #30
0
int main(int argc, char **argv)
{
	static struct option long_options[] = {
		{ "help",    no_argument,       0, 'h' },
		{ "stdin",   no_argument,       0, 0x100 },
		{ "compile-debug", optional_argument, 0, 0x101 },
		{ "compile", optional_argument, 0, 0x102 },
		{ "punct",   optional_argument, 0, 0x103 },
		{ "voices",  optional_argument, 0, 0x104 },
		{ "stdout",  no_argument,       0, 0x105 },
		{ "split",   optional_argument, 0, 0x106 },
		{ "path",    required_argument, 0, 0x107 },
		{ "phonout", required_argument, 0, 0x108 },
		{ "pho",     no_argument,       0, 0x109 },
		{ "ipa",     optional_argument, 0, 0x10a },
		{ "version", no_argument,       0, 0x10b },
		{ "sep",     optional_argument, 0, 0x10c },
		{ "tie",     optional_argument, 0, 0x10d },
		{ "compile-mbrola", optional_argument, 0, 0x10e },
		{ "compile-intonations", no_argument, 0, 0x10f },
		{ "compile-phonemes", optional_argument, 0, 0x110 },
		{ 0, 0, 0, 0 }
	};

	FILE *f_text = NULL;
	char *p_text = NULL;
	FILE *f_phonemes_out = stdout;
	char *data_path = NULL; // use default path for espeak-ng-data

	int option_index = 0;
	int c;
	int ix;
	char *optarg2;
	int value;
	int flag_stdin = 0;
	int flag_compile = 0;
	int filesize = 0;
	int synth_flags = espeakCHARS_AUTO | espeakPHONEMES | espeakENDPAUSE;

	int volume = -1;
	int speed = -1;
	int pitch = -1;
	int wordgap = -1;
	int option_capitals = -1;
	int option_punctuation = -1;
	int phonemes_separator = 0;
	int phoneme_options = 0;
	int option_linelength = 0;
	int option_waveout = 0;

	espeak_VOICE voice_select;
	char filename[200];
	char voicename[40];
	char devicename[200];
	#define N_PUNCTLIST 100
	wchar_t option_punctlist[N_PUNCTLIST];

	voicename[0] = 0;
	wavefile[0] = 0;
	filename[0] = 0;
	devicename[0] = 0;
	option_punctlist[0] = 0;

	while (true) {
		c = getopt_long(argc, argv, "a:b:d:f:g:hk:l:mp:qs:v:w:xXz",
		                long_options, &option_index);

		// Detect the end of the options.
		if (c == -1)
			break;
		optarg2 = optarg;

		switch (c)
		{
		case 'b':
			// input character encoding, 8bit, 16bit, UTF8
			if ((sscanf(optarg2, "%d", &value) == 1) && (value <= 4))
				synth_flags |= value;
			else
				synth_flags |= espeakCHARS_8BIT;
			break;
		case 'd':
			strncpy0(devicename, optarg2, sizeof(devicename));
			break;
		case 'h':
			printf("\n");
			PrintVersion();
			printf("%s", help_text);
			return 0;
		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 = true;
			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
			if (optarg2 != NULL && *optarg2) {
				strncpy0(voicename, optarg2, sizeof(voicename));
				flag_compile = c;
				quiet = true;
				break;
			} else {
				fprintf(stderr, "Voice name to '%s' not specified.\n", c == 0x101 ? "--compile-debug" : "--compile");
				exit(EXIT_FAILURE);
			}
		case 0x103: // --punct
			option_punctuation = 1;
			if (optarg2 != NULL) {
				ix = 0;
				while ((ix < N_PUNCTLIST) && ((option_punctlist[ix] = optarg2[ix]) != 0)) ix++;
				option_punctlist[N_PUNCTLIST-1] = 0;
				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) {
				// deprecated and obsolete
				switch (atoi(optarg2))
				{
				case 1:
					phonemes_separator = '_';
					break;
				case 2:
					phonemes_separator = 0x0361;
					phoneme_options |= espeakPHONEMES_TIE;
					break;
				case 3:
					phonemes_separator = 0x200d; // ZWJ
					phoneme_options |= espeakPHONEMES_TIE;
					break;
				}

			}
			break;
		case 0x10b: // --version
			PrintVersion();
			exit(0);
		case 0x10c: // --sep
			phoneme_options |= espeakPHONEMES_SHOW;
			if (optarg2 == 0)
				phonemes_separator = ' ';
			else
				utf8_in(&phonemes_separator, optarg2);
			if (phonemes_separator == 'z')
				phonemes_separator = 0x200c; // ZWNJ
			break;
		case 0x10d: // --tie
			phoneme_options |= (espeakPHONEMES_SHOW | espeakPHONEMES_TIE);
			if (optarg2 == 0)
				phonemes_separator = 0x0361; // default: combining-double-inverted-breve
			else
				utf8_in(&phonemes_separator, optarg2);
			if (phonemes_separator == 'z')
				phonemes_separator = 0x200d; // ZWJ
			break;
		case 0x10e: // --compile-mbrola
		{
			espeak_ng_InitializePath(data_path);
			espeak_ng_ERROR_CONTEXT context = NULL;
			espeak_ng_STATUS result = espeak_ng_CompileMbrolaVoice(optarg2, stdout, &context);
			if (result != ENS_OK) {
				espeak_ng_PrintStatusCodeMessage(result, stderr, context);
				espeak_ng_ClearErrorContext(&context);
				return EXIT_FAILURE;
			}
			return EXIT_SUCCESS;
		}
		case 0x10f: // --compile-intonations
		{
			espeak_ng_InitializePath(data_path);
			espeak_ng_ERROR_CONTEXT context = NULL;
			espeak_ng_STATUS result = espeak_ng_CompileIntonation(stdout, &context);
			if (result != ENS_OK) {
				espeak_ng_PrintStatusCodeMessage(result, stderr, context);
				espeak_ng_ClearErrorContext(&context);
				return EXIT_FAILURE;
			}
			return EXIT_SUCCESS;
		}
		case 0x110: // --compile-phonemes
		{
			espeak_ng_InitializePath(data_path);
			espeak_ng_ERROR_CONTEXT context = NULL;
			espeak_ng_STATUS result;
			if (optarg2) {
				result = espeak_ng_CompilePhonemeDataPath(22050, optarg2, NULL, stdout, &context);
			} else {
				result = espeak_ng_CompilePhonemeData(22050, stdout, &context);
			}
			if (result != ENS_OK) {
				espeak_ng_PrintStatusCodeMessage(result, stderr, context);
				espeak_ng_ClearErrorContext(&context);
				return EXIT_FAILURE;
			}
			return EXIT_SUCCESS;
		}
		default:
			exit(0);
		}
	}

	espeak_ng_InitializePath(data_path);
	espeak_ng_ERROR_CONTEXT context = NULL;
	espeak_ng_STATUS result = espeak_ng_Initialize(&context);
	if (result != ENS_OK) {
		espeak_ng_PrintStatusCodeMessage(result, stderr, context);
		espeak_ng_ClearErrorContext(&context);
		exit(1);
	}

	if (option_waveout || quiet) {
		// writing to a file (or no output), we can use synchronous mode
		result = espeak_ng_InitializeOutput(ENOUTPUT_MODE_SYNCHRONOUS, 0, devicename[0] ? devicename : NULL);
		samplerate = espeak_ng_GetSampleRate();
		samples_split = samplerate * samples_split_seconds;

		espeak_SetSynthCallback(SynthCallback);
		if (samples_split) {
			char *extn;
			extn = strrchr(wavefile, '.');
			if ((extn != NULL) && ((wavefile + strlen(wavefile) - extn) <= 4)) {
				strcpy(filetype, extn);
				*extn = 0;
			}
		}
	} else {
		// play the sound output
		result = espeak_ng_InitializeOutput(PLAYBACK_MODE, 0, devicename[0] ? devicename : NULL);
		samplerate = espeak_ng_GetSampleRate();
	}

	if (result != ENS_OK) {
		espeak_ng_PrintStatusCodeMessage(result, stderr, NULL);
		exit(EXIT_FAILURE);
	}

	if (voicename[0] == 0)
		strcpy(voicename, ESPEAKNG_DEFAULT_VOICE);

	result = espeak_ng_SetVoiceByName(voicename);
	if (result != ENS_OK) {
		memset(&voice_select, 0, sizeof(voice_select));
		voice_select.languages = voicename;
		result = espeak_ng_SetVoiceByProperties(&voice_select);
		if (result != ENS_OK) {
			espeak_ng_PrintStatusCodeMessage(result, stderr, NULL);
			exit(EXIT_FAILURE);
		}
	}

	if (flag_compile) {
		// This must be done after the voice is set
		espeak_ng_ERROR_CONTEXT context = NULL;
		espeak_ng_STATUS result = espeak_ng_CompileDictionary("", NULL, stderr, flag_compile & 0x1, &context);
		if (result != ENS_OK) {
			espeak_ng_PrintStatusCodeMessage(result, stderr, context);
			espeak_ng_ClearErrorContext(&context);
			return EXIT_FAILURE;
		}
		return EXIT_SUCCESS;
	}

	// set any non-default values of parameters. This must be done after espeak_Initialize()
	if (speed > 0)
		espeak_SetParameter(espeakRATE, speed, 0);
	if (volume >= 0)
		espeak_SetParameter(espeakVOLUME, volume, 0);
	if (pitch >= 0)
		espeak_SetParameter(espeakPITCH, pitch, 0);
	if (option_capitals >= 0)
		espeak_SetParameter(espeakCAPITALS, option_capitals, 0);
	if (option_punctuation >= 0)
		espeak_SetParameter(espeakPUNCTUATION, option_punctuation, 0);
	if (wordgap >= 0)
		espeak_SetParameter(espeakWORDGAP, wordgap, 0);
	if (option_linelength > 0)
		espeak_SetParameter(espeakLINELENGTH, option_linelength, 0);
	if (option_punctuation == 2)
		espeak_SetPunctuationList(option_punctlist);

	espeak_SetPhonemeTrace(phoneme_options | (phonemes_separator << 8), f_phonemes_out);

	if (filename[0] == 0) {
		if ((optind < argc) && (flag_stdin == 0)) {
			// there's a non-option parameter, and no -f or --stdin
			// use it as text
			p_text = argv[optind];
		} else {
			f_text = stdin;
			if (flag_stdin == 0)
				flag_stdin = 2;
		}
	} else {
		struct stat st;
		if (stat(filename, &st) != 0) {
			fprintf(stderr, "Failed to stat() file '%s'\n", filename);
			exit(EXIT_FAILURE);
		}
		filesize = GetFileLength(filename);
		f_text = fopen(filename, "r");
		if (f_text == NULL) {
			fprintf(stderr, "Failed to read file '%s'\n", filename);
			exit(EXIT_FAILURE);
		}
		if (S_ISFIFO(st.st_mode)) {
			flag_stdin = 2;
		}
	}

	if (p_text != NULL) {
		int size;
		size = strlen(p_text);
		espeak_Synth(p_text, size+1, 0, POS_CHARACTER, 0, synth_flags, NULL, NULL);
	} else if (flag_stdin) {
		size_t max = 1000;
		if ((p_text = (char *)malloc(max)) == NULL) {
			espeak_ng_PrintStatusCodeMessage(ENOMEM, stderr, NULL);
			exit(EXIT_FAILURE);
		}

		if (flag_stdin == 2) {
			// line by line input on stdin or from FIFO
			while (fgets(p_text, max, f_text) != NULL) {
				p_text[max-1] = 0;
				espeak_Synth(p_text, max, 0, POS_CHARACTER, 0, synth_flags, NULL, NULL);
				// Allow subprocesses to use the audio data through pipes.
				fflush(stdout);
			}
			if (f_text != stdin) {
				fclose(f_text);
			}
		} else {
			// bulk input on stdin
			ix = 0;
			while (true) {
				if ((c = fgetc(stdin)) == EOF)
					break;
				p_text[ix++] = (char)c;
				if (ix >= (max-1)) {
					char *new_text = NULL;
					if (max <= SIZE_MAX - 1000) {
						max += 1000;
						new_text = (char *)realloc(p_text, max);
					}
					if (new_text == NULL) {
						free(p_text);
						espeak_ng_PrintStatusCodeMessage(ENOMEM, stderr, NULL);
						exit(EXIT_FAILURE);
					}
					p_text = new_text;
				}
			}
			if (ix > 0) {
				p_text[ix-1] = 0;
				espeak_Synth(p_text, ix+1, 0, POS_CHARACTER, 0, synth_flags, NULL, NULL);
			}
		}

		free(p_text);
	} else if (f_text != NULL) {
		if ((p_text = (char *)malloc(filesize+1)) == NULL) {
			espeak_ng_PrintStatusCodeMessage(ENOMEM, stderr, NULL);
			exit(EXIT_FAILURE);
		}

		fread(p_text, 1, filesize, f_text);
		p_text[filesize] = 0;
		espeak_Synth(p_text, filesize+1, 0, POS_CHARACTER, 0, synth_flags, NULL, NULL);
		fclose(f_text);

		free(p_text);
	}

	result = espeak_ng_Synchronize();
	if (result != ENS_OK) {
		espeak_ng_PrintStatusCodeMessage(result, stderr, NULL);
		exit(EXIT_FAILURE);
	}

	if (f_phonemes_out != stdout)
		fclose(f_phonemes_out);

	CloseWavFile();
	espeak_ng_Terminate();
	return 0;
}