bool Melder_stringMatchesCriterion (const char32 *value, int which_kMelder_string, const char32 *criterion) {
if (! value) {
value = U""; // regard null strings as empty strings, as is usual in Praat
}
if (! criterion) {
criterion = U""; // regard null strings as empty strings, as is usual in Praat
}
if (which_kMelder_string <= kMelder_string_NOT_EQUAL_TO) {
bool matchPositiveCriterion = str32equ (value, criterion);
return ( which_kMelder_string == kMelder_string_EQUAL_TO ) == matchPositiveCriterion;
}
if (which_kMelder_string <= kMelder_string_DOES_NOT_CONTAIN) {
bool matchPositiveCriterion = !! str32str (value, criterion);
return ( which_kMelder_string == kMelder_string_CONTAINS ) == matchPositiveCriterion;
}
if (which_kMelder_string <= kMelder_string_DOES_NOT_START_WITH) {
bool matchPositiveCriterion = str32nequ (value, criterion, str32len (criterion));
return ( which_kMelder_string == kMelder_string_STARTS_WITH ) == matchPositiveCriterion;
}
if (which_kMelder_string <= kMelder_string_DOES_NOT_END_WITH) {
int criterionLength = str32len (criterion), valueLength = str32len (value);
bool matchPositiveCriterion = ( criterionLength <= valueLength && str32equ (value + valueLength - criterionLength, criterion) );
return (which_kMelder_string == kMelder_string_ENDS_WITH) == matchPositiveCriterion;
}
if (which_kMelder_string == kMelder_string_MATCH_REGEXP) {
char32 *place = nullptr;
regexp *compiled_regexp = CompileRE_throwable (criterion, 0);
if (ExecRE (compiled_regexp, nullptr, value, nullptr, 0, '\0', '\0', nullptr, nullptr, nullptr))
place = compiled_regexp -> startp [0];
free (compiled_regexp);
return !! place;
}
return false; // should not occur
}
double PairDistribution_Distributions_getFractionCorrect (PairDistribution me, Distributions dist, long column) {
try {
double correct = 0.0;
long pairmin = 1;
char32 string [1000];
Distributions_checkSpecifiedColumnNumberWithinRange (dist, column);
autoPairDistribution thee = Data_copy (me);
Collection_sort (thy pairs.get(), PairProbability_compare);
double total = PairDistributions_getTotalWeight_checkPositive (thee.peek());
do {
long pairmax = pairmin, length, ipair;
double sum = 0.0, sumDist = 0.0;
char32 *firstInput = ((PairProbability) thy pairs -> item [pairmin]) -> string1;
for (ipair = pairmin + 1; ipair <= thy pairs -> size; ipair ++) {
PairProbability prob = static_cast <PairProbability> (thy pairs -> item [ipair]);
if (! str32equ (prob -> string1, firstInput)) {
pairmax = ipair - 1;
break;
}
}
if (ipair > thy pairs -> size) pairmax = thy pairs -> size;
for (ipair = pairmin; ipair <= pairmax; ipair ++) {
PairProbability prob = static_cast <PairProbability> (thy pairs -> item [ipair]);
double p = prob -> weight / total, pout = 0.0;
Melder_sprint (string, 1000, prob -> string1, U" \\-> ", prob -> string2);
for (long idist = 1; idist <= dist -> numberOfRows; idist ++) {
if (str32equ (string, dist -> rowLabels [idist])) {
pout = dist -> data [idist] [column];
break;
}
}
sum += p * pout;
}
Melder_sprint (string, 1000, firstInput, U" \\-> ");
length = str32len (string);
for (long idist = 1; idist <= dist -> numberOfRows; idist ++) {
if (str32nequ (string, dist -> rowLabels [idist], length)) {
sumDist += dist -> data [idist] [column];
}
}
if (sumDist != 0.0) correct += sum / sumDist;
pairmin = pairmax + 1;
} while (pairmin <= thy pairs -> size);
return correct;
} catch (MelderError) {
Melder_throw (me, U" & ", dist, U": could not compute our fraction correct.");
}
}
bool SpellingChecker_isWordAllowed (SpellingChecker me, const char32 *word) {
int wordLength = str32len (word);
if (my allowAllWordsContaining && my allowAllWordsContaining [0]) {
char32 *p = & my allowAllWordsContaining [0];
while (*p) {
/*
* Find next token in list of allowed string parts.
*/
char32 token [100], *q = & token [0];
/*
* Skip spaces in list.
*/
while (*p == U' ') p ++;
/*
* Collect one token string from list.
*/
while (*p != U'\0' && *p != U' ') {
*q ++ = *p ++;
}
*q = U'\0'; // trailing null character
/*
* Allow word if it contains this token.
*/
if (str32str (word, token)) return true;
}
}
if (my allowAllNames) {
/*
* Allow word if it starts with a capital.
*/
if (startsWithCapital (word)) {
return true;
}
if (my namePrefixes && my namePrefixes [0]) {
char32 *p = & my namePrefixes [0];
while (*p) {
char32 token [100], *q = & token [0];
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
/*
* Allow word if starts with this prefix
* and this prefix is followed by a capital.
*/
if (str32str (word, token) == word && startsWithCapital (word + str32len (token))) {
return true;
}
}
}
} else if (my allowAllAbbreviations && startsWithCapital (word)) {
const char32 *p = & word [0];
for (;;) {
if (*p == '\0') return true;
if (iswlower ((int) *p)) break;
p ++;
}
}
if (my allowAllWordsStartingWith && my allowAllWordsStartingWith [0]) {
char32 *p = & my allowAllWordsStartingWith [0];
while (*p) {
char32 token [100], *q = & token [0];
int tokenLength;
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
tokenLength = str32len (token);
if (wordLength >= tokenLength && str32nequ (token, word, tokenLength)) {
return true;
}
}
}
if (my allowAllWordsEndingIn && my allowAllWordsEndingIn [0]) {
char32 *p = & my allowAllWordsEndingIn [0];
while (*p) {
char32 token [100], *q = & token [0];
int tokenLength;
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
tokenLength = str32len (token);
if (wordLength >= tokenLength && str32nequ (token, word + wordLength - tokenLength, tokenLength)) {
return true;
}
}
}
if (WordList_hasWord (my wordList, word))
return true;
if (my userDictionary != NULL) {
if (str32len (word) > 3333) return false; // superfluous, because WordList_hasWord already checked; but safe
static char32 buffer [3*3333+1];
Longchar_genericize32 (word, buffer);
if (SortedSetOfString_lookUp (my userDictionary, buffer) != 0)
return true;
}
return false;
}
static void gui_drawingarea_cb_expose (I, GuiDrawingAreaExposeEvent event) {
iam (RunnerMFC);
Melder_assert (event -> widget == my d_drawingArea);
if (my graphics == NULL) return; // Could be the case in the very beginning.
ExperimentMFC experiment = (ExperimentMFC) my data;
long iresponse;
if (my data == NULL) return;
Graphics_setGrey (my graphics, 0.8);
Graphics_fillRectangle (my graphics, 0, 1, 0, 1);
Graphics_setGrey (my graphics, 0.0);
if (experiment -> trial == 0) {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> startText);
} else if (experiment -> pausing) {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> pauseText);
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
} else if (experiment -> trial <= experiment -> numberOfTrials) {
const char32 *visibleText = experiment -> stimulus [experiment -> stimuli [experiment -> trial]]. visibleText;
autostring32 visibleText_dup = Melder_dup_f (visibleText ? visibleText : U"");
char32 *visibleText_p = visibleText_dup.peek();
Graphics_setFont (my graphics, kGraphics_font_TIMES);
Graphics_setFontSize (my graphics, 10);
Graphics_setColour (my graphics, Graphics_BLACK);
Graphics_setTextAlignment (my graphics, Graphics_LEFT, Graphics_TOP);
Graphics_text (my graphics, 0, 1, experiment -> trial, U" / ", experiment -> numberOfTrials);
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_TOP);
Graphics_setFontSize (my graphics, 24);
/*
* The run text.
*/
if (visibleText_p [0] != U'\0') {
char32 *visibleText_q = str32chr (visibleText_p, U'|');
if (visibleText_q) *visibleText_q = '\0';
Graphics_text (my graphics, 0.5, 1.0, visibleText_p [0] != '\0' ? visibleText_p : experiment -> runText);
if (visibleText_q) visibleText_p = visibleText_q + 1; else visibleText_p += str32len (visibleText_p);
} else {
Graphics_text (my graphics, 0.5, 1.0, experiment -> runText);
}
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
for (iresponse = 1; iresponse <= experiment -> numberOfDifferentResponses; iresponse ++) {
ResponseMFC response = & experiment -> response [iresponse];
char32 *textToDraw = response -> label; // can be overridden
if (visibleText_p [0] != U'\0') {
char32 *visibleText_q = str32chr (visibleText_p, U'|');
if (visibleText_q) *visibleText_q = U'\0';
textToDraw = visibleText_p; // override
if (visibleText_q) visibleText_p = visibleText_q + 1; else visibleText_p += str32len (visibleText_p);
}
if (str32nequ (textToDraw, U"\\FI", 3)) {
structMelderFile file = { 0 };
MelderDir_relativePathToFile (& experiment -> rootDirectory, textToDraw + 3, & file);
Graphics_imageFromFile (my graphics, Melder_fileToPath (& file), response -> left, response -> right, response -> bottom, response -> top);
} else {
Graphics_setColour (my graphics,
response -> name [0] == U'\0' ? Graphics_SILVER :
experiment -> responses [experiment -> trial] == iresponse ? Graphics_RED :
experiment -> ok_right > experiment -> ok_left || experiment -> responses [experiment -> trial] == 0 ?
Graphics_YELLOW : Graphics_SILVER);
Graphics_setLineWidth (my graphics, 3.0);
Graphics_fillRectangle (my graphics, response -> left, response -> right, response -> bottom, response -> top);
Graphics_setColour (my graphics, Graphics_MAROON);
Graphics_rectangle (my graphics, response -> left, response -> right, response -> bottom, response -> top);
Graphics_setFontSize (my graphics, response -> fontSize ? response -> fontSize : 24);
Graphics_text (my graphics, 0.5 * (response -> left + response -> right),
0.5 * (response -> bottom + response -> top), textToDraw);
}
Graphics_setFontSize (my graphics, 24);
}
for (iresponse = 1; iresponse <= experiment -> numberOfGoodnessCategories; iresponse ++) {
GoodnessMFC goodness = & experiment -> goodness [iresponse];
Graphics_setColour (my graphics, experiment -> responses [experiment -> trial] == 0 ? Graphics_SILVER :
experiment -> goodnesses [experiment -> trial] == iresponse ? Graphics_RED : Graphics_YELLOW);
Graphics_setLineWidth (my graphics, 3.0);
Graphics_fillRectangle (my graphics, goodness -> left, goodness -> right, goodness -> bottom, goodness -> top);
Graphics_setColour (my graphics, Graphics_MAROON);
Graphics_rectangle (my graphics, goodness -> left, goodness -> right, goodness -> bottom, goodness -> top);
Graphics_text (my graphics, 0.5 * (goodness -> left + goodness -> right), 0.5 * (goodness -> bottom + goodness -> top), goodness -> label);
}
if (experiment -> replay_right > experiment -> replay_left && my numberOfReplays < experiment -> maximumNumberOfReplays) {
drawControlButton (me,
experiment -> replay_left, experiment -> replay_right, experiment -> replay_bottom, experiment -> replay_top,
experiment -> replay_label);
}
if (experiment -> ok_right > experiment -> ok_left &&
experiment -> responses [experiment -> trial] != 0 &&
(experiment -> numberOfGoodnessCategories == 0 || experiment -> goodnesses [experiment -> trial] != 0))
{
drawControlButton (me,
experiment -> ok_left, experiment -> ok_right, experiment -> ok_bottom, experiment -> ok_top,
experiment -> ok_label);
}
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
} else {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> endText);
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
}
}
static autoStrings Strings_createAsFileOrDirectoryList (const char32 *path /* cattable */, int type) {
#if USE_STAT
/*
* Initialize.
*/
DIR *d = nullptr;
try {
autoMelderString filePath, searchDirectory, left, right;
/*
* Parse the path.
* Example: in /Users/paul/sounds/h*.wav",
* the search directory is "/Users/paul/sounds",
* the left environment is "h", and the right environment is ".wav".
*/
MelderString_copy (& searchDirectory, path);
char32 *asterisk = str32rchr (searchDirectory. string, '*');
if (asterisk) {
*asterisk = '\0';
searchDirectory. length = asterisk - searchDirectory. string; // probably superfluous, but correct
char32 *lastSlash = str32rchr (searchDirectory. string, Melder_DIRECTORY_SEPARATOR);
if (lastSlash) {
*lastSlash = '\0'; // This fixes searchDirectory.
searchDirectory. length = lastSlash - searchDirectory. string; // probably superfluous, but correct
MelderString_copy (& left, lastSlash + 1);
} else {
MelderString_copy (& left, searchDirectory. string); // quickly save...
MelderString_empty (& searchDirectory); // ...before destruction
}
MelderString_copy (& right, asterisk + 1);
}
char buffer8 [kMelder_MAXPATH+1];
Melder_str32To8bitFileRepresentation_inline (searchDirectory. string, buffer8);
d = opendir (buffer8 [0] ? buffer8 : ".");
if (! d)
Melder_throw (U"Cannot open directory ", searchDirectory. string, U".");
//Melder_casual (U"opened");
autoStrings me = Thing_new (Strings);
my strings = NUMvector <char32 *> (1, 1000000);
struct dirent *entry;
while (!! (entry = readdir (d))) {
MelderString_copy (& filePath, searchDirectory. string [0] ? searchDirectory. string : U".");
MelderString_appendCharacter (& filePath, Melder_DIRECTORY_SEPARATOR);
char32 buffer32 [kMelder_MAXPATH+1];
Melder_8bitFileRepresentationToStr32_inline (entry -> d_name, buffer32);
MelderString_append (& filePath, buffer32);
//Melder_casual (U"read ", filePath. string);
Melder_str32To8bitFileRepresentation_inline (filePath. string, buffer8);
struct stat stats;
if (stat (buffer8, & stats) != 0) {
//Melder_throw (U"Cannot look at file ", filePath. string, U".");
//stats. st_mode = -1L;
}
//Melder_casual (U"statted ", filePath. string);
//Melder_casual (U"file ", filePath. string, U" mode ", stats. st_mode / 4096);
if ((type == Strings_createAsFileOrDirectoryList_TYPE_FILE && S_ISREG (stats. st_mode)) ||
(type == Strings_createAsFileOrDirectoryList_TYPE_DIRECTORY && S_ISDIR (stats. st_mode)))
{
Melder_8bitFileRepresentationToStr32_inline (entry -> d_name, buffer32);
int64 length = str32len (buffer32);
if (buffer32 [0] != U'.' &&
(left. length == 0 || str32nequ (buffer32, left. string, left. length)) &&
(right. length == 0 || (length >= right. length && str32equ (buffer32 + (length - right. length), right. string))))
{
my strings [++ my numberOfStrings] = Melder_dup (buffer32);
}
}
}
closedir (d);
Strings_sort (me.get());
return me;
} catch (MelderError) {
if (d) closedir (d); // "finally"
throw;
}
#elif defined (_WIN32)
try {
char32 searchPath [kMelder_MAXPATH+1];
int len = str32len (path);
bool hasAsterisk = !! str32chr (path, U'*');
bool endsInSeparator = ( len != 0 && path [len - 1] == U'\\' );
autoStrings me = Thing_new (Strings);
my strings = NUMvector <char32 *> (1, 1000000);
Melder_sprint (searchPath, kMelder_MAXPATH+1, path, hasAsterisk || endsInSeparator ? U"" : U"\\", hasAsterisk ? U"" : U"*");
WIN32_FIND_DATAW findData;
HANDLE searchHandle = FindFirstFileW (Melder_peek32toW (searchPath), & findData);
if (searchHandle != INVALID_HANDLE_VALUE) {
do {
if ((type == Strings_createAsFileOrDirectoryList_TYPE_FILE &&
(findData. dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
|| (type == Strings_createAsFileOrDirectoryList_TYPE_DIRECTORY &&
(findData. dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0))
{
if (findData. cFileName [0] != L'.') {
my strings [++ my numberOfStrings] = Melder_dup (Melder_peekWto32 (findData. cFileName));
}
}
} while (FindNextFileW (searchHandle, & findData));
FindClose (searchHandle);
}
Strings_sort (me.get());
return me;
} catch (MelderError) {
throw;
}
#endif
}