initial separation from ttsservice into a separate project

main
vampi 3 months ago
parent 275cbcedc4
commit f0caedfcac

5
.gitignore vendored

@ -0,0 +1,5 @@
.vs
Release
Debug
sapicli.vcxproj.filters
sapicli.vcxproj.user

@ -1,3 +1,6 @@
# sapicli
SAPI command line interface
===========================
Command line tool to generate audio using SAPI.
A simple tool to generate a `.wav` file from text.
Using [getoptW](https://github.com/bluebaroncanada/getoptW).

@ -0,0 +1,804 @@
/*
* getoptW.c
*
* Implementation of the `getoptW', `getoptW_longW' and `getoptW_long_onlyW'
* APIs, for inclusion in the MinGW runtime library.
*
* This file is part of the MinGW32 package set.
*
* Written by Keith Marshall <keithmarshall@users.sourceforge.net>
* Copyright (C) 2008, 2009, 2011, 2012, MinGW.org Project.
*
* ---------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice, this permission notice, and the following
* disclaimer shall be included in all copies or substantial portions of
* the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* This licence is governed by the laws of Ontario, Canada and any dispute
* shall be finally resolved by the courts in London, Ontario, Canada.
*
* ---------------------------------------------------------------------------
*
*/
#ifndef UNICODE
#define UNICODE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "getoptW.h"
#include <tchar.h>
#include <crtdefs.h>
/* Identify how to get the calling program name, for use in messages...
*/
#ifdef __CYGWIN__
/*
* CYGWIN uses this DLL reference...
*/
# define PROGNAME __progname
extern char __declspec(dllimport) *__progname;
#else
/*
* ...while elsewhere, we simply use the first argument passed.
*/
# define PROGNAME *argv
#endif
/* Initialise the public variables. */
int optind = 1; /* index for first non-option arg */
int opterr = 1; /* enable built-in error messages */
#define WCHAR wchar_t /* argument type selector */
WCHAR *optarg = NULL; /* pointer to current option argument */
#define getoptW_switchar L'-' /* option prefix character in argv */
#define getoptW_pluschar L'+' /* prefix for POSIX mode in optstring */
#define getoptW_takes_argument L':' /* marker for optarg in optstring */
#define getoptW_arg_assign L'=' /* longopt argument field separator */
#define getoptW_unknown L'?' /* return code for unmatched option */
#define getoptW_ordered 1 /* return code for ordered non-option */
#define getoptW_all_done -1 /* return code to indicate completion */
enum
{ /* All `getoptW' API functions are implemented via calls to the
* common static function `getoptW_parse()'; these `mode' selectors
* determine the behaviour of `getoptW_parse()', to deliver the
* appropriate result in each case.
*/
getoptW_mode_standard = 0, /* getoptW() */
getoptW_mode_long, /* getoptW_long() */
getoptW_mode_long_only /* getoptW_long_only() */
};
enum
{ /* When attempting to match a command line argument to a long form option,
* these indicate the status of the match.
*/
getoptW_no_match = 0, /* no successful match */
getoptW_abbreviated_match, /* argument is an abbreviation for an option */
getoptW_exact_match /* argument matches the full option name */
};
int optopt = getoptW_unknown; /* return value for option being evaluated */
/* Some BSD applications expect to be able to reinitialise `getoptW' parsing
* by setting a global variable called `optreset'. We provide an obfuscated
* API, which allows applications to emulate this brain damage; however, any
* use of this is non-portable, and is strongly discouraged.
*/
#define optreset __mingw_optreset
int optreset = 0;
static __inline__
int getoptW_missing_arg( const WCHAR *optstring )
{
/* Helper function to determine the appropriate return value,
* for the case where a required option argument is missing.
*/
if( (*optstring == getoptW_pluschar) || (*optstring == getoptW_switchar) )
++optstring;
return (*optstring == getoptW_takes_argument)
? getoptW_takes_argument
: getoptW_unknown;
}
/* `complain' macro facilitates the generation of simple built-in
* error messages, displayed on various fault conditions, provided
* `opterr' is non-zero.
*/
#define complain( MSG, ARG ) if( opterr ) \
fwprintf( stderr, L"%ls: " MSG L"\n", PROGNAME, ARG )
static __inline__
int getoptW_argerror( int mode, WCHAR *fmt, WCHAR *prog, struct option *opt, int retval )
{
/* Helper function, to generate more complex built-in error
* messages, for invalid arguments to long form options ...
*/
if( opterr )
{
/* ... but, displayed only if `opterr' is non-zero.
*/
WCHAR flag[] = L"--";
if( mode != getoptW_mode_long )
/*
* only display one hyphen, for implicit long form options,
* improperly resolved by `getoptW_long_only()'.
*/
flag[1] = L'\0';
/*
* always preface the program name ...
*/
fwprintf( stderr, L"%ls: ", prog );
/*
* to the appropriate, option specific message.
*/
fwprintf( stderr, fmt, flag, opt->name );
}
/* Whether displaying the message, or not, always set `optopt'
* to identify the faulty option ...
*/
optopt = opt->val;
/*
* and return the `invalid option' indicator.
*/
return retval;
}
/* `getoptW_conventions' establish behavioural options, to control
* the operation of `getoptW_parse()', e.g. to select between POSIX
* and GNU style argument parsing behaviour.
*/
#define getoptW_set_conventions 0x1000
#define getoptW_posixly_correct 0x0010
static __inline__
int getoptW_conventions( int flags )
{
static int conventions = 0;
if( (conventions == 0) && ((flags & getoptW_set_conventions) == 0) )
{
/* default conventions have not yet been established;
* initialise them now!
*/
conventions = getoptW_set_conventions;
if( (flags == getoptW_pluschar)/* || (getenv( "POSIXLY_CORRECT" ) != NULL) */)
conventions |= getoptW_posixly_correct;
}
else if( flags & getoptW_set_conventions )
/*
* default conventions may have already been established,
* but this is a specific request to augment them.
*/
conventions |= flags;
/* in any event, return the currently established conventions.
*/
return conventions;
}
static __inline__
int is_switchar( WCHAR flag )
{
/* A simple helper function, used to identify the switch character
* introducing an optional command line argument.
*/
return flag == getoptW_switchar;
}
static __inline__
const WCHAR *getoptW_match( WCHAR lookup, const WCHAR *opt_string )
{
/* Helper function, used to identify short form options.
*/
if( (*opt_string == getoptW_pluschar) || (*opt_string == getoptW_switchar) )
++opt_string;
if( *opt_string == getoptW_takes_argument )
++opt_string;
do if( lookup == *opt_string ) return opt_string;
while( *++opt_string );
return NULL;
}
static __inline__
int getoptW_match_long( const WCHAR *nextchar, const WCHAR *optname )
{
/* Helper function, used to identify potential matches for
* long form options.
*/
WCHAR matchchar;
while( (matchchar = *nextchar++) && (matchchar == *optname) )
/*
* skip over initial substring which DOES match.
*/
++optname;
if( matchchar )
{
/* did NOT match the entire argument to an initial substring
* of a defined option name ...
*/
if( matchchar != getoptW_arg_assign )
/*
* ... and didn't stop at an `=' internal field separator,
* so this is NOT a possible match.
*/
return getoptW_no_match;
/* DID stop at an `=' internal field separator,
* so this IS a possible match, and what follows is an
* argument to the possibly matched option.
*/
optarg = (WCHAR *)(nextchar);
}
return *optname
/*
* if we DIDN'T match the ENTIRE text of the option name,
* then it's a possible abbreviated match ...
*/
? getoptW_abbreviated_match
/*
* but if we DID match the entire option name,
* then it's a DEFINITE EXACT match.
*/
: getoptW_exact_match;
}
static __inline__
int getoptW_resolved( int mode, int argc, WCHAR *const *argv, int *argind,
struct option *opt, int index, int *retindex, const WCHAR *optstring )
{
/* Helper function to establish appropriate return conditions,
* on resolution of a long form option.
*/
if( retindex != NULL )
*retindex = index;
/* On return, `optind' should normally refer to the argument, if any,
* which follows the current one; it is convenient to set this, before
* checking for the presence of any `optarg'.
*/
optind = *argind + 1;
if( optarg && (opt[index].has_arg == no_argument) )
/*
* it is an error for the user to specify an option specific argument
* with an option which doesn't expect one!
*/
return getoptW_argerror( mode, L"option `%ls%ls' doesn't accept an argument\n",
PROGNAME, opt + index, getoptW_unknown );
else if( (optarg == NULL) && (opt[index].has_arg == required_argument) )
{
/* similarly, it is an error if no argument is specified
* with an option which requires one ...
*/
if( optind < argc )
/*
* ... except that the requirement may be satisfied from
* the following command line argument, if any ...
*/
optarg = argv[*argind = optind++];
else
/* so fail this case, only if no such argument exists!
*/
return getoptW_argerror( mode, L"option `%ls%ls' requires an argument\n",
PROGNAME, opt + index, getoptW_missing_arg( optstring ) );
}
/* when the caller has provided a return buffer ...
*/
if( opt[index].flag != NULL )
{
/* ... then we place the proper return value there,
* and return a status code of zero ...
*/
*(opt[index].flag) = opt[index].val;
return 0;
}
/* ... otherwise, the return value becomes the status code.
*/
return opt[index].val;
}
static __inline__
int getoptW_verify( const WCHAR *nextchar, const WCHAR *optstring )
{
/* Helper function, called by getoptW_parse() when invoked
* by getoptW_long_only(), to verify when an unmatched or an
* ambiguously matched long form option string is valid as
* a short form option specification.
*/
if( ! (nextchar && *nextchar && optstring && *optstring) )
/*
* There are no characters to be matched, or there are no
* valid short form option characters to which they can be
* matched, so this can never be valid.
*/
return 0;
while( *nextchar )
{
/* For each command line character in turn ...
*/
const WCHAR *test;
if( (test = getoptW_match( *nextchar++, optstring )) == NULL )
/*
* ... there is no short form option to match the current
* candidate, so the entire argument fails.
*/
return 0;
if( test[1] == getoptW_takes_argument )
/*
* The current candidate is valid, and it matches an option
* which takes an argument, so this command line argument is
* a valid short form option specification; accept it.
*/
return 1;
}
/* If we get to here, then every character in the command line
* argument was valid as a short form option; accept it.
*/
return 1;
}
static
#define getoptW_std_args int argc, WCHAR *const argv[], const WCHAR *optstring
int getoptW_parse( int mode, getoptW_std_args, ... )
{
/* Common core implementation for ALL `getoptW' functions.
*/
static int argind = 0;
static int optbase = 0;
static const WCHAR *nextchar = NULL;
static int optmark = 0;
if( (optreset |= (optind < 1)) || (optind < optbase) )
{
/* POSIX does not prescribe any definitive mechanism for restarting
* a `getoptW' scan, but some applications may require such capability.
* We will support it, by allowing the caller to adjust the value of
* `optind' downwards, (nominally setting it to zero). Since POSIX
* wants `optind' to have an initial value of one, but we want all
* of our internal place holders to be initialised to zero, when we
* are called for the first time, we will handle such a reset by
* adjusting all of the internal place holders to one less than
* the adjusted `optind' value, (but never to less than zero).
*/
if( optreset )
{
/* User has explicitly requested reinitialisation...
* We need to reset `optind' to it's normal initial value of 1,
* to avoid a potential infinitely recursive loop; by doing this
* up front, we also ensure that the remaining place holders
* will be correctly reinitialised to no less than zero.
*/
optind = 1;
/* We also need to clear the `optreset' request...
*/
optreset = 0;
}
/* Now, we may safely reinitialise the internal place holders, to
* one less than `optind', without fear of making them negative.
*/
optmark = optbase = argind = optind - 1;
nextchar = NULL;
}
/* From a POSIX perspective, the following is `undefined behaviour';
* we implement it thus, for compatibility with GNU and BSD getoptW.
*/
else if( optind > (argind + 1) )
{
/* Some applications expect to be able to manipulate `optind',
* causing `getoptW' to skip over one or more elements of `argv';
* POSIX doesn't require us to support this brain-damaged concept;
* (indeed, POSIX defines no particular behaviour, in the event of
* such usage, so it must be considered a bug for an application
* to rely on any particular outcome); nonetheless, Mac-OS-X and
* BSD actually provide *documented* support for this capability,
* so we ensure that our internal place holders keep track of
* external `optind' increments; (`argind' must lag by one).
*/
argind = optind - 1;
/* When `optind' is misused, in this fashion, we also abandon any
* residual text in the argument we had been parsing; this is done
* without any further processing of such abandoned text, assuming
* that the caller is equipped to handle it appropriately.
*/
nextchar = NULL;
}
if( nextchar && *nextchar )
{
/* we are parsing a standard, or short format, option argument ...
*/
const WCHAR *optchar;
if( (optchar = getoptW_match( optopt = *nextchar++, optstring )) != NULL )
{
/* we have identified it as valid ...
*/
if( optchar[1] == getoptW_takes_argument )
{
/* and determined that it requires an associated argument ...
*/
if( ! *(optarg = (WCHAR *)(nextchar)) )
{
/* the argument is NOT attached ...
*/
if( optchar[2] == getoptW_takes_argument )
/*
* but this GNU extension marks it as optional,
* so we don't provide one on this occasion.
*/
optarg = NULL;
/* otherwise this option takes a mandatory argument,
* so, provided there is one available ...
*/
else if( (argc - argind) > 1 )
/*
* we take the following command line argument,
* as the appropriate option argument.
*/
optarg = argv[++argind];
/* but if no further argument is available,
* then there is nothing we can do, except for
* issuing the requisite diagnostic message.
*/
else
{
complain( "option requires an argument -- %c", optopt );
return getoptW_missing_arg( optstring );
}
}
optind = argind + 1;
nextchar = NULL;
}
else
optarg = NULL;
optind = (nextchar && *nextchar) ? argind : argind + 1;
return optopt;
}
/* if we didn't find a valid match for the specified option character,
* then we fall through to here, so take appropriate diagnostic action.
*/
if( mode == getoptW_mode_long_only )
{
complain( "unrecognised option `-%s'", --nextchar );
nextchar = NULL;
optopt = 0;
}
else
complain( "invalid option -- %c", optopt );
optind = (nextchar && *nextchar) ? argind : argind + 1;
return getoptW_unknown;
}
if( optmark > optbase )
{
/* This can happen, in GNU parsing mode ONLY, when we have
* skipped over non-option arguments, and found a subsequent
* option argument; in this case we permute the arguments.
*/
int index;
/*
* `optspan' specifies the number of contiguous arguments
* which are spanned by the current option, and so must be
* moved together during permutation.
*/
int optspan = argind - optmark + 1;
/*
* we use `this_arg' to store these temporarily.
*/
WCHAR **this_arg = calloc(optspan, sizeof(WCHAR *));
/*
* we cannot manipulate `argv' directly, since the `getoptW'
* API prototypes it as `read-only'; this cast to `arglist'
* allows us to work around that restriction.
*/
WCHAR **arglist = (WCHAR **)(argv);
/* save temporary copies of the arguments which are associated
* with the current option ...
*/
for( index = 0; index < optspan; ++index )
this_arg[index] = arglist[optmark + index];
/* move all preceding non-option arguments to the right,
* overwriting these saved arguments, while making space
* to replace them in their permuted location.
*/
for( --optmark; optmark >= optbase; --optmark )
arglist[optmark + optspan] = arglist[optmark];
/* restore the temporarily saved option arguments to
* their permuted location.
*/
for( index = 0; index < optspan; ++index )
arglist[optbase + index] = this_arg[index];
free(this_arg);
this_arg = 0;
/* adjust `optbase', to account for the relocated option.
*/
optbase += optspan;
}
else
/* no permutation occurred ...
* simply adjust `optbase' for all options parsed so far.
*/
optbase = argind + 1;
/* enter main parsing loop ...
*/
while( argc > ++argind )
{
/* inspect each argument in turn, identifying possible options ...
*/
if( is_switchar( *(nextchar = argv[optmark = argind]) ) && *++nextchar )
{
/* we've found a candidate option argument ... */
if( is_switchar( *nextchar ) )
{
/* it's a double hyphen argument ... */
const WCHAR *refchar = nextchar;
if( *++refchar )
{
/* and it looks like a long format option ...
* `getoptW_long' mode must be active to accept it as such,
* `getoptW_long_only' also qualifies, but we must downgrade
* it to force explicit handling as a long format option.
*/
if( mode >= getoptW_mode_long )
{
nextchar = refchar;
mode = getoptW_mode_long;
}
}
else
{
/* this is an explicit `--' end of options marker, so wrap up now!
*/
if( optmark > optbase )
{
/* permuting the argument list as necessary ...
* (note use of `this_arg' and `arglist', as above).
*/
WCHAR *this_arg = argv[optmark];
WCHAR **arglist = (WCHAR **)(argv);
/* move all preceding non-option arguments to the right ...
*/
do arglist[optmark] = arglist[optmark - 1];
while( optmark-- > optbase );
/* reinstate the `--' marker, in its permuted location.
*/
arglist[optbase] = this_arg;
}
/* ... before finally bumping `optbase' past the `--' marker,
* and returning the `all done' completion indicator.
*/
optind = ++optbase;
return getoptW_all_done;
}
}
else if( mode < getoptW_mode_long_only )
{
/* it's not an explicit long option, and `getoptW_long_only' isn't active,
* so we must explicitly try to match it as a short option.
*/
mode = getoptW_mode_standard;
}
if( mode >= getoptW_mode_long )
{
/* the current argument is a long form option, (either explicitly,
* introduced by a double hyphen, or implicitly because we were called
* by `getoptW_long_only'); this is where we parse it.
*/
int lookup;
int matched = -1;
/* we need to fetch the `extra' function arguments, which are
* specified for the `getoptW_long' APIs.
*/
va_list refptr;
va_start( refptr, optstring );
struct option *longopts = va_arg( refptr, struct option * );
int *optindex = va_arg( refptr, int * );
va_end( refptr );
/* ensuring that `optarg' does not inherit any junk, from parsing
* preceding arguments ...
*/
optarg = NULL;
for( lookup = 0; longopts && longopts[lookup].name; ++lookup )
{
/* scan the list of defined long form options ...
*/
switch( getoptW_match_long( nextchar, longopts[lookup].name ) )
{
/* looking for possible matches for the current argument.
*/
case getoptW_exact_match:
/*
* when an exact match is found,
* return it immediately, setting `nextchar' to NULL,
* to ensure we don't mistakenly try to match any
* subsequent characters as short form options.
*/
nextchar = NULL;
return getoptW_resolved( mode, argc, argv, &argind,
longopts, lookup, optindex, optstring );
case getoptW_abbreviated_match:
/*
* but, for a partial (initial substring) match ...
*/
if( matched >= 0 )
{
/* if this is not the first, then we have an ambiguity ...
*/
if( (mode == getoptW_mode_long_only)
/*
* However, in the case of getoptW_long_only(), if
* the entire ambiguously matched string represents
* a valid short option specification, then we may
* proceed to interpret it as such.
*/
&& getoptW_verify( nextchar, optstring ) )
return getoptW_parse( mode, argc, argv, optstring );
/* If we get to here, then the ambiguously matched
* partial long option isn't valid for short option
* evaluation; reset parser context to resume with
* the following command line argument, diagnose
* ambiguity, and bail out.
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "option `%s' is ambiguous", argv[argind] );
return getoptW_unknown;
}
/* otherwise just note that we've found a possible match ...
*/
matched = lookup;
}
}
if( matched >= 0 )
{
/* if we get to here, then we found exactly one partial match,
* so return it, as for an exact match.
*/
nextchar = NULL;
return getoptW_resolved( mode, argc, argv, &argind,
longopts, matched, optindex, optstring );
}
/* if here, then we had what SHOULD have been a long form option,
* but it is unmatched ...
*/
if( (mode < getoptW_mode_long_only)
/*
* ... although paradoxically, `mode == getoptW_mode_long_only'
* allows us to still try to match it as a short form option.
*/
|| (getoptW_verify( nextchar, optstring ) == 0) )
{
/* When it cannot be matched, reset the parsing context to
* resume from the next argument, diagnose the failed match,
* and bail out.
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "unrecognised option `%s'", argv[argind] );
return getoptW_unknown;
}
}
/* fall through to handle standard short form options...
* when the option argument format is neither explictly identified
* as long, nor implicitly matched as such, and the argument isn't
* just a bare hyphen, (which isn't an option), then we make one
* recursive call to explicitly interpret it as short format.
*/
if( *nextchar )
return getoptW_parse( mode, argc, argv, optstring );
}
/* if we get to here, then we've parsed a non-option argument ...
* in GNU compatibility mode, we step over it, so we can permute
* any subsequent option arguments, but ...
*/
if( *optstring == getoptW_switchar )
{
/* if `optstring' begins with a `-' character, this special
* GNU specific behaviour requires us to return the non-option
* arguments in strict order, as pseudo-arguments to a special
* option, with return value defined as `getoptW_ordered'.
*/
nextchar = NULL;
optind = argind + 1;
optarg = argv[argind];
return getoptW_ordered;
}
if( getoptW_conventions( *optstring ) & getoptW_posixly_correct )
/*
* otherwise ...
* for POSIXLY_CORRECT behaviour, or if `optstring' begins with
* a `+' character, then we break out of the parsing loop, so that
* the scan ends at the current argument, with no permutation.
*/
break;
}
/* fall through when all arguments have been evaluated,
*/
optind = optbase;
return getoptW_all_done;
}
/* All three public API entry points are trivially defined,
* in terms of the internal `getoptW_parse' function.
*/
int getoptW( getoptW_std_args )
{
return getoptW_parse( getoptW_mode_standard, argc, argv, optstring );
}
int getoptW_long( getoptW_std_args, const struct option *opts, int *index )
{
return getoptW_parse( getoptW_mode_long, argc, argv, optstring, opts, index );
}
int getoptW_long_only( getoptW_std_args, const struct option *opts, int *index )
{
return getoptW_parse( getoptW_mode_long_only, argc, argv, optstring, opts, index );
}
#ifdef __weak_alias
/*
* These Microsnot style uglified aliases are provided for compatibility
* with the previous MinGW implementation of the getoptW API.
*/
__weak_alias( getoptW, _getoptW )
__weak_alias( getoptW_long, _getoptW_long )
__weak_alias( getoptW_long_only, _getoptW_long_only )
#endif
/* $RCSfile$: end of file */

@ -0,0 +1,100 @@
#ifndef __GETOPTW_H__
/**
* DISCLAIMER
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
*
* The mingw-w64 runtime package and its code is distributed in the hope that it
* will be useful but WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESSED OR
* IMPLIED ARE HEREBY DISCLAIMED. This includes but is not limited to
* warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* This licence is governed by the laws of Ontario, Canada and any dispute
* shall be finally resolved by the courts in London, Ontario, Canada.
*/
#define __GETOPTW_H__
/* All the headers include this file. */
#include <crtdefs.h>
#ifdef __cplusplus
extern "C" {
#endif
#define __inline__
extern int optind; /* index of first non-option in argv */
extern int optopt; /* single option character, as parsed */
extern int opterr; /* flag to enable built-in diagnostics... */
/* (user may set to zero, to suppress) */
extern wchar_t *optarg; /* pointer to argument of current option */
extern int getoptW(int nargc, wchar_t * const *nargv, const wchar_t *options);
#ifdef _BSD_SOURCE
/*
* BSD adds the non-standard `optreset' feature, for reinitialisation
* of `getoptW' parsing. We support this feature, for applications which
* proclaim their BSD heritage, before including this header; however,
* to maintain portability, developers are advised to avoid it.
*/
# define optreset __mingw_optreset
extern int optreset;
#endif
#ifdef __cplusplus
}
#endif
/*
* POSIX requires the `getoptW' API to be specified in `unistd.h';
* thus, `unistd.h' includes this header. However, we do not want
* to expose the `getoptW_long' or `getoptW_long_only' APIs, when
* included in this manner. Thus, close the standard __GETOPTW_H__
* declarations block, and open an additional __GETOPTW_LONG_H__
* specific block, only when *not* __UNISTD_H_SOURCED__, in which
* to declare the extended API.
*/
#endif /* !defined(__GETOPTW_H__) */
#if !defined(__UNISTD_H_SOURCED__) && !defined(__GETOPTW_LONG_H__)
#define __GETOPTW_LONG_H__
#ifdef __cplusplus
extern "C" {
#endif
struct option /* specification for a long form option... */
{
const wchar_t *name; /* option name, without leading hyphens */
int has_arg; /* does it take an argument? */
int *flag; /* where to save its status, or NULL */
int val; /* its associated status value */
};
enum /* permitted values for its `has_arg' field... */
{
no_argument = 0, /* option never takes an argument */
required_argument, /* option always requires an argument */
optional_argument /* option may take an argument */
};
int getoptW_long(int nargc, wchar_t * const *nargv, const wchar_t *options,
const struct option *long_options, int *idx);
int getoptW_long_only(int nargc, wchar_t * const *nargv, const wchar_t *options,
const struct option *long_options, int *idx);
/*
* Previous MinGW implementation had...
*/
#ifndef HAVE_DECL_GETOPT
/*
* ...for the long form API only; keep this for compatibility.
*/
# define HAVE_DECL_GETOPT 1
#endif
#ifdef __cplusplus
}
#endif
#endif /* !defined(__UNISTD_H_SOURCED__) && !defined(__GETOPTW_LONG_H__) */

@ -0,0 +1,422 @@
#include <windows.h> // System includes
#include <atlbase.h> // ATL
#include <windowsx.h>
#include <wchar.h>
#include <tchar.h>
#include <sapi.h> // SAPI includes
#pragma warning(push) // Disable warning C4996: 'GetVersionExA': was declared deprecated (sphelper.h:1319)
#pragma warning(disable: 4996)
#include <sphelper.h>
#pragma warning(pop)
#include <io.h>
#include <fcntl.h>
#include "getoptw.h"
const WCHAR *getErrorString(HRESULT r) {
switch(r) {
#include "sapierr.h"
}
return L"Unknown";
}
void printJsonString(const WCHAR* in) {
if (!in) {
fwprintf(stdout, L"null");
return;
}
int l = wcslen(in);
fputwc(L'"', stdout);
for(int i = 0; i < l; i++) {
if(in[i] == L'"')
fputwc(L'\\', stdout);
else if(in[i] == L'\\')
fputwc(L'\\', stdout);
fputwc(in[i], stdout);
}
fputwc(L'"', stdout);
}
void printJsonKeyPair(const WCHAR* key, const WCHAR* value, int skipComma = 0) {
printJsonString(key);
wprintf(L": ");
printJsonString(value);
if(skipComma)
wprintf(L"\n");
else
wprintf(L",\n");
}
int listVoices() {
HRESULT hr = 0L;
CComPtr<IEnumSpObjectTokens> voicesEnum;
hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL, &voicesEnum);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not enumerate tokens: %d %s\n", hr, getErrorString(hr));
return 1;
}
ULONG ulCount = 0;
hr = voicesEnum->GetCount(&ulCount);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not get token count: %d %s\n", hr, getErrorString(hr));
return 1;
}
wprintf(L"[\n");
while(ulCount--) {
CComPtr<ISpObjectToken> cpVoiceToken;
hr = voicesEnum->Next(1, &cpVoiceToken, NULL);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not iterate voice token: %d %s\n", hr, getErrorString(hr));
return 1;
}
WCHAR* idString = 0L;
hr = cpVoiceToken->GetId(&idString);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not get token ID: %d %s\n", hr, getErrorString(hr));
return 1;
}
wprintf(L"{\n");
printJsonKeyPair(L"id", idString);
WCHAR* descriptionString = 0L;
hr = SpGetDescription(cpVoiceToken, &descriptionString);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not get token description: %d %s\n", hr, getErrorString(hr));
return 1;
}
printJsonKeyPair(L"description", descriptionString);
CComPtr<ISpDataKey> cpSpAttributesKey;
hr = cpVoiceToken->OpenKey(L"Attributes", &cpSpAttributesKey);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not open attributes key: %d %s\n", hr, getErrorString(hr));
return 1;
}
WCHAR* age;
cpSpAttributesKey->GetStringValue(L"Age", &age);
printJsonKeyPair(L"age", age);
WCHAR* gender;
cpSpAttributesKey->GetStringValue(L"Gender", &gender);
printJsonKeyPair(L"gender", gender);
WCHAR* language;
cpSpAttributesKey->GetStringValue(L"Language", &language);
WCHAR strNameBuffer[LOCALE_NAME_MAX_LENGTH] = {0};
int langId = wcstol(language, NULL, 16);
LCIDToLocaleName(langId, strNameBuffer, LOCALE_NAME_MAX_LENGTH, 0);
printJsonKeyPair(L"language", strNameBuffer);
WCHAR* name;
cpSpAttributesKey->GetStringValue(L"Name", &name);
printJsonKeyPair(L"name", name);
WCHAR* vendor;
cpSpAttributesKey->GetStringValue(L"Vendor", &vendor);
printJsonKeyPair(L"vendor", vendor, 1);
if(ulCount > 0)
wprintf(L"},\n");
else
wprintf(L"}\n");
}
wprintf(L"]\n");
return 0;
}
int addLexemes() {
HRESULT hr;
CComPtr<ISpLexicon> cpLexicon;
hr = cpLexicon.CoCreateInstance(CLSID_SpLexicon);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not instantiate lexicon: %d %s\n", hr, getErrorString(hr));
return 1;
}
LANGID langidUS = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
CComPtr<ISpPhoneConverter> cpPhoneConv;
hr = SpCreatePhoneConverter(langidUS, NULL, NULL, &cpPhoneConv);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not instantiate phoneme converter: %d %s\n", hr, getErrorString(hr));
return 1;
}
const struct {
LANGID langId;
const WCHAR* word;
const WCHAR* phone;
} lexemes[] = {
{ langidUS, L"cum", L"k uw m" },
{ langidUS, L"poo", L"p uw" },
{ langidUS, L"lol", L"l uh l" },
{ langidUS, L"lolol", L"l uh l uh l" },
{ langidUS, L"deez", L"d iy z" },
{ langidUS, L"nutz", L"n ah t s" },
{ langidUS, L"nasim", L"n ah s iy m" },
};
for(int i = 0; i < sizeof(lexemes) / sizeof(lexemes[0]); i++) {
SPPHONEID wszId[SP_MAX_PRON_LENGTH];
hr = cpPhoneConv->PhoneToId(lexemes[i].phone, wszId);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not convert phoneme \"%s\" to id: ", lexemes[i].phone);
if(hr == E_INVALIDARG)
fwprintf(stderr, L"Invalid argument");
else if(hr == SPERR_UNINITIALIZED)
fwprintf(stderr, L"Uninitialized");
else if(hr == E_FAIL)
fwprintf(stderr, L"Failed");
else fwprintf(stderr, L"%d", hr);
fwprintf(stderr, L"\n");
continue;
}
hr = cpLexicon->AddPronunciation(lexemes[i].word, lexemes[i].langId, SPPS_Noun, wszId);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not add pronounciation for word \"%s\": %d %s\n", lexemes[i].word, hr, getErrorString(hr));
continue;
}
}
return 0;
}
int speakToWav(WCHAR *text, WCHAR *voiceId, WCHAR *wavFilename, int rate, int volume, DWORD speakFlags, ULONGLONG ullEventInterest) {
HRESULT hr;
if(addLexemes())
return 1;
CComPtr<ISpVoice> voice;
hr = voice.CoCreateInstance(CLSID_SpVoice);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not create voice instance: %d %s\n", hr, getErrorString(hr));
return 1;
}
CComPtr<ISpObjectToken> voiceToken;
hr = SpGetTokenFromId(voiceId, &voiceToken);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not get token for voice \"%s\": %d %s\n", voiceId, hr, getErrorString(hr));
return 1;
}
hr = voice->SetVoice(voiceToken);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not set voice: %d %s\n", hr, getErrorString(hr));
return 1;
}
CComPtr<ISpStreamFormat> outputStreamFormat;
hr = voice->GetOutputStream(&outputStreamFormat);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not get output stream: %d %s\n", hr, getErrorString(hr));
return 1;
}
CSpStreamFormat streamFormat;
hr = streamFormat.AssignFormat(outputStreamFormat);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not assign format: %d %s\n", hr, getErrorString(hr));
return 1;
}
// User SAPI helper function in sphelper.h to create a wav file
CComPtr<ISpStream> cpWavStream;
hr = SPBindToFile(wavFilename, SPFM_CREATE_ALWAYS, &cpWavStream, &streamFormat.FormatId(), streamFormat.WaveFormatExPtr(), ullEventInterest);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not bind to file \"%s\": %d %s\n", wavFilename, hr, getErrorString(hr));
return 1;
}
hr = voice->SetOutput(cpWavStream, TRUE);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not set output to wav file \"%s\": %d %s\n", wavFilename, hr, getErrorString(hr));
return 1;
}
hr = voice->SetRate(rate);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not set rate to %d: %d %s\n", rate, hr, getErrorString(hr));
return 1;
}
hr = voice->SetVolume(volume);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not set volume to %d: %d %s\n", volume, hr, getErrorString(hr));
return 1;
}
hr = voice->Speak(text, speakFlags, 0);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not speak: %d %s\n", hr, getErrorString(hr));
return 1;
}
cpWavStream.Release();
voiceToken.Release();
return 0;
}
int wmain(int argc, WCHAR* argv[]) {
// https://stackoverflow.com/questions/2492077/output-unicode-strings-in-windows-console-app
(void)_setmode(_fileno(stdout), _O_U8TEXT);
const struct option long_options[] = {
{L"help", no_argument, 0, L'h'},
{L"list", no_argument, 0, L'l'},
{L"output", required_argument, 0, L'o'},
{L"voice", required_argument, 0, L'v'},
{L"type", required_argument, 0, L't'},
{L"rate", required_argument, 0, L'r'},
{L"volume", required_argument, 0, L'V'},
{L"all-events", no_argument, 0, L'a'},
{L"start-input-stream-event", no_argument, 0, L'S'},
{L"end-input-stream-event", no_argument, 0, L'E'},
{L"voice-change-event", no_argument, 0, L'C'},
{L"bookmark-event", no_argument, 0, L'B'},
{L"word-boundary-event", no_argument, 0, L'W'},
{L"phoneme-event", no_argument, 0, L'F'},
{L"sentence-boundary-event", no_argument, 0, L'N'},
{L"viseme-event", no_argument, 0, L'I'},
{L"audio-level-event", no_argument, 0, L'L'},
{0, 0, 0, 0},
};
int help = 0;
int list = 0;
WCHAR *voice = 0;
WCHAR *wavFilename = 0;
DWORD speakFlags = 0;
int rate = 0;
int volume = 100;
ULONGLONG ullEventInterest = 0;
int option;
int option_index = 0;
while(1) {
option = getoptW_long(argc, argv, L"hlo:v:t:r:VaSECBWFNIL", long_options, &option_index);
if(option == -1) break;
switch (option) {
case L'h':
help = 1;
break;
case L'l':
list = 1;
break;
case L'o':
wavFilename = optarg;
break;
case L'v':
voice = optarg;
break;
case L't':
if(!_wcsicmp(optarg, L"ssml"))
speakFlags = SPF_IS_XML | SPF_PARSE_SSML;
else if(!_wcsicmp(optarg, L"sapi"))
speakFlags = SPF_IS_XML | SPF_PARSE_SAPI;
else if(!_wcsicmp(optarg, L"auto"))
speakFlags = SPF_IS_XML | SPF_PARSE_AUTODETECT;
else if(!_wcsicmp(optarg, L"text"))
speakFlags = SPF_IS_NOT_XML;
else
help = 1;
break;
case L'r':
rate = wcstol(optarg, 0, 10);
break;
case L'V':
volume = wcstol(optarg, 0, 10);
break;
case L'a':
ullEventInterest = SPFEI_ALL_EVENTS;
break;
case L'S':
ullEventInterest |= SPEI_START_INPUT_STREAM;
break;
case L'E':
ullEventInterest |= SPEI_END_INPUT_STREAM;
break;
case L'C':
ullEventInterest |= SPEI_VOICE_CHANGE;
break;
case L'B':
ullEventInterest |= SPEI_TTS_BOOKMARK;
break;
case L'W':
ullEventInterest |= SPEI_WORD_BOUNDARY;
break;
case L'F':
ullEventInterest |= SPEI_PHONEME;
break;
case L'N':
ullEventInterest |= SPEI_SENTENCE_BOUNDARY;
break;
case L'I':
ullEventInterest |= SPEI_VISEME;
break;
case L'L':
ullEventInterest |= SPEI_TTS_AUDIO_LEVEL;
break;
}
}
if(!list && optind >= argc)
help = 1;
if(help) {
fwprintf(
stderr,
L"Usage: %s --list | [options] <text>\n"
" -h, --help Print this help.\n"
" -l, --list List all voices.\n"
" -o, --output=FILE Output WAV file.\n"
" -v, --voice=VOICE Select voice.\n"
" -t, --type=TYPE Input text type (PLAIN,SSML,SAPI,AUTO).\n"
" -r, --rate=RATE Rate (speed) of speech, from -10 to 10.\n"
" -V, --volume=VOL Volume of speech, from 0 to 100.\n"
" -a, --all-events Log all events in the EVNT RIFF chunk.\n"
" -S, --start-input-stream-event Log start input stream events.\n"
" -E, --end-input-stream-event Log end input stream events.\n"
" -C, --voice-change-event Log voice change events.\n"
" -B, --bookmark-event Log bookmark events.\n"
" -W, --word-boundary-event Log word boundary events.\n"
" -F, --phoneme-event Log phoneme events.\n"
" -N, --sentence-boundary-event Log sentence boundary events.\n"
" -I, --viseme-event Log viseme events.\n"
" -L, --audio-level-event Log audio level events.\n",
argv[0]
);
return 1;
}
HRESULT hr = ::CoInitialize(NULL);
if(FAILED(hr)) {
fwprintf(stderr, L"Could not initialize COM: %x %s\n", hr, getErrorString(hr));
return 1;
}
int ret = 0;
if(list) {
ret = listVoices();
} else {
ret = speakToWav(argv[optind], voice, wavFilename, rate, volume, speakFlags, ullEventInterest);
}
::CoUninitialize();
return ret;
}

@ -0,0 +1,31 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.1.32319.34
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sapicli", "sapicli.vcxproj", "{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Debug|x64.ActiveCfg = Debug|x64
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Debug|x64.Build.0 = Debug|x64
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Debug|x86.ActiveCfg = Debug|Win32
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Debug|x86.Build.0 = Debug|Win32
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Release|x64.ActiveCfg = Release|x64
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Release|x64.Build.0 = Release|x64
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Release|x86.ActiveCfg = Release|Win32
{8B3A05D9-28C1-4C89-B90C-7409DEF9C273}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {050DE126-BC0C-4FEC-B091-C41974A47EDA}
EndGlobalSection
EndGlobal

@ -0,0 +1,135 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{8b3a05d9-28c1-4c89-b90c-7409def9c273}</ProjectGuid>
<RootNamespace>sapicli</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>