42 #include <netinet/in.h>
48 #include <iso/limits_iso.h>
65 char fnbuf[10], asciibuf[20] =
"letters/ascii";
78 while (
str[num] && !res) {
88 fn =
"letters/exclaimation-point";
94 fn =
"letters/dollar";
103 fn =
"letters/equals";
109 fn =
"letters/slash";
112 fn =
"letters/space";
124 strcpy(fnbuf,
"digits/X");
130 if (
'A' <= ltr && ltr <=
'Z') {
132 switch (sensitivity) {
140 }
else if (
'a' <= ltr && ltr <=
'z') {
141 switch (sensitivity) {
152 strcpy(fnbuf,
"uppercase");
154 strcpy(fnbuf,
"lowercase");
156 strcpy(fnbuf,
"letters/X");
162 (snprintf(asciibuf + 13,
sizeof(asciibuf) - 13,
"%d",
str[num]) > 0 &&
ast_fileexists(asciibuf,
NULL, lang) > 0 && (fn = asciibuf))) {
165 if (upper || lower) {
192 while ((fn =
strsep(&files,
"&"))) {
195 if ((audiofd > -1) && (ctrlfd > -1))
218 return say_filenames(chan, ints, lang, audiofd, ctrlfd, filenames);
244 fn =
"letters/exclaimation-point";
250 fn =
"letters/dollar";
259 fn =
"letters/equals";
265 fn =
"letters/slash";
268 fn =
"letters/space";
279 strcpy(fnbuf,
"digits/X");
285 if (
'A' <= ltr && ltr <=
'Z') ltr +=
'a' -
'A';
286 strcpy(fnbuf,
"phonetic/X_p");
302 return say_filenames(chan, ints, lang, audiofd, ctrlfd, filenames);
339 strcpy(fnbuf,
"digits/X");
356 return say_filenames(chan, ints, lang, audiofd, ctrlfd, filenames);
373 if (sscanf(
str,
"%30lf", &dollars) != 1) {
380 cents = amt - (((int) dollars) * 100);
381 ast_debug(1,
"Cents is %d, amount is %d\n", cents, amt);
394 ast_str_append(&filenames, 0,
"&%s", (cents > 0) ?
"letters/dollar_" :
"letters/dollar");
413 ast_str_append(&filenames, 0,
"&%s", (cents == 1) ?
"cent" :
"cents");
414 }
else if (amt == 0) {
435 if (!strncasecmp(lang,
"en", 2)) {
439 ast_log(
LOG_WARNING,
"Language %s not currently supported, defaulting to US Dollars\n", lang);
447 return say_filenames(chan, ints, lang, audiofd, ctrlfd, filenames);
471 while (!res && (num || playh)) {
474 if ( num > INT_MIN ) {
482 }
else if (num < 20) {
483 snprintf(fn,
sizeof(fn),
"digits/%d", num);
485 }
else if (num < 100) {
486 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
490 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
504 snprintf(fn,
sizeof(fn),
"&digits/thousand");
506 if (num < 1000000000) {
552 if (!strncasecmp(lang,
"en", 2)) {
556 ast_log(
LOG_WARNING,
"Language %s not currently supported, defaulting to English\n", lang);
582 while (!res && (num || playh)) {
585 if ( num > INT_MIN ) {
591 ast_copy_string(fn, (num % 100 == 0) ?
"digits/h-hundred" :
"digits/hundred",
sizeof(fn));
593 }
else if (num < 20) {
595 snprintf(fn,
sizeof(fn),
"digits/h-%d", num);
600 }
else if (num < 100) {
601 int base = (num / 10) * 10;
603 snprintf(fn,
sizeof(fn),
"digits/%d", base);
605 snprintf(fn,
sizeof(fn),
"digits/h-%d", base);
610 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
624 snprintf(fn,
sizeof(fn), (num % 1000 == 0) ?
"&digits/h-thousand" :
"&digits/thousand");
626 if (num < 1000000000) {
635 ast_copy_string(fn, (num % 1000000 == 0) ?
"&digits/h-million" :
"&digits/million",
sizeof(fn));
646 ast_copy_string(fn, (num % 1000000000 == 0) ?
"&digits/h-billion" :
"&digits/billion",
sizeof(fn));
672 if (!strncasecmp(lang,
"en", 2)) {
676 ast_log(
LOG_WARNING,
"Language %s not currently supported, defaulting to English\n", lang);
861 if (!strncasecmp(
language,
"en_GB", 5)) {
863 }
else if (!strncasecmp(
language,
"en", 2)) {
865 }
else if (!strncasecmp(
language,
"cs", 2)) {
867 }
else if (!strncasecmp(
language,
"da", 2)) {
869 }
else if (!strncasecmp(
language,
"de", 2)) {
871 }
else if (!strncasecmp(
language,
"es", 2)) {
873 }
else if (!strncasecmp(
language,
"fr", 2)) {
875 }
else if (!strncasecmp(
language,
"gr", 2)) {
877 }
else if (!strncasecmp(
language,
"ja", 2)) {
879 }
else if (!strncasecmp(
language,
"he", 2)) {
881 }
else if (!strncasecmp(
language,
"hu", 2)) {
883 }
else if (!strncasecmp(
language,
"is", 2)) {
885 }
else if (!strncasecmp(
language,
"it", 2)) {
887 }
else if (!strncasecmp(
language,
"ka", 2)) {
889 }
else if (!strncasecmp(
language,
"nl", 2)) {
891 }
else if (!strncasecmp(
language,
"no", 2)) {
893 }
else if (!strncasecmp(
language,
"pl", 2)) {
895 }
else if (!strncasecmp(
language,
"pt", 2)) {
897 }
else if (!strncasecmp(
language,
"ru", 2)) {
899 }
else if (!strncasecmp(
language,
"se", 2)) {
901 }
else if (!strncasecmp(
language,
"th", 2)) {
903 }
else if (!strncasecmp(
language,
"zh", 2)) {
905 }
else if (!strncasecmp(
language,
"ur", 2)) {
907 }
else if (!strncasecmp(
language,
"vi", 2)) {
933 for (x=0;x<power;x++)
977 while (!res && (num || playh)) {
980 if ( num > INT_MIN ) {
985 }
else if (num < 3 ) {
986 snprintf(fn,
sizeof(fn),
"digits/%d%c", num,
options[0]);
989 }
else if (num < 20) {
990 snprintf(fn,
sizeof(fn),
"digits/%d", num);
993 }
else if (num < 100) {
994 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
996 }
else if (num < 1000) {
998 if ( hundred == 1 ) {
1000 }
else if ( hundred == 2 ) {
1006 if (hundred == 3 || hundred == 4) {
1008 }
else if ( hundred > 4 ) {
1012 num -= (hundred * 100);
1014 length = (int)log10(num)+1;
1015 while ( (length % 3 ) != 1 ) {
1032 snprintf(fn,
sizeof(fn),
"digits/5_E%d", length - 1);
1033 }
else if ( left >= 2 && left <= 4 ) {
1034 snprintf(fn,
sizeof(fn),
"digits/2-4_E%d", length - 1);
1036 snprintf(fn,
sizeof(fn),
"digits/1_E%d", length - 1);
1042 if ((audiofd > -1) && (ctrlfd > -1)) {
1070 while (!res && (num || playh || playa )) {
1083 if ( num > INT_MIN ) {
1094 }
else if (num == 1 && cn == -1) {
1097 }
else if (num < 20) {
1098 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1100 }
else if (num < 100) {
1101 int ones = num % 10;
1103 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
1106 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1111 int hundreds = num / 100;
1115 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
1118 num -= 100 * hundreds;
1123 if (num < 1000000) {
1130 if (num < 1000000000) {
1131 int millions = num / 1000000;
1139 num = num % 1000000;
1141 ast_debug(1,
"Number '%d' is too big for me\n", num);
1145 if (num && num < 100)
1151 if ((audiofd > -1) && (ctrlfd > -1))
1184 while (!res && num) {
1200 if ( num > INT_MIN ) {
1205 }
else if (num == 1 && mf == -1) {
1206 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
1208 }
else if (num < 20) {
1209 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1211 }
else if (num < 100) {
1212 int ones = num % 10;
1214 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
1217 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1220 }
else if (num == 100 && t == 0) {
1223 }
else if (num < 1000) {
1224 int hundreds = num / 100;
1226 if (hundreds == 1) {
1229 snprintf(fn,
sizeof(fn),
"digits/%d", hundreds);
1232 }
else if (num == 1000 && t == 0) {
1235 }
else if (num < 1000000) {
1236 int thousands = num / 1000;
1239 if (thousands == 1) {
1248 }
else if (num < 1000000000) {
1249 int millions = num / 1000000;
1250 num = num % 1000000;
1252 if (millions == 1) {
1261 }
else if (num <= INT_MAX) {
1262 int billions = num / 1000000000;
1263 num = num % 1000000000;
1265 if (billions == 1) {
1276 ast_debug(1,
"Number '%d' is too big for me\n", num);
1281 if ((audiofd > -1) && (ctrlfd > -1))
1289 if ((audiofd > -1) && (ctrlfd > -1))
1315 while (!res && (num || playh || playa )) {
1318 if ( num > INT_MIN ) {
1329 }
else if (num < 20) {
1330 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1332 }
else if (num < 100) {
1333 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
1335 }
else if (num < 1000) {
1336 int hundreds = num / 100;
1337 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
1340 num -= 100 * hundreds;
1343 }
else if (num < 1000000) {
1349 if (num && num < 100)
1351 }
else if (num < 1000000000) {
1352 int millions = num / 1000000;
1358 if (num && num < 100)
1361 ast_debug(1,
"Number '%d' is too big for me\n", num);
1367 if ((audiofd > -1) && (ctrlfd > -1))
1395 if (!strncasecmp(
options,
"f", 1))
1397 else if (!strncasecmp(
options,
"m", 1))
1401 while (!res && num) {
1404 if ( num > INT_MIN ) {
1412 }
else if (num == 1) {
1414 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
1416 snprintf(fn,
sizeof(fn),
"digits/%dM", num);
1418 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1420 }
else if (num < 31) {
1421 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1423 }
else if (num < 100) {
1424 snprintf(fn,
sizeof(fn),
"digits/%d", (num/10)*10);
1428 }
else if (num == 100) {
1431 }
else if (num < 200) {
1436 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100)*100);
1438 }
else if (num < 2000) {
1442 if (num < 1000000) {
1449 if (num < 2147483640) {
1450 if ((num/1000000) == 1) {
1463 ast_debug(1,
"Number '%d' is too big for me\n", num);
1472 if ((audiofd > -1) && (ctrlfd > -1))
1502 while (!res && (num || playh || playa)) {
1505 if ( num > INT_MIN ) {
1516 }
else if (num == 1) {
1518 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
1520 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1522 }
else if (num < 21) {
1523 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1525 }
else if (num < 70) {
1526 snprintf(fn,
sizeof(fn),
"digits/%d", (num/10)*10);
1527 if ((num % 10) == 1) playa++;
1529 }
else if (num < 80) {
1531 if ((num % 10) == 1) playa++;
1533 }
else if (num < 100) {
1536 }
else if (num < 200) {
1539 }
else if (num < 1000) {
1540 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
1543 }
else if (num < 2000) {
1546 }
else if (num < 1000000) {
1552 }
else if (num < 1000000000) {
1557 num = num % 1000000;
1559 ast_debug(1,
"Number '%d' is too big for me\n", num);
1564 if ((audiofd > -1) && (ctrlfd > -1))
1580 #define SAY_NUM_BUF_SIZE 256
1590 ast_verb(3,
"ast_say_digits_full: started. num: %d, options=\"%s\"\n", num,
options);
1598 ast_verb(3,
"ast_say_digits_full: num: %d, state=%d, options=\"%s\", mf=%d\n", num,
state,
options, mf);
1601 while (!res && (num || (
state > 0))) {
1609 ast_verb(3,
"ast_say_digits_full: num: %d, state=%d, options=\"%s\", mf=%d, tmpnum=%d\n", num,
state,
options, mf, tmpnum);
1613 }
else if (
state == 2) {
1614 if ((num >= 11) && (num < 21)) {
1616 snprintf(fn,
sizeof(fn),
"digits/ve");
1618 snprintf(fn,
sizeof(fn),
"digits/uu");
1623 snprintf(fn,
sizeof(fn),
"digits/ve");
1626 snprintf(fn,
sizeof(fn),
"digits/uu");
1630 snprintf(fn,
sizeof(fn),
"digits/ve");
1632 snprintf(fn,
sizeof(fn),
"digits/uu");
1636 snprintf(fn,
sizeof(fn),
"digits/ve");
1639 snprintf(fn,
sizeof(fn),
"digits/ve");
1642 snprintf(fn,
sizeof(fn),
"digits/ve");
1645 snprintf(fn,
sizeof(fn),
"digits/ve");
1648 snprintf(fn,
sizeof(fn),
"digits/uu");
1651 snprintf(fn,
sizeof(fn),
"digits/ve");
1654 snprintf(fn,
sizeof(fn),
"digits/ve");
1659 }
else if (
state == 3) {
1660 snprintf(fn,
sizeof(fn),
"digits/1k");
1662 }
else if (num < 0) {
1663 snprintf(fn,
sizeof(fn),
"digits/minus");
1665 }
else if (num < 20) {
1667 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1669 snprintf(fn,
sizeof(fn),
"digits/%dm", num);
1672 }
else if ((num < 100) && (num >= 20)) {
1673 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
1678 }
else if ((num >= 100) && (num < 1000)) {
1680 snprintf(fn,
sizeof(fn),
"digits/%d00", tmpnum);
1681 num = num - (tmpnum * 100);
1682 if ((num > 0) && (num < 11)) {
1685 }
else if ((num >= 1000) && (num < 10000)) {
1686 tmpnum = num / 1000;
1687 snprintf(fn,
sizeof(fn),
"digits/%dk", tmpnum);
1688 num = num - (tmpnum * 1000);
1689 if ((num > 0) && (num < 11)) {
1692 }
else if (num < 20000) {
1693 snprintf(fn,
sizeof(fn),
"digits/%dm", (num / 1000));
1696 }
else if (num < 1000000) {
1701 snprintf(fn,
sizeof(fn),
"digits/1k");
1703 if ((num > 0) && (num < 11)) {
1706 }
else if (num < 2000000) {
1707 snprintf(fn,
sizeof(fn),
"digits/million");
1708 num = num % 1000000;
1709 if ((num > 0) && (num < 11)) {
1712 }
else if (num < 3000000) {
1713 snprintf(fn,
sizeof(fn),
"digits/twomillion");
1714 num = num - 2000000;
1715 if ((num > 0) && (num < 11)) {
1718 }
else if (num < 1000000000) {
1723 snprintf(fn,
sizeof(fn),
"digits/million");
1724 num = num % 1000000;
1725 if ((num > 0) && (num < 11)) {
1729 ast_debug(1,
"Number '%d' is too big for me\n", num);
1735 if ((audiofd > -1) && (ctrlfd > -1)) {
1767 while(!res && (num || playh)) {
1770 if ( num > INT_MIN ) {
1778 }
else if (num < 11 || num == 20) {
1779 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1781 }
else if (num < 20) {
1784 }
else if (num < 30) {
1787 }
else if (num < 100) {
1788 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
1792 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
1796 if (num < 1000000) {
1803 if (num < 1000000000) {
1810 ast_debug(1,
"Number '%d' is too big for me\n", num);
1818 if ((audiofd > -1) && (ctrlfd > -1))
1849 while (!res && (num || playh || playa )) {
1852 if ( num > INT_MIN ) {
1866 }
else if (num < 5 && cn == 2) {
1867 snprintf(fn,
sizeof(fn),
"digits/%dkvk", num);
1869 }
else if (num < 5 && cn == 3) {
1870 snprintf(fn,
sizeof(fn),
"digits/%dhk", num);
1872 }
else if (num < 20) {
1873 snprintf(fn,
sizeof(fn),
"digits/%d", num);
1875 }
else if (num < 100) {
1876 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
1880 }
else if (num < 1000) {
1881 int hundreds = num / 100;
1884 snprintf(fn,
sizeof(fn),
"digits/%dhk", hundreds);
1886 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
1889 num -= 100 * hundreds;
1890 if (num && num < 20)
1893 if (num && (num % 10) == 0)
1895 }
else if (num < 1000000) {
1898 if ((num % 100) == 0 && (num % 1000 != 0)) {
1905 if (num && (num < 20 || (num % 10 == 0)))
1907 }
else if (num < 1000000000) {
1908 int millions = num / 1000000;
1918 if (num && num < 100)
1920 }
else if (num < INT_MAX) {
1921 int milliards = num / 1000000000;
1931 if (num && num < 100)
1934 ast_debug(1,
"Number '%d' is too big for me\n", num);
1940 if ((audiofd > -1) && (ctrlfd > -1))
1987 while (!res && (num || playh)) {
1990 if ( num > INT_MIN ) {
1998 }
else if (num < 20) {
1999 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2001 }
else if (num == 21) {
2002 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2004 }
else if (num == 28) {
2005 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2007 }
else if (num == 31) {
2008 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2010 }
else if (num == 38) {
2011 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2013 }
else if (num == 41) {
2014 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2016 }
else if (num == 48) {
2017 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2019 }
else if (num == 51) {
2020 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2022 }
else if (num == 58) {
2023 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2025 }
else if (num == 61) {
2026 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2028 }
else if (num == 68) {
2029 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2031 }
else if (num == 71) {
2032 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2034 }
else if (num == 78) {
2035 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2037 }
else if (num == 81) {
2038 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2040 }
else if (num == 88) {
2041 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2043 }
else if (num == 91) {
2044 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2046 }
else if (num == 98) {
2047 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2049 }
else if (num < 100) {
2050 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
2054 if ((num / 100) > 1) {
2055 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
2062 if (num < 1000000) {
2069 if ((tempnum / 1000) < 2)
2074 if (num < 1000000000) {
2075 if ((num / 1000000) > 1)
2081 if ((tempnum / 1000000) < 2)
2086 ast_debug(1,
"Number '%d' is too big for me\n", num);
2094 if ((audiofd > -1) && (ctrlfd > -1))
2116 while (!res && (num || playh )) {
2119 if ( num > INT_MIN ) {
2127 }
else if (num < 20) {
2128 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2130 }
else if (num < 100) {
2139 snprintf(fn,
sizeof(fn),
"digits/%d", num - units);
2142 }
else if (num < 200) {
2146 }
else if (num < 1000) {
2147 snprintf(fn,
sizeof(fn),
"digits/%d", num / 100);
2155 }
else if (num < 10000) {
2162 if (num < 1000000) {
2169 if (num < 1000000000) {
2176 ast_debug(1,
"Number '%d' is too big for me\n", num);
2185 if ((audiofd > -1) && (ctrlfd > -1))
2219 while (!res && (num || playh || playa )) {
2222 if ( num > INT_MIN ) {
2233 }
else if (num == 1 && cn == -1) {
2236 }
else if (num < 20) {
2237 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2239 }
else if (num < 100) {
2240 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
2242 }
else if (num < 1000) {
2243 int hundreds = num / 100;
2247 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
2250 num -= 100 * hundreds;
2253 }
else if (num < 1000000) {
2259 if (num && num < 100)
2261 }
else if (num < 1000000000) {
2262 int millions = num / 1000000;
2268 if (num && num < 100)
2271 ast_debug(1,
"Number '%d' is too big for me\n", num);
2277 if ((audiofd > -1) && (ctrlfd > -1))
2293 char *dziesiatki[10];
2304 return odm->
rzedy[rzad - 1][0];
2305 if ((i > 21 || i < 11) && i%10 > 1 && i%10 < 5)
2306 return odm->
rzedy[rzad - 1][1];
2308 return odm->
rzedy[rzad - 1][2];
2313 strcpy(buffer,
str);
2314 buffer += strlen(
str);
2320 char file_name[255] =
"digits/";
2321 strcat(file_name, fn);
2322 ast_debug(1,
"Trying to play: %s\n", file_name);
2324 if ((audiofd > -1) && (ctrlfd > -1))
2344 if (i == 0 && rzad > 0) {
2352 m1000E6 = i % 1000000000;
2353 i1000E6 = i / 1000000000;
2357 m1000E3 = m1000E6 % 1000000;
2358 i1000E3 = m1000E6 / 1000000;
2362 m1000 = m1000E3 % 1000;
2363 i1000 = m1000E3 / 1000;
2373 if (m100 > 0 && m100 <= 9) {
2378 }
else if (m100 % 10 == 0 && m100 != 0) {
2380 }
else if (m100 > 10 && m100 <= 19) {
2382 }
else if (m100 > 20) {
2495 char *zenski_cyfry[] = {
"0",
"1z",
"2z",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
2497 char *zenski_cyfry2[] = {
"0",
"1",
"2z",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
2499 char *meski_cyfry[] = {
"0",
"1",
"2-1m",
"3-1m",
"4-1m",
"5m",
"6m",
"7m",
"8m",
"9m"};
2501 char *meski_cyfry2[] = {
"0",
"1",
"2-2m",
"3-2m",
"4-2m",
"5m",
"6m",
"7m",
"8m",
"9m"};
2503 char *meski_setki[] = {
"",
"100m",
"200m",
"300m",
"400m",
"500m",
"600m",
"700m",
"800m",
"900m"};
2505 char *meski_dziesiatki[] = {
"",
"10m",
"20m",
"30m",
"40m",
"50m",
"60m",
"70m",
"80m",
"90m"};
2507 char *meski_nastki[] = {
"",
"11m",
"12m",
"13m",
"14m",
"15m",
"16m",
"17m",
"18m",
"19m"};
2509 char *nijaki_cyfry[] = {
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
2511 char *nijaki_cyfry2[] = {
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
2513 char *nijaki_setki[] = {
"",
"100",
"200",
"300",
"400",
"500",
"600",
"700",
"800",
"900"};
2515 char *nijaki_dziesiatki[] = {
"",
"10",
"20",
"30",
"40",
"50",
"60",
"70",
"80",
"90"};
2517 char *nijaki_nastki[] = {
"",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19"};
2519 char *rzedy[][3] = { {
"1000",
"1000.2",
"1000.5"}, {
"1000000",
"1000000.2",
"1000000.5"}, {
"1000000000",
"1000000000.2",
"1000000000.5"}};
2528 if (odmiana_nieosobowa ==
NULL) {
2529 odmiana_nieosobowa =
ast_malloc(
sizeof(*odmiana_nieosobowa));
2533 memcpy(odmiana_nieosobowa->
cyfry, nijaki_cyfry,
sizeof(odmiana_nieosobowa->
cyfry));
2534 memcpy(odmiana_nieosobowa->
cyfry2, nijaki_cyfry2,
sizeof(odmiana_nieosobowa->
cyfry));
2535 memcpy(odmiana_nieosobowa->
setki, nijaki_setki,
sizeof(odmiana_nieosobowa->
setki));
2536 memcpy(odmiana_nieosobowa->
dziesiatki, nijaki_dziesiatki,
sizeof(odmiana_nieosobowa->
dziesiatki));
2537 memcpy(odmiana_nieosobowa->
nastki, nijaki_nastki,
sizeof(odmiana_nieosobowa->
nastki));
2538 memcpy(odmiana_nieosobowa->
rzedy, rzedy,
sizeof(odmiana_nieosobowa->
rzedy));
2541 if (odmiana_zenska ==
NULL) {
2542 odmiana_zenska =
ast_malloc(
sizeof(*odmiana_zenska));
2546 memcpy(odmiana_zenska->
cyfry, zenski_cyfry,
sizeof(odmiana_zenska->
cyfry));
2547 memcpy(odmiana_zenska->
cyfry2, zenski_cyfry2,
sizeof(odmiana_zenska->
cyfry));
2548 memcpy(odmiana_zenska->
setki, nijaki_setki,
sizeof(odmiana_zenska->
setki));
2550 memcpy(odmiana_zenska->
nastki, nijaki_nastki,
sizeof(odmiana_zenska->
nastki));
2551 memcpy(odmiana_zenska->
rzedy, rzedy,
sizeof(odmiana_zenska->
rzedy));
2554 if (odmiana_meska ==
NULL) {
2555 odmiana_meska =
ast_malloc(
sizeof(*odmiana_meska));
2559 memcpy(odmiana_meska->
cyfry, meski_cyfry,
sizeof(odmiana_meska->
cyfry));
2560 memcpy(odmiana_meska->
cyfry2, meski_cyfry2,
sizeof(odmiana_meska->
cyfry));
2561 memcpy(odmiana_meska->
setki, meski_setki,
sizeof(odmiana_meska->
setki));
2563 memcpy(odmiana_meska->
nastki, meski_nastki,
sizeof(odmiana_meska->
nastki));
2564 memcpy(odmiana_meska->
rzedy, rzedy,
sizeof(odmiana_meska->
rzedy));
2568 if (strncasecmp(
options,
"f", 1) == 0)
2570 else if (strncasecmp(
options,
"m", 1) == 0)
2573 o = odmiana_nieosobowa;
2575 o = odmiana_nieosobowa;
2602 while (!res && num ) {
2605 if ( num > INT_MIN ) {
2610 }
else if (num < 20) {
2611 if ((num == 1 || num == 2) && (mf < 0))
2612 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
2614 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2616 }
else if (num < 100) {
2617 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
2621 }
else if (num < 1000) {
2627 if (mf < 0 && num > 199)
2628 snprintf(fn,
sizeof(fn),
"digits/%dF", (num / 100) * 100);
2630 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100) * 100);
2635 }
else if (num < 1000000) {
2642 if ((num % 1000) && ((num % 1000) < 100 || !(num % 100)))
2645 }
else if (num < 1000000000) {
2654 if ((num % 1000000) &&
2656 ((!((num / 1000) % 1000) && ((num % 1000) < 100 || !(num % 100))) ||
2658 (!(num % 1000) && (((num / 1000) % 1000) < 100 || !((num / 1000) % 100))) ) )
2660 num = num % 1000000;
2668 if ((audiofd > -1) && (ctrlfd > -1))
2675 if (!res && playh) {
2702 while (num || playh) {
2705 if ( num > INT_MIN ) {
2713 }
else if (start && num < 200 && num > 99 && cn == -1) {
2715 snprintf(fn,
sizeof(fn),
"digits/hundred");
2717 }
else if (num == 1 && cn == -1) {
2720 }
else if (num < 20) {
2721 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2723 }
else if (num < 100) {
2724 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
2726 }
else if (num < 1000) {
2728 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
2731 }
else if (num < 1000000) {
2739 }
else if (num < 1000000000) {
2748 ast_debug(1,
"Number '%d' is too big for me\n", num);
2753 if ((audiofd > -1) && (ctrlfd > -1)) {
2775 int last_length = 0;
2781 while (!res && (num || playh || playt || playz)) {
2784 if ( num > INT_MIN ) {
2790 snprintf(fn,
sizeof(fn),
"digits/0");
2797 snprintf(fn,
sizeof(fn),
"digits/thousand");
2799 }
else if (num < 10) {
2800 snprintf(
buf, 12,
"%d", num);
2801 if (last_length - strlen(
buf) > 1 && last_length != 0) {
2802 last_length = strlen(
buf);
2806 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2808 }
else if (num < 100) {
2809 snprintf(
buf, 10,
"%d", num);
2810 if (last_length - strlen(
buf) > 1 && last_length != 0) {
2811 last_length = strlen(
buf);
2815 last_length = strlen(
buf);
2816 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
2820 snprintf(
buf, 10,
"%d", num);
2821 if (last_length - strlen(
buf) > 1 && last_length != 0) {
2822 last_length = strlen(
buf);
2826 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
2828 snprintf(
buf, 10,
"%d", num);
2829 ast_debug(1,
"Number '%d' %d %d\n", num, (
int)strlen(
buf), last_length);
2830 last_length = strlen(
buf);
2831 num -= ((num / 100) * 100);
2832 }
else if (num < 10000){
2833 snprintf(
buf, 10,
"%d", num);
2834 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 1000));
2836 snprintf(
buf, 10,
"%d", num);
2837 ast_debug(1,
"Number '%d' %d %d\n", num, (
int)strlen(
buf), last_length);
2838 last_length = strlen(
buf);
2839 num -= ((num / 1000) * 1000);
2840 }
else if (num < 100000000) {
2844 snprintf(
buf, 10,
"%d", num);
2845 ast_debug(1,
"Number '%d' %d %d\n", num, (
int)strlen(
buf), last_length);
2846 num -= ((num / 10000) * 10000);
2847 last_length = strlen(
buf);
2848 snprintf(fn,
sizeof(fn),
"digits/wan");
2850 if (num < 1000000000) {
2854 snprintf(
buf, 10,
"%d", num);
2855 ast_debug(1,
"Number '%d' %d %d\n", num, (
int)strlen(
buf), last_length);
2856 last_length = strlen(
buf);
2857 num -= ((num / 100000000) * 100000000);
2858 snprintf(fn,
sizeof(fn),
"digits/yi");
2860 ast_debug(1,
"Number '%d' is too big for me\n", num);
2867 if ((audiofd > -1) && (ctrlfd > -1))
2892 while (!res && (num || playh)) {
2894 snprintf(fn,
sizeof(fn),
"digits/hundred");
2896 }
else if (num < 100) {
2897 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2899 }
else if (num < 1000) {
2900 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
2902 num -= ((num / 100) * 100);
2903 }
else if (num < 100000) {
2908 snprintf(fn,
sizeof(fn),
"digits/thousand");
2909 }
else if (num < 10000000) {
2914 snprintf(fn,
sizeof(fn),
"digits/lac");
2915 }
else if (num < 1000000000) {
2919 num = num % 10000000;
2920 snprintf(fn,
sizeof(fn),
"digits/crore");
2922 ast_debug(1,
"Number '%d' is too big for me\n", num);
2928 if ((audiofd > -1) && (ctrlfd > -1)) {
2944 }
else if (num < 100) {
2946 }
else if (num < 1000) {
2976 while (!res && (num)) {
2979 if ( num > INT_MIN ) {
2984 }
else if (num < 20) {
2986 snprintf(fn,
sizeof(fn),
"digits/%d%s", num,
options);
2988 snprintf(fn,
sizeof(fn),
"digits/%d", num);
2991 }
else if (num < 100) {
2992 snprintf(fn,
sizeof(fn),
"digits/%d", num - (num % 10));
2994 }
else if (num < 1000){
2995 snprintf(fn,
sizeof(fn),
"digits/%d", num - (num % 100));
2997 }
else if (num < 1000000) {
3000 if (lastdigits < 3) {
3007 if (lastdigits == 1) {
3009 }
else if (lastdigits > 1 && lastdigits < 5) {
3015 }
else if (num < 1000000000) {
3021 if (lastdigits == 1) {
3023 }
else if (lastdigits > 1 && lastdigits < 5) {
3030 ast_debug(1,
"Number '%d' is too big for me\n", num);
3035 if ((audiofd > -1) && (ctrlfd > -1))
3055 while(!res && (num || playh)) {
3058 if ( num > INT_MIN ) {
3066 }
else if (num < 100) {
3067 if ((num <= 20) || ((num % 10) == 1)) {
3068 snprintf(fn,
sizeof(fn),
"digits/%d", num);
3071 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
3074 }
else if (num < 1000) {
3075 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
3078 }
else if (num < 10000) {
3084 }
else if (num < 100000) {
3090 }
else if (num < 1000000) {
3105 if ((audiofd > -1) && (ctrlfd > -1))
3128 while (!res && (num || playh)) {
3131 if ( num > INT_MIN ) {
3137 snprintf(fn,
sizeof(fn),
"digits/%da", num);
3146 }
else if (playoh) {
3149 }
else if (playohz) {
3152 }
else if (num < 20) {
3153 snprintf(fn,
sizeof(fn),
"digits/%d", num);
3155 }
else if (num < 100) {
3156 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
3158 if ((num == 5) || (num == 4) || (num == 1)) playl++;
3161 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
3163 if (num && (num < 10)) {
3170 if (num < 1000000) {
3175 snprintf(fn,
sizeof(fn),
"digits/thousand");
3176 if (num && (num < 10)) {
3178 }
else if (num && (num < 100)){
3186 if (num < 1000000000) {
3200 if ((audiofd > -1) && (ctrlfd > -1))
3215 if (!strncasecmp(
language,
"en", 2)) {
3217 }
else if (!strncasecmp(
language,
"da", 2)) {
3219 }
else if (!strncasecmp(
language,
"de", 2)) {
3221 }
else if (!strncasecmp(
language,
"he", 2)) {
3223 }
else if (!strncasecmp(
language,
"is", 2)) {
3225 }
else if (!strncasecmp(
language,
"vi", 2)) {
3240 while (!res && num) {
3243 if ( num > INT_MIN ) {
3248 }
else if (num < 20) {
3249 snprintf(fn,
sizeof(fn),
"digits/h-%d", num);
3251 }
else if (num < 100) {
3252 int tens = num / 10;
3255 snprintf(fn,
sizeof(fn),
"digits/h-%d", (tens * 10));
3257 snprintf(fn,
sizeof(fn),
"digits/%d", (tens * 10));
3259 }
else if (num < 1000) {
3260 int hundreds = num / 100;
3262 if (hundreds > 1 || t == 1) {
3272 }
else if (num < 1000000) {
3273 int thousands = num / 1000;
3275 if (thousands > 1 || t == 1) {
3286 }
else if (num < 1000000000) {
3287 int millions = num / 1000000;
3288 num = num % 1000000;
3298 }
else if (num < INT_MAX) {
3299 int billions = num / 1000000000;
3300 num = num % 1000000000;
3310 }
else if (num == INT_MAX) {
3314 ast_debug(1,
"Number '%d' is too big for me\n", num);
3320 if ((audiofd > -1) && (ctrlfd > -1)) {
3339 if ((audiofd > -1) && (ctrlfd > -1)) {
3356 char fn[256] =
"", fna[256] =
"";
3370 while (!res && num) {
3373 if ( num > INT_MIN ) {
3378 }
else if (num < 100 && t) {
3381 }
else if (num < 20) {
3382 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3384 }
else if (num < 100) {
3385 int ones = num % 10;
3387 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
3390 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3393 }
else if (num == 100 && t == 0) {
3394 snprintf(fn,
sizeof(fn),
"digits/h-hundred%s", gender);
3396 }
else if (num < 1000) {
3397 int hundreds = num / 100;
3399 if (hundreds == 1) {
3402 snprintf(fn,
sizeof(fn),
"digits/%d", hundreds);
3407 snprintf(fna,
sizeof(fna),
"digits/h-hundred%s", gender);
3410 }
else if (num < 1000000) {
3411 int thousands = num / 1000;
3413 if (thousands == 1) {
3420 snprintf(fna,
sizeof(fna),
"digits/h-thousand%s", gender);
3422 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3433 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3437 }
else if (num < 1000000000) {
3438 int millions = num / 1000000;
3439 num = num % 1000000;
3440 if (millions == 1) {
3446 snprintf(fna,
sizeof(fna),
"digits/h-million%s", gender);
3456 snprintf(fn,
sizeof(fn),
"digits/h-million%s", gender);
3460 }
else if (num < INT_MAX) {
3461 int billions = num / 1000000000;
3462 num = num % 1000000000;
3463 if (billions == 1) {
3469 snprintf(fna,
sizeof(fna),
"digits/h-milliard%s", gender);
3478 snprintf(fn,
sizeof(fna),
"digits/h-milliard%s", gender);
3482 }
else if (num == INT_MAX) {
3483 snprintf(fn,
sizeof(fn),
"digits/h-last%s", gender);
3486 ast_debug(1,
"Number '%d' is too big for me\n", num);
3492 if ((audiofd > -1) && (ctrlfd > -1))
3500 if ((audiofd > -1) && (ctrlfd > -1)) {
3519 char fn[256] =
"", fna[256] =
"";
3533 while (!res && num) {
3536 if ( num > INT_MIN ) {
3541 }
else if (num < 100 && t) {
3544 }
else if (num < 20) {
3545 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3547 }
else if (num < 100) {
3548 int ones = num % 10;
3550 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
3553 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3556 }
else if (num == 100 && t == 0) {
3557 snprintf(fn,
sizeof(fn),
"digits/h-hundred%s", gender);
3559 }
else if (num < 1000) {
3560 int hundreds = num / 100;
3562 if (hundreds == 1) {
3565 snprintf(fn,
sizeof(fn),
"digits/%d", hundreds);
3570 snprintf(fna,
sizeof(fna),
"digits/h-hundred%s", gender);
3573 }
else if (num < 1000000) {
3574 int thousands = num / 1000;
3576 if (thousands == 1) {
3583 snprintf(fna,
sizeof(fna),
"digits/h-thousand%s", gender);
3585 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3596 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3600 }
else if (num < 1000000000) {
3601 int millions = num / 1000000;
3602 num = num % 1000000;
3603 if (millions == 1) {
3609 snprintf(fna,
sizeof(fna),
"digits/h-million%s", gender);
3619 snprintf(fn,
sizeof(fn),
"digits/h-million%s", gender);
3623 }
else if (num < INT_MAX) {
3624 int billions = num / 1000000000;
3625 num = num % 1000000000;
3626 if (billions == 1) {
3632 snprintf(fna,
sizeof(fna),
"digits/h-milliard%s", gender);
3641 snprintf(fn,
sizeof(fna),
"digits/h-milliard%s", gender);
3645 }
else if (num == INT_MAX) {
3646 snprintf(fn,
sizeof(fn),
"digits/h-last%s", gender);
3649 ast_debug(1,
"Number '%d' is too big for me\n", num);
3655 if ((audiofd > -1) && (ctrlfd > -1))
3663 if ((audiofd > -1) && (ctrlfd > -1)) {
3682 ast_verb(3,
"ast_say_digits_full: started. num: %d, options=\"%s\"\n", num,
options);
3688 ast_verb(3,
"ast_say_digits_full: num: %d, options=\"%s\", mf=%d\n", num,
options, mf);
3690 while (!res && num) {
3692 snprintf(fn,
sizeof(fn),
"digits/minus");
3693 if (num > INT_MIN) {
3698 }
else if (num < 21) {
3701 snprintf(fn,
sizeof(fn),
"digits/f-0%d", num);
3703 snprintf(fn,
sizeof(fn),
"digits/f-%d", num);
3707 snprintf(fn,
sizeof(fn),
"digits/m-0%d", num);
3709 snprintf(fn,
sizeof(fn),
"digits/m-%d", num);
3713 }
else if ((num < 100) && num >= 20) {
3714 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
3716 }
else if ((num >= 100) && (num < 1000)) {
3717 int tmpnum = num / 100;
3718 snprintf(fn,
sizeof(fn),
"digits/%d00", tmpnum);
3719 num = num - (tmpnum * 100);
3720 }
else if ((num >= 1000) && (num < 10000)) {
3721 int tmpnum = num / 1000;
3722 snprintf(fn,
sizeof(fn),
"digits/%dk", tmpnum);
3723 num = num - (tmpnum * 1000);
3724 }
else if (num < 20000) {
3725 snprintf(fn,
sizeof(fn),
"digits/m-%d", (num / 1000));
3727 }
else if (num < 1000000) {
3732 snprintf(fn,
sizeof(fn),
"digits/1k");
3734 }
else if (num < 2000000) {
3735 snprintf(fn,
sizeof(fn),
"digits/1m");
3736 num = num % 1000000;
3737 }
else if (num < 3000000) {
3738 snprintf(fn,
sizeof(fn),
"digits/2m");
3739 num = num - 2000000;
3740 }
else if (num < 1000000000) {
3745 snprintf(fn,
sizeof(fn),
"digits/1m");
3746 num = num % 1000000;
3748 ast_debug(1,
"Number '%d' is too big for me\n", num);
3753 if ((audiofd > -1) && (ctrlfd > -1)) {
3770 char fn[256] =
"", fna[256] =
"";
3784 while (!res && num) {
3787 if ( num > INT_MIN ) {
3792 }
else if (num < 100 && t) {
3795 }
else if (num < 20) {
3796 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3798 }
else if (num < 100) {
3799 int ones = num % 10;
3801 int tens = num - ones;
3802 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", tens, gender);
3807 snprintf(fn,
sizeof(fn),
"digits/and");
3811 snprintf(fn,
sizeof(fn),
"digits/h-%d%s", num, gender);
3815 }
else if (num == 100 && t == 0) {
3816 snprintf(fn,
sizeof(fn),
"digits/h-hundred%s", gender);
3818 }
else if (num < 1000) {
3819 int hundreds = num / 100;
3821 if (hundreds == 1) {
3824 snprintf(fn,
sizeof(fn),
"digits/%d", hundreds);
3829 snprintf(fna,
sizeof(fna),
"digits/h-hundred%s", gender);
3832 }
else if (num < 1000000) {
3833 int thousands = num / 1000;
3835 if (thousands == 1) {
3843 snprintf(fna,
sizeof(fna),
"digits/h-thousand%s", gender);
3845 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3856 snprintf(fn,
sizeof(fn),
"digits/h-thousand%s", gender);
3861 }
else if (num < 1000000000) {
3862 int millions = num / 1000000;
3863 num = num % 1000000;
3864 if (millions == 1) {
3871 snprintf(fna,
sizeof(fna),
"digits/h-million%s", gender);
3881 snprintf(fn,
sizeof(fn),
"digits/h-million%s", gender);
3886 }
else if (num < INT_MAX) {
3887 int billions = num / 1000000000;
3888 num = num % 1000000000;
3889 if (billions == 1) {
3895 snprintf(fna,
sizeof(fna),
"digits/h-milliard%s", gender);
3904 snprintf(fn,
sizeof(fna),
"digits/h-milliard%s", gender);
3909 }
else if (num == INT_MAX) {
3910 snprintf(fn,
sizeof(fn),
"digits/h-last%s", gender);
3913 ast_debug(1,
"Number '%d' is too big for me\n", num);
3919 if ((audiofd > -1) && (ctrlfd > -1))
3927 if ((audiofd > -1) && (ctrlfd > -1)) {
3943 if (!strncasecmp(lang,
"en", 2)) {
3945 }
else if (!strncasecmp(lang,
"da", 2)) {
3947 }
else if (!strncasecmp(lang,
"de", 2)) {
3949 }
else if (!strncasecmp(lang,
"fr", 2)) {
3951 }
else if (!strncasecmp(lang,
"gr", 2)) {
3953 }
else if (!strncasecmp(lang,
"ja", 2)) {
3955 }
else if (!strncasecmp(lang,
"he", 2)) {
3957 }
else if (!strncasecmp(lang,
"hu", 2)) {
3959 }
else if (!strncasecmp(lang,
"is", 2)) {
3961 }
else if (!strncasecmp(lang,
"ka", 2)) {
3963 }
else if (!strncasecmp(lang,
"nl", 2)) {
3965 }
else if (!strncasecmp(lang,
"pt", 2)) {
3967 }
else if (!strncasecmp(lang,
"th", 2)) {
3979 struct timeval when = { t, 0 };
3984 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
3990 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4007 struct timeval when = { t, 0 };
4013 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4023 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4039 snprintf(fn,
sizeof(fn),
"digits/%d", (year / 100));
4042 res =
wait_file(chan, ints,
"digits/hundred", lang);
4043 if (!res && year % 100 != 0) {
4056 struct timeval when = { t, 0 };
4062 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4072 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4089 snprintf(fn,
sizeof(fn),
"digits/%d", (year / 100) );
4092 res =
wait_file(chan, ints,
"digits/hundred", lang);
4093 if (!res && year % 100 != 0) {
4106 struct timeval when = { t, 0 };
4117 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4127 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4138 struct timeval when = { t, 0 };
4144 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4154 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4167 struct timeval when = { t, 0 };
4173 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4181 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4196 struct timeval when = { t, 0 };
4202 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4216 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4232 struct timeval when = { t, 0 };
4238 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4244 res =
wait_file(chan, ints,
"digits/pt-de", lang);
4245 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4249 res =
wait_file(chan, ints,
"digits/pt-de", lang);
4259 struct timeval when = { t, 0 };
4265 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4272 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4293 struct timeval when = { t, 0 };
4299 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.
tm_wday);
4309 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.
tm_mon);
4325 snprintf(fn,
sizeof(fn),
"digits/%d", (year / 100));
4328 res =
wait_file(chan, ints,
"digits/hundred", lang);
4329 if (!res && year % 100 != 0) {
4341 if (!strncasecmp(lang,
"en", 2)) {
4343 }
else if (!strncasecmp(lang,
"da", 2)) {
4345 }
else if (!strncasecmp(lang,
"de", 2)) {
4347 }
else if (!strncasecmp(lang,
"es", 2)) {
4349 }
else if (!strncasecmp(lang,
"he", 2)) {
4351 }
else if (!strncasecmp(lang,
"fr", 2)) {
4353 }
else if (!strncasecmp(lang,
"gr", 2)) {
4355 }
else if (!strncasecmp(lang,
"is", 2)) {
4357 }
else if (!strncasecmp(lang,
"ja", 2)) {
4359 }
else if (!strncasecmp(lang,
"it", 2)) {
4361 }
else if (!strncasecmp(lang,
"nl", 2)) {
4363 }
else if (!strncasecmp(lang,
"pl", 2)) {
4365 }
else if (!strncasecmp(lang,
"pt", 2)) {
4367 }
else if (!strncasecmp(lang,
"th", 2)) {
4369 }
else if (!strncasecmp(lang,
"zh", 2)) {
4371 }
else if (!strncasecmp(lang,
"vi", 2)) {
4382 struct timeval when = { t, 0 };
4384 int res=0, offset, sndoffset;
4385 char sndfile[256], nextmsg[256];
4388 format =
"ABdY 'digits/at' IMp";
4392 for (offset=0 ;
format[offset] !=
'\0' ; offset++) {
4394 switch (
format[offset]) {
4398 for (sndoffset = 0; !strchr(
"\'\0",
format[++offset]) && (sndoffset <
sizeof(sndfile) - 1) ; sndoffset++) {
4399 sndfile[sndoffset] =
format[offset];
4401 sndfile[sndoffset] =
'\0';
4402 res =
wait_file(chan, ints, sndfile, lang);
4407 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.
tm_wday);
4408 res =
wait_file(chan, ints, nextmsg, lang);
4414 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.
tm_mon);
4415 res =
wait_file(chan, ints, nextmsg, lang);
4434 res =
wait_file(chan, ints,
"digits/19", lang);
4438 res =
wait_file(chan, ints,
"digits/oh", lang);
4451 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour - 12);
4453 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour);
4454 res =
wait_file(chan, ints, nextmsg, lang);
4459 if (
format[offset] ==
'H') {
4462 res =
wait_file(chan, ints,
"digits/oh", lang);
4467 res =
wait_file(chan, ints,
"digits/oh", lang);
4474 res =
wait_file(chan, ints,
"digits/20", lang);
4478 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", remaining);
4479 res =
wait_file(chan, ints, nextmsg, lang);
4488 if (
format[offset] ==
'M') {
4489 res =
wait_file(chan, ints,
"digits/oclock", lang);
4491 res =
wait_file(chan, ints,
"digits/hundred", lang);
4493 }
else if (tm.
tm_min < 10) {
4494 res =
wait_file(chan, ints,
"digits/oh", lang);
4496 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_min);
4497 res =
wait_file(chan, ints, nextmsg, lang);
4510 res =
wait_file(chan, ints, nextmsg, lang);
4522 gettimeofday(&now,
NULL);
4527 if (beg_today + 15768000 < t) {
4530 }
else if (beg_today + 2628000 < t) {
4533 }
else if (beg_today + 86400 * 6 < t) {
4536 }
else if (beg_today + 172800 < t) {
4539 }
else if (beg_today + 86400 < t) {
4541 res =
wait_file(chan, ints,
"digits/tomorrow", lang);
4542 }
else if (beg_today < t) {
4544 res =
wait_file(chan, ints,
"digits/today", lang);
4545 }
else if (beg_today - 86400 < t) {
4547 res =
wait_file(chan, ints,
"digits/yesterday", lang);
4548 }
else if (beg_today - 86400 * 6 < t) {
4551 }
else if (beg_today - 2628000 < t) {
4554 }
else if (beg_today - 15768000 < t) {
4578 if (beg_today + 15768000 < t) {
4581 }
else if (beg_today + 2628000 < t) {
4584 }
else if (beg_today + 86400 * 6 < t) {
4587 }
else if (beg_today + 172800 < t) {
4590 }
else if (beg_today + 86400 < t) {
4592 res =
wait_file(chan, ints,
"digits/tomorrow", lang);
4593 }
else if (beg_today < t) {
4595 res =
wait_file(chan, ints,
"digits/today", lang);
4596 }
else if (beg_today - 86400 < t) {
4598 res =
wait_file(chan, ints,
"digits/yesterday", lang);
4599 }
else if (beg_today - 86400 * 6 < t) {
4602 }
else if (beg_today - 2628000 < t) {
4605 }
else if (beg_today - 15768000 < t) {
4620 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_sec);
4621 res =
wait_file(chan, ints, nextmsg, lang);
4622 }
else if (tm.
tm_sec < 10) {
4623 res =
wait_file(chan, ints,
"digits/oh", lang);
4625 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_sec);
4626 res =
wait_file(chan, ints, nextmsg, lang);
4660 struct timeval when = { t, 0 };
4662 int res=0, offset, sndoffset;
4663 char sndfile[256], nextmsg[256];
4670 for (offset=0 ;
format[offset] !=
'\0' ; offset++) {
4672 switch (
format[offset]) {
4676 for (sndoffset = 0; !strchr(
"\'\0",
format[++offset]) && (sndoffset <
sizeof(sndfile) - 1) ; sndoffset++) {
4677 sndfile[sndoffset] =
format[offset];
4679 sndfile[sndoffset] =
'\0';
4680 res =
wait_file(chan, ints, sndfile, lang);
4685 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.
tm_wday);
4686 res =
wait_file(chan, ints, nextmsg, lang);
4692 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.
tm_mon);
4693 res =
wait_file(chan, ints, nextmsg, lang);
4717 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", (year / 100) );
4718 res =
wait_file(chan, ints, nextmsg, lang);
4720 res =
wait_file(chan, ints,
"digits/hundred", lang);
4721 if (!res && year % 100 != 0) {
4732 res =
wait_file(chan, ints,
"digits/oclock", lang);
4736 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour - 12);
4738 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour);
4740 res =
wait_file(chan, ints, nextmsg, lang);
4746 res =
wait_file(chan, ints,
"digits/0", lang);
4760 res =
wait_file(chan, ints,
"minute", lang);
4762 res =
wait_file(chan, ints,
"minutes", lang);
4773 res =
wait_file(chan, ints, nextmsg, lang);
4789 if (beg_today < t) {
4791 res =
wait_file(chan, ints,
"digits/today", lang);
4792 }
else if (beg_today - 86400 < t) {
4794 res =
wait_file(chan, ints,
"digits/yesterday", lang);
4814 if (beg_today < t) {
4816 }
else if ((beg_today - 86400) < t) {
4818 res =
wait_file(chan, ints,
"digits/yesterday", lang);
4819 }
else if (beg_today - 86400 * 6 < t) {
4832 res =
wait_file(chan, ints,
"digits/and", lang);
4836 res =
wait_file(chan, ints,
"seconds", lang);
4862 struct timeval when = { t, 0 };
4864 int res=0, offset, sndoffset;
4865 char sndfile[256], nextmsg[256];
4872 for (offset=0 ;
format[offset] !=
'\0' ; offset++) {
4874 switch (
format[offset]) {
4878 for (sndoffset = 0; !strchr(
"\'\0",
format[++offset]) && (sndoffset <
sizeof(sndfile) - 1) ; sndoffset++) {
4879 sndfile[sndoffset] =
format[offset];
4881 sndfile[sndoffset] =
'\0';
4882 res =
wait_file(chan, ints, sndfile, lang);
4887 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.
tm_wday);
4888 res =
wait_file(chan, ints, nextmsg, lang);
4894 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.
tm_mon);
4895 res =
wait_file(chan, ints, nextmsg, lang);
4919 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", (year / 100) );
4920 res =
wait_file(chan, ints, nextmsg, lang);
4922 res =
wait_file(chan, ints,
"digits/hundred", lang);
4923 if (!res && year % 100 != 0) {
4937 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour - 12);
4939 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour);
4940 res =
wait_file(chan, ints, nextmsg, lang);
4942 res =
wait_file(chan, ints,
"digits/oclock", lang);
4950 res =
wait_file(chan, ints,
"digits/oclock", lang);
4957 }
else if (tm.
tm_min > 0) {
4963 res =
wait_file(chan, ints,
"minute", lang);
4965 res =
wait_file(chan, ints,
"minutes", lang);
4976 res =
wait_file(chan, ints, nextmsg, lang);
4992 if (beg_today < t) {
4994 res =
wait_file(chan, ints,
"digits/today", lang);
4995 }
else if (beg_today - 86400 < t) {
4997 res =
wait_file(chan, ints,
"digits/yesterday", lang);
5017 if (beg_today < t) {
5019 }
else if ((beg_today - 86400) < t) {
5021 res =
wait_file(chan, ints,
"digits/yesterday", lang);
5022 }
else if (beg_today - 86400 * 6 < t) {
5035 res =
wait_file(chan, ints,
"digits/and", lang);
5039 res =
wait_file(chan, ints, tm.
tm_sec == 1 ?
"second" :
"seconds", lang);
5065 struct timeval when = { t, 0 };
5067 int res=0, offset, sndoffset;
5068 char sndfile[256], nextmsg[256];
5075 for (offset=0 ;
format[offset] !=
'\0' ; offset++) {
5077 switch (
format[offset]) {
5081 for (sndoffset = 0; !strchr(
"\'\0",
format[++offset]) && (sndoffset <
sizeof(sndfile) - 1) ; sndoffset++) {
5082 sndfile[sndoffset] =
format[offset];
5084 sndfile[sndoffset] =
'\0';
5085 res =
wait_file(chan, ints, sndfile, lang);
5090 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.
tm_wday);
5091 res =
wait_file(chan, ints, nextmsg, lang);
5097 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.
tm_mon);
5098 res =
wait_file(chan, ints, nextmsg, lang);
5122 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", (year / 100) );
5123 res =
wait_file(chan, ints, nextmsg, lang);
5125 res =
wait_file(chan, ints,
"digits/hundred", lang);
5126 if (!res && year % 100 != 0) {
5137 res =
wait_file(chan, ints,
"digits/oclock", lang);
5141 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour - 12);
5143 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.
tm_hour);
5145 res =
wait_file(chan, ints, nextmsg, lang);
5151 res =
wait_file(chan, ints,
"digits/0", lang);
5162 res =
wait_file(chan, ints,
"digits/0", lang);