00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
#include <sys/types.h>
00015
#include <string.h>
00016
#include <stdlib.h>
00017
#include <netinet/in.h>
00018
#include <time.h>
00019
#include <ctype.h>
00020
#include <math.h>
00021
#include <asterisk/file.h>
00022
#include <asterisk/channel.h>
00023
#include <asterisk/logger.h>
00024
#include <asterisk/say.h>
00025
#include <asterisk/lock.h>
00026
#include <asterisk/localtime.h>
00027
#include <asterisk/utils.h>
00028
#include "asterisk.h"
00029
#include <stdio.h>
00030
00031
00032
00033
static int wait_file(
struct ast_channel *chan,
char *ints,
char *file,
char *lang);
00034
00035 int ast_say_digit_str(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang)
00036 {
00037
00038
char fn[256] =
"";
00039
int num = 0;
00040
int res = 0;
00041
while(fn2[num] && !res) {
00042 fn[0] =
'\0';
00043
switch (fn2[num]) {
00044
case (
'*'):
00045 snprintf(fn,
sizeof(fn),
"digits/star");
00046
break;
00047
case (
'#'):
00048 snprintf(fn,
sizeof(fn),
"digits/pound");
00049
break;
00050
default:
00051
if((fn2[num] >=
'0') && (fn2[num] <=
'9')){
00052 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00053 }
00054 }
00055
if(!ast_strlen_zero(fn)){
00056 res =
ast_streamfile(chan, fn, lang);
00057
if (!res)
00058 res =
ast_waitstream(chan, ints);
00059
ast_stopstream(chan);
00060 }
00061 num++;
00062 }
00063
return res;
00064 }
00065
00066 int ast_say_character_str(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang)
00067 {
00068
00069
char fn[256] =
"";
00070
char ltr;
00071
int num = 0;
00072
int res = 0;
00073
while(fn2[num] && !res) {
00074 fn[0] =
'\0';
00075
switch (fn2[num]) {
00076
case (
'*'):
00077 snprintf(fn,
sizeof(fn),
"digits/star");
00078
break;
00079
case (
'#'):
00080 snprintf(fn,
sizeof(fn),
"digits/pound");
00081
break;
00082
case (
'0'):
00083
case (
'1'):
00084
case (
'2'):
00085
case (
'3'):
00086
case (
'4'):
00087
case (
'5'):
00088
case (
'6'):
00089
case (
'7'):
00090
case (
'8'):
00091
case (
'9'):
00092 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00093
break;
00094
case (
'!'):
00095 strncpy(fn,
"letters/exclaimation-point",
sizeof(fn));
00096
break;
00097
case (
'@'):
00098 strncpy(fn,
"letters/at",
sizeof(fn));
00099
break;
00100
case (
'$'):
00101 strncpy(fn,
"letters/dollar",
sizeof(fn));
00102
break;
00103
case (
'-'):
00104 strncpy(fn,
"letters/dash",
sizeof(fn));
00105
break;
00106
case (
'.'):
00107 strncpy(fn,
"letters/dot",
sizeof(fn));
00108
break;
00109
case (
'='):
00110 strncpy(fn,
"letters/equals",
sizeof(fn));
00111
break;
00112
case (
'+'):
00113 strncpy(fn,
"letters/plus",
sizeof(fn));
00114
break;
00115
case (
'/'):
00116 strncpy(fn,
"letters/slash",
sizeof(fn));
00117
break;
00118
case (
' '):
00119 strncpy(fn,
"letters/space",
sizeof(fn));
00120
break;
00121
default:
00122 ltr = fn2[num];
00123
if (
'A' <= ltr && ltr <=
'Z') ltr +=
'a' -
'A';
00124 snprintf(fn,
sizeof(fn),
"letters/%c", ltr);
00125 }
00126
if(!ast_strlen_zero(fn)) {
00127 res =
ast_streamfile(chan, fn, lang);
00128
if (!res)
00129 res =
ast_waitstream(chan, ints);
00130 }
ast_stopstream(chan);
00131 num++;
00132 }
00133
return res;
00134 }
00135
00136 int ast_say_phonetic_str(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang)
00137 {
00138
00139
char fn[256] =
"";
00140
char ltr;
00141
int num = 0;
00142
int res = 0;
00143
int temp;
00144
int play;
00145
char hex[3];
00146
00147
while(fn2[num]) {
00148 play=1;
00149
switch (fn2[num]) {
00150
case (
'*'):
00151 snprintf(fn,
sizeof(fn),
"digits/star");
00152
break;
00153
case (
'#'):
00154 snprintf(fn,
sizeof(fn),
"digits/pound");
00155
break;
00156
case (
'0'):
00157
case (
'1'):
00158
case (
'2'):
00159
case (
'3'):
00160
case (
'4'):
00161
case (
'5'):
00162
case (
'6'):
00163
case (
'7'):
00164
case (
'8'):
00165 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00166
break;
00167
case (
'!'):
00168 strncpy(fn,
"exclaimation-point",
sizeof(fn));
00169
break;
00170
case (
'@'):
00171 strncpy(fn,
"at",
sizeof(fn));
00172
break;
00173
case (
'$'):
00174 strncpy(fn,
"dollar",
sizeof(fn));
00175
break;
00176
case (
'-'):
00177 strncpy(fn,
"dash",
sizeof(fn));
00178
break;
00179
case (
'.'):
00180 strncpy(fn,
"dot",
sizeof(fn));
00181
break;
00182
case (
'='):
00183 strncpy(fn,
"equals",
sizeof(fn));
00184
break;
00185
case (
'+'):
00186 strncpy(fn,
"plus",
sizeof(fn));
00187
break;
00188
case (
'/'):
00189 strncpy(fn,
"slash",
sizeof(fn));
00190
break;
00191
case (
' '):
00192 strncpy(fn,
"space",
sizeof(fn));
00193
break;
00194
case (
'%'):
00195 play=0;
00196
00197
if (strlen(fn2) > num+2)
00198 {
00199 hex[0]=fn2[num+1];
00200 hex[1]=fn2[num+2];
00201 hex[2]=
'\0';
00202
if (sscanf(hex,
"%x", &temp))
00203 {
00204 fn2[num+2]=temp;
00205 num++;
00206
if (temp==37)
00207 {
00208 strncpy(fn,
"percent",
sizeof(fn));
00209 num++;
00210 play=1;
00211 }
00212
00213
if ((temp<32) || (temp>126))
00214 {
00215 num++;
00216 }
00217 }
00218 }
00219
else
00220 num++;
00221
break;
00222
default:
00223 ltr = tolower(fn2[num]);
00224 snprintf(fn,
sizeof(fn),
"phonetic/%c_p", ltr);
00225 }
00226
if (play)
00227 {
00228 res =
ast_streamfile(chan, fn, lang);
00229
if (!res)
00230 res =
ast_waitstream(chan, ints);
00231
ast_stopstream(chan);
00232 }
00233 num++;
00234 }
00235
return res;
00236 }
00237
00238 int ast_say_digit_str_full(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang,
int audiofd,
int ctrlfd)
00239 {
00240
char fn[256] =
"";
00241
int num = 0;
00242
int res = 0;
00243
while(fn2[num] && !res) {
00244 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00245 res =
ast_streamfile(chan, fn, lang);
00246
if (!res)
00247 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00248
ast_stopstream(chan);
00249 num++;
00250 }
00251
return res;
00252 }
00253
00254 int ast_say_character_str_full(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang,
int audiofd,
int ctrlfd)
00255 {
00256
char fn[256] =
"";
00257
char ltr;
00258
int num = 0;
00259
int res = 0;
00260
while(fn2[num] && !res) {
00261
switch (fn2[num]) {
00262
case (
'*'):
00263 snprintf(fn,
sizeof(fn),
"digits/star");
00264
break;
00265
case (
'#'):
00266 snprintf(fn,
sizeof(fn),
"digits/pound");
00267
break;
00268
case (
'0'):
00269
case (
'1'):
00270
case (
'2'):
00271
case (
'3'):
00272
case (
'4'):
00273
case (
'5'):
00274
case (
'6'):
00275
case (
'7'):
00276
case (
'8'):
00277
case (
'9'):
00278 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00279
break;
00280
case (
'!'):
00281 strncpy(fn,
"exclaimation-point",
sizeof(fn));
00282
break;
00283
case (
'@'):
00284 strncpy(fn,
"at",
sizeof(fn));
00285
break;
00286
case (
'$'):
00287 strncpy(fn,
"dollar",
sizeof(fn));
00288
break;
00289
case (
'-'):
00290 strncpy(fn,
"dash",
sizeof(fn));
00291
break;
00292
case (
'.'):
00293 strncpy(fn,
"dot",
sizeof(fn));
00294
break;
00295
case (
'='):
00296 strncpy(fn,
"equals",
sizeof(fn));
00297
break;
00298
case (
'+'):
00299 strncpy(fn,
"plus",
sizeof(fn));
00300
break;
00301
case (
'/'):
00302 strncpy(fn,
"slash",
sizeof(fn));
00303
break;
00304
case (
' '):
00305 strncpy(fn,
"space",
sizeof(fn));
00306
break;
00307
default:
00308 ltr = fn2[num];
00309
if (
'A' <= ltr && ltr <=
'Z') ltr +=
'a' -
'A';
00310 snprintf(fn,
sizeof(fn),
"letters/%c", ltr);
00311 }
00312
00313 res =
ast_streamfile(chan, fn, lang);
00314
if (!res)
00315 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00316
ast_stopstream(chan);
00317 num++;
00318 }
00319
return res;
00320 }
00321
00322 int ast_say_phonetic_str_full(
struct ast_channel *chan,
char *fn2,
char *ints,
char *lang,
int audiofd,
int ctrlfd)
00323 {
00324
char fn[256] =
"";
00325
char ltr;
00326
int num = 0;
00327
int res = 0;
00328
while(fn2[num] && !res) {
00329
switch (fn2[num]) {
00330
case (
'*'):
00331 snprintf(fn,
sizeof(fn),
"digits/star");
00332
break;
00333
case (
'#'):
00334 snprintf(fn,
sizeof(fn),
"digits/pound");
00335
break;
00336
case (
'0'):
00337
case (
'1'):
00338
case (
'2'):
00339
case (
'3'):
00340
case (
'4'):
00341
case (
'5'):
00342
case (
'6'):
00343
case (
'7'):
00344
case (
'8'):
00345 snprintf(fn,
sizeof(fn),
"digits/%c", fn2[num]);
00346
break;
00347
case (
'!'):
00348 strncpy(fn,
"exclaimation-point",
sizeof(fn));
00349
break;
00350
case (
'@'):
00351 strncpy(fn,
"at",
sizeof(fn));
00352
break;
00353
case (
'$'):
00354 strncpy(fn,
"dollar",
sizeof(fn));
00355
break;
00356
case (
'-'):
00357 strncpy(fn,
"dash",
sizeof(fn));
00358
break;
00359
case (
'.'):
00360 strncpy(fn,
"dot",
sizeof(fn));
00361
break;
00362
case (
'='):
00363 strncpy(fn,
"equals",
sizeof(fn));
00364
break;
00365
case (
'+'):
00366 strncpy(fn,
"plus",
sizeof(fn));
00367
break;
00368
case (
'/'):
00369 strncpy(fn,
"slash",
sizeof(fn));
00370
break;
00371
case (
' '):
00372 strncpy(fn,
"space",
sizeof(fn));
00373
break;
00374
default:
00375 ltr = fn2[num];
00376
if (
'A' <= ltr && ltr <=
'Z') ltr +=
'a' -
'A';
00377 snprintf(fn,
sizeof(fn),
"phonetic/%c", ltr);
00378 }
00379
00380 res =
ast_streamfile(chan, fn, lang);
00381
if (!res)
00382 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00383
ast_stopstream(chan);
00384 num++;
00385 }
00386
return res;
00387 }
00388
00389 int ast_say_digits(
struct ast_channel *chan,
int num,
char *ints,
char *lang)
00390 {
00391
00392
char fn2[256];
00393 snprintf(fn2,
sizeof(fn2),
"%d", num);
00394
return ast_say_digit_str(chan, fn2, ints, lang);
00395 }
00396
00397 int ast_say_digits_full(
struct ast_channel *chan,
int num,
char *ints,
char *lang,
int audiofd,
int ctrlfd)
00398 {
00399
char fn2[256];
00400 snprintf(fn2,
sizeof(fn2),
"%d", num);
00401
return ast_say_digit_str_full(chan, fn2, ints, lang, audiofd, ctrlfd);
00402 }
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
static int ast_say_number_full_en(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd);
00447
static int ast_say_number_full_da(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00448
static int ast_say_number_full_de(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00449
static int ast_say_number_full_es(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00450
static int ast_say_number_full_fr(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00451
static int ast_say_number_full_it(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd);
00452
static int ast_say_number_full_nl(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd);
00453
static int ast_say_number_full_pl(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00454
static int ast_say_number_full_pt(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00455
static int ast_say_number_full_se(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00456
static int ast_say_number_full_tw(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd);
00457
static int ast_say_number_full_cz(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd);
00458
00459
00460
static int ast_say_date_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00461
static int ast_say_date_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00462
static int ast_say_date_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00463
00464
static int ast_say_date_with_format_en(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00465
static int ast_say_date_with_format_de(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00466
static int ast_say_date_with_format_es(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00467
static int ast_say_date_with_format_nl(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00468
static int ast_say_date_with_format_pt(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00469
static int ast_say_date_with_format_tw(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone);
00470
00471
static int ast_say_time_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00472
static int ast_say_time_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00473
static int ast_say_time_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00474
static int ast_say_time_tw(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00475
00476
static int ast_say_datetime_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00477
static int ast_say_datetime_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00478
static int ast_say_datetime_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00479
static int ast_say_datetime_tw(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00480
00481
static int ast_say_datetime_from_now_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00482
static int ast_say_datetime_from_now_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang);
00483
00484
static int wait_file(
struct ast_channel *chan,
char *ints,
char *file,
char *lang)
00485 {
00486
int res;
00487
if ((res =
ast_streamfile(chan, file, lang)))
00488
ast_log(LOG_WARNING,
"Unable to play message %s\n", file);
00489
if (!res)
00490 res =
ast_waitstream(chan, ints);
00491
return res;
00492 }
00493
00494
00495
00496 int ast_say_number_full(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
00497 {
00498
if (!strcasecmp(language,
"en") ) {
00499
return(ast_say_number_full_en(chan, num, ints, language, audiofd, ctrlfd));
00500 }
else if (!strcasecmp(language,
"da") ) {
00501
return(ast_say_number_full_da(chan, num, ints, language, options, audiofd, ctrlfd));
00502 }
else if (!strcasecmp(language,
"de") ) {
00503
return(ast_say_number_full_de(chan, num, ints, language, options, audiofd, ctrlfd));
00504 }
else if (!strcasecmp(language,
"es") || !strcasecmp(language,
"mx")) {
00505
return(ast_say_number_full_es(chan, num, ints, language, options, audiofd, ctrlfd));
00506 }
else if (!strcasecmp(language,
"fr") ) {
00507
return(ast_say_number_full_fr(chan, num, ints, language, options, audiofd, ctrlfd));
00508 }
else if (!strcasecmp(language,
"it") ) {
00509
return(ast_say_number_full_it(chan, num, ints, language, audiofd, ctrlfd));
00510 }
else if (!strcasecmp(language,
"nl") ) {
00511
return(ast_say_number_full_nl(chan, num, ints, language, audiofd, ctrlfd));
00512 }
else if (!strcasecmp(language,
"pl") ) {
00513
return(ast_say_number_full_pl(chan, num, ints, language, options, audiofd, ctrlfd));
00514 }
else if (!strcasecmp(language,
"pt") ) {
00515
return(ast_say_number_full_pt(chan, num, ints, language, options, audiofd, ctrlfd));
00516 }
else if (!strcasecmp(language,
"se") ) {
00517
return(ast_say_number_full_se(chan, num, ints, language, options, audiofd, ctrlfd));
00518 }
else if (!strcasecmp(language,
"tw")) {
00519
return(ast_say_number_full_tw(chan, num, ints, language, audiofd, ctrlfd));
00520 }
else if (!strcasecmp(language,
"cz") ) {
00521
return(ast_say_number_full_cz(chan, num, ints, language, options, audiofd, ctrlfd));
00522 }
00523
00524
00525
return(ast_say_number_full_en(chan, num, ints, language, audiofd, ctrlfd));
00526 }
00527
00528
00529 int ast_say_number(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options)
00530 {
00531
return(
ast_say_number_full(chan, num, ints, language, options, -1, -1));
00532 }
00533
00534
00535
00536
static int ast_say_number_full_en(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd)
00537 {
00538
int res = 0;
00539
int playh = 0;
00540
char fn[256] =
"";
00541
if (!num)
00542
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00543
00544
while(!res && (num || playh)) {
00545
if (playh) {
00546 snprintf(fn,
sizeof(fn),
"digits/hundred");
00547 playh = 0;
00548 }
else if (num < 20) {
00549 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00550 num = 0;
00551 }
else if (num < 100) {
00552 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
00553 num -= ((num / 10) * 10);
00554 }
else {
00555
if (num < 1000){
00556 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
00557 playh++;
00558 num -= ((num / 100) * 100);
00559 }
else {
00560
if (num < 1000000) {
00561 res = ast_say_number_full_en(chan, num / 1000, ints, language, audiofd, ctrlfd);
00562
if (res)
00563
return res;
00564 num = num % 1000;
00565 snprintf(fn,
sizeof(fn),
"digits/thousand");
00566 }
else {
00567
if (num < 1000000000) {
00568 res = ast_say_number_full_en(chan, num / 1000000, ints, language, audiofd, ctrlfd);
00569
if (res)
00570
return res;
00571 num = num % 1000000;
00572 snprintf(fn,
sizeof(fn),
"digits/million");
00573 }
else {
00574
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
00575 res = -1;
00576 }
00577 }
00578 }
00579 }
00580
if (!res) {
00581
if(!
ast_streamfile(chan, fn, language)) {
00582
if (audiofd && ctrlfd)
00583 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00584
else
00585 res =
ast_waitstream(chan, ints);
00586 }
00587
ast_stopstream(chan);
00588
00589 }
00590
00591 }
00592
return res;
00593 }
00594
00595
00596
00597
00598
00599
static int ast_say_number_full_da(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
00600 {
00601
int res = 0;
00602
int playh = 0;
00603
int playa = 0;
00604
int cn = 1;
00605
char fn[256] =
"";
00606
if (!num)
00607
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00608
00609
if (options && !strncasecmp(options,
"n",1)) cn = -1;
00610
00611
while(!res && (num || playh || playa )) {
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
if (playh) {
00623 snprintf(fn,
sizeof(fn),
"digits/hundred");
00624 playh = 0;
00625 }
else if (playa) {
00626 snprintf(fn,
sizeof(fn),
"digits/and");
00627 playa = 0;
00628 }
else if (num == 1 && cn == -1) {
00629 snprintf(fn,
sizeof(fn),
"digits/1N");
00630 num = 0;
00631 }
else if (num < 20) {
00632 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00633 num = 0;
00634 }
else if (num < 100) {
00635
int ones = num % 10;
00636
if (ones) {
00637 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
00638 num -= ones;
00639 }
else {
00640 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00641 num = 0;
00642 }
00643 }
else {
00644
if (num < 1000) {
00645
int hundreds = num / 100;
00646
if (hundreds == 1)
00647 snprintf(fn,
sizeof(fn),
"digits/1N");
00648
else
00649 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
00650
00651 playh++;
00652 num -= 100 * hundreds;
00653
if (num)
00654 playa++;
00655
00656 }
else {
00657
if (num < 1000000) {
00658 res = ast_say_number_full_da(chan, num / 1000, ints, language,
"n", audiofd, ctrlfd);
00659
if (res)
00660
return res;
00661 num = num % 1000;
00662 snprintf(fn,
sizeof(fn),
"digits/thousand");
00663 }
else {
00664
if (num < 1000000000) {
00665
int millions = num / 1000000;
00666 res = ast_say_number_full_da(chan, millions, ints, language,
"c", audiofd, ctrlfd);
00667
if (res)
00668
return res;
00669
if (millions == 1)
00670 snprintf(fn,
sizeof(fn),
"digits/million");
00671
else
00672 snprintf(fn,
sizeof(fn),
"digits/millions");
00673 num = num % 1000000;
00674 }
else {
00675
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
00676 res = -1;
00677 }
00678 }
00679
if (num && num < 100)
00680 playa++;
00681 }
00682 }
00683
if (!res) {
00684
if(!
ast_streamfile(chan, fn, language)) {
00685
if (audiofd && ctrlfd)
00686 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00687
else
00688 res =
ast_waitstream(chan, ints);
00689 }
00690
ast_stopstream(chan);
00691 }
00692 }
00693
return res;
00694 }
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
static int ast_say_number_full_de(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
00706 {
00707
int res = 0;
00708
int playh = 0;
00709
int t = 0;
00710
int mf = 1;
00711
char fn[256] =
"";
00712
char fna[256] =
"";
00713
if (!num)
00714
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00715
00716
if (options && (!strncasecmp(options,
"f",1)))
00717 mf = -1;
00718
00719
while(!res && (num || playh)) {
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
if (playh) {
00731 snprintf(fn,
sizeof(fn),
"digits/hundred");
00732 playh = 0;
00733 }
else if (num == 1 && mf == -1) {
00734 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
00735 num = 0;
00736 }
else if (num < 20) {
00737 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00738 num = 0;
00739 }
else if (num < 100) {
00740
int ones = num % 10;
00741
if (ones) {
00742 snprintf(fn,
sizeof(fn),
"digits/%d-and", ones);
00743 num -= ones;
00744 }
else {
00745 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00746 num = 0;
00747 }
00748 }
else if (num == 100) {
00749 snprintf(fn,
sizeof(fn),
"digits/hundred");
00750 num = num - 100;
00751 }
else if (num < 1000) {
00752
int hundreds = num / 100;
00753
if (hundreds == 1)
00754 snprintf(fn,
sizeof(fn),
"digits/1N");
00755
else
00756 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100));
00757 playh++;
00758 num -= 100 * hundreds;
00759 }
else if (num == 1000 && t == 0) {
00760 snprintf(fn,
sizeof(fn),
"digits/thousand");
00761 num = 0;
00762 }
else if (num < 1000000) {
00763
int thousands = num / 1000;
00764 t = 1;
00765
if (thousands == 1) {
00766 snprintf(fn,
sizeof(fn),
"digits/1N");
00767 snprintf(fna,
sizeof(fna),
"digits/thousand");
00768 }
else {
00769 res = ast_say_number_full_de(chan, thousands, ints, language, options, audiofd, ctrlfd);
00770
if (res)
00771
return res;
00772 snprintf(fn,
sizeof(fn),
"digits/thousand");
00773 }
00774 num = num % 1000;
00775 }
else if (num < 1000000000) {
00776
int millions = num / 1000000;
00777 t = 1;
00778
if (millions == 1) {
00779 snprintf(fn,
sizeof(fn),
"digits/1N");
00780 snprintf(fna,
sizeof(fna),
"digits/million");
00781 }
else {
00782 res = ast_say_number_full_de(chan, millions, ints, language, options, audiofd, ctrlfd);
00783
if (res)
00784
return res;
00785 snprintf(fn,
sizeof(fn),
"digits/millions");
00786 }
00787 num = num % 1000000;
00788 }
else {
00789
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
00790 res = -1;
00791 }
00792
if (!res) {
00793
if(!
ast_streamfile(chan, fn, language)) {
00794
if (audiofd && ctrlfd)
00795 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00796
else
00797 res =
ast_waitstream(chan, ints);
00798 }
00799
ast_stopstream(chan);
00800
if(!
ast_streamfile(chan, fna, language)) {
00801
if (audiofd && ctrlfd)
00802 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00803
else
00804 res =
ast_waitstream(chan, ints);
00805 }
00806
ast_stopstream(chan);
00807 strcpy(fna,
"");
00808 }
00809 }
00810
return res;
00811 }
00812
00813
00814
00815
00816
00817
00818
00819
static int ast_say_number_full_es(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
00820 {
00821
int res = 0;
00822
int playa = 0;
00823
int mf = 1;
00824
char fn[256] =
"";
00825
if (!num)
00826
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00827
00828
if (options && !strncasecmp(options,
"f",1))
00829 mf = -1;
00830
00831
while (!res && num) {
00832
if (playa) {
00833 snprintf(fn,
sizeof(fn),
"digits/y");
00834 playa = 0;
00835 }
else if (num == 1) {
00836
if (mf < 0)
00837 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
00838
else
00839 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00840 num = 0;
00841 }
else if (num < 31) {
00842 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00843 num = 0;
00844 }
else if (num < 100) {
00845 snprintf(fn,
sizeof(fn),
"digits/%d", (num/10)*10);
00846 num -= ((num/10)*10);
00847
if (num)
00848 playa++;
00849 }
else if (num == 100) {
00850 snprintf(fn,
sizeof(fn),
"digits/cien");
00851 num = 0;
00852 }
else {
00853
if (num < 1000) {
00854 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100)*100);
00855 num -= ((num/100)*100);
00856 }
else {
00857
if (num < 1000000) {
00858 res = ast_say_number_full_es(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
00859
if (res)
00860
return res;
00861 num = num % 1000;
00862 snprintf(fn,
sizeof(fn),
"digits/mil");
00863 }
else {
00864
if (num < 2147483640) {
00865 res = ast_say_number_full_es(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
00866
if (res)
00867
return res;
00868
if ((num/1000000) == 1) {
00869 snprintf(fn,
sizeof(fn),
"digits/millon");
00870 }
else {
00871 snprintf(fn,
sizeof(fn),
"digits/millones");
00872 }
00873 num = num % 1000000;
00874 }
else {
00875
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
00876 res = -1;
00877 }
00878 }
00879 }
00880 }
00881
00882
if (!res) {
00883
if(!
ast_streamfile(chan, fn, language)) {
00884
if (audiofd && ctrlfd)
00885 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00886
else
00887 res =
ast_waitstream(chan, ints);
00888 }
00889
ast_stopstream(chan);
00890
00891 }
00892
00893 }
00894
return res;
00895 }
00896
00897
00898
00899
00900
00901
00902
static int ast_say_number_full_fr(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
00903 {
00904
int res = 0;
00905
int playh = 0;
00906
int playa = 0;
00907
int mf = 1;
00908
char fn[256] =
"";
00909
if (!num)
00910
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00911
00912
if (options && !strncasecmp(options,
"f",1))
00913 mf = -1;
00914
00915
while(!res && (num || playh || playa)) {
00916
if (playh) {
00917 snprintf(fn,
sizeof(fn),
"digits/hundred");
00918 playh = 0;
00919 }
else if (playa) {
00920 snprintf(fn,
sizeof(fn),
"digits/et");
00921 playa = 0;
00922 }
else if (num == 1) {
00923
if (mf < 0)
00924 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
00925
else
00926 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00927 num = 0;
00928 }
else if (num < 21) {
00929 snprintf(fn,
sizeof(fn),
"digits/%d", num);
00930 num = 0;
00931 }
else if (num < 70) {
00932 snprintf(fn,
sizeof(fn),
"digits/%d", (num/10)*10);
00933
if ((num % 10) == 1) playa++;
00934 num = num % 10;
00935 }
else if (num < 80) {
00936 snprintf(fn,
sizeof(fn),
"digits/60");
00937
if ((num % 10) == 1) playa++;
00938 num = num - 60;
00939 }
else if (num < 100) {
00940 snprintf(fn,
sizeof(fn),
"digits/80");
00941 num = num - 80;
00942 }
else if (num < 200) {
00943 snprintf(fn,
sizeof(fn),
"digits/hundred");
00944 num = num - 100;
00945 }
else if (num < 1000) {
00946 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
00947 playh++;
00948 num = num % 100;
00949 }
else if (num < 2000) {
00950 snprintf(fn,
sizeof(fn),
"digits/thousand");
00951 num = num - 1000;
00952 }
else if (num < 1000000) {
00953 res = ast_say_number_full_fr(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
00954
if (res)
00955
return res;
00956 snprintf(fn,
sizeof(fn),
"digits/thousand");
00957 num = num % 1000;
00958 }
else if (num < 1000000000) {
00959 res = ast_say_number_full_fr(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
00960
if (res)
00961
return res;
00962 snprintf(fn,
sizeof(fn),
"digits/million");
00963 num = num % 1000000;
00964 }
else {
00965
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
00966 res = -1;
00967 }
00968
if (!res) {
00969
if(!
ast_streamfile(chan, fn, language)) {
00970
if (audiofd && ctrlfd)
00971 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00972
else
00973 res =
ast_waitstream(chan, ints);
00974 }
00975
ast_stopstream(chan);
00976 }
00977 }
00978
return res;
00979 }
00980
00981
00982
static int ast_say_number_full_it(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd)
00983 {
00984
int res = 0;
00985
int playh = 0;
00986
int tempnum = 0;
00987
char fn[256] =
"";
00988
00989
if (!num)
00990
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
while(!res && (num || playh)) {
01017
if (playh) {
01018 snprintf(fn,
sizeof(fn),
"digits/hundred");
01019 playh = 0;
01020 }
else if (num < 20) {
01021 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01022 num = 0;
01023 }
else if (num == 21) {
01024 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01025 num = 0;
01026 }
else if (num == 28) {
01027 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01028 num = 0;
01029 }
else if (num == 31) {
01030 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01031 num = 0;
01032 }
else if (num == 38) {
01033 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01034 num = 0;
01035 }
else if (num == 41) {
01036 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01037 num = 0;
01038 }
else if (num == 48) {
01039 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01040 num = 0;
01041 }
else if (num == 51) {
01042 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01043 num = 0;
01044 }
else if (num == 58) {
01045 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01046 num = 0;
01047 }
else if (num == 61) {
01048 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01049 num = 0;
01050 }
else if (num == 68) {
01051 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01052 num = 0;
01053 }
else if (num == 71) {
01054 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01055 num = 0;
01056 }
else if (num == 78) {
01057 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01058 num = 0;
01059 }
else if (num == 81) {
01060 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01061 num = 0;
01062 }
else if (num == 88) {
01063 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01064 num = 0;
01065 }
else if (num == 91) {
01066 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01067 num = 0;
01068 }
else if (num == 98) {
01069 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01070 num = 0;
01071 }
else if (num < 100) {
01072 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
01073 num -= ((num / 10) * 10);
01074 }
else {
01075
if (num < 1000) {
01076
if ((num / 100) > 1) {
01077 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
01078 playh++;
01079 }
else {
01080 snprintf(fn,
sizeof(fn),
"digits/hundred");
01081 }
01082 num -= ((num / 100) * 100);
01083 }
else {
01084
if (num < 1000000) {
01085
if ((num/1000) > 1)
01086 res = ast_say_number_full_it(chan, num / 1000, ints, language, audiofd, ctrlfd);
01087
if (res)
01088
return res;
01089 tempnum = num;
01090 num = num % 1000;
01091
if ((tempnum / 1000) < 2)
01092 snprintf(fn,
sizeof(fn),
"digits/thousand");
01093
else
01094 snprintf(fn,
sizeof(fn),
"digits/thousands");
01095 }
else {
01096
if (num < 1000000000) {
01097
if ((num / 1000000) > 1)
01098 res = ast_say_number_full_it(chan, num / 1000000, ints, language, audiofd, ctrlfd);
01099
if (res)
01100
return res;
01101 tempnum = num;
01102 num = num % 1000000;
01103
if ((tempnum / 1000000) < 2)
01104 snprintf(fn,
sizeof(fn),
"digits/million");
01105
else
01106 snprintf(fn,
sizeof(fn),
"digits/millions");
01107 }
else {
01108
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
01109 res = -1;
01110 }
01111 }
01112 }
01113 }
01114
if (!res) {
01115
if(!
ast_streamfile(chan, fn, language)) {
01116
if (audiofd && ctrlfd)
01117 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01118
else
01119 res =
ast_waitstream(chan, ints);
01120 }
01121
ast_stopstream(chan);
01122 }
01123 }
01124
return res;
01125 }
01126
01127
01128
01129
01130
static int ast_say_number_full_nl(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd)
01131 {
01132
int res = 0;
01133
int playh = 0;
01134
int units = 0;
01135
char fn[256] =
"";
01136
if (!num)
01137
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01138
while (!res && (num || playh )) {
01139
if (playh) {
01140 snprintf(fn,
sizeof(fn),
"digits/hundred");
01141 playh = 0;
01142 }
else if (num < 20) {
01143 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01144 num = 0;
01145 }
else if (num < 100) {
01146 units = num % 10;
01147
if (units > 0) {
01148 res = ast_say_number_full_nl(chan, units, ints, language, audiofd, ctrlfd);
01149
if (res)
01150
return res;
01151 num = num - units;
01152 snprintf(fn,
sizeof(fn),
"digits/nl-en");
01153 }
else {
01154 snprintf(fn,
sizeof(fn),
"digits/%d", num - units);
01155 num = 0;
01156 }
01157 }
else {
01158
if (num < 1000) {
01159 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
01160 playh++;
01161 num -= ((num / 100) * 100);
01162 }
else {
01163
if (num < 1000000) {
01164 res = ast_say_number_full_en(chan, num / 1000, ints, language, audiofd, ctrlfd);
01165
if (res)
01166
return res;
01167 num = num % 1000;
01168 snprintf(fn,
sizeof(fn),
"digits/thousand");
01169 }
else {
01170
if (num < 1000000000) {
01171 res = ast_say_number_full_en(chan, num / 1000000, ints, language, audiofd, ctrlfd);
01172
if (res)
01173
return res;
01174 num = num % 1000000;
01175 snprintf(fn,
sizeof(fn),
"digits/million");
01176 }
else {
01177
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
01178 res = -1;
01179 }
01180 }
01181 }
01182 }
01183
01184
if (!res) {
01185
if(!
ast_streamfile(chan, fn, language)) {
01186
if (audiofd && ctrlfd)
01187 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01188
else
01189 res =
ast_waitstream(chan, ints);
01190 }
01191
ast_stopstream(chan);
01192 }
01193 }
01194
return res;
01195 }
01196
01197
static int exp10_int(
int power)
01198 {
01199
int x, res= 1;
01200
for (x=0;x<power;x++)
01201 res *= 10;
01202
return res;
01203 }
01204
01205 typedef struct {
01206 char *separator_dziesiatek;
01207 char *cyfry[10];
01208 char *cyfry2[10];
01209 char *setki[10];
01210 char *dziesiatki[10];
01211 char *nastki[10];
01212 char *rzedy[3][3];
01213 }
odmiana;
01214
01215
static char *pl_rzad_na_tekst(
odmiana *odm,
int i,
int rzad)
01216 {
01217
if (rzad==0)
01218
return "";
01219
01220
if (i==1)
01221
return odm->
rzedy[rzad - 1][0];
01222
if ((i > 21 || i < 11) && i%10 > 1 && i%10 < 5)
01223
return odm->
rzedy[rzad - 1][1];
01224
else
01225
return odm->
rzedy[rzad - 1][2];
01226 }
01227
01228
static char* pl_append(
char* buffer,
char* str)
01229 {
01230 strcpy(buffer, str);
01231 buffer += strlen(str);
01232
return buffer;
01233 }
01234
01235
static void pl_odtworz_plik(
struct ast_channel *chan,
char *language,
int audiofd,
int ctrlfd,
char *ints,
char *fn)
01236 {
01237
char file_name[255] =
"digits/";
01238 strcat(file_name, fn);
01239
ast_log(LOG_DEBUG,
"Trying to play: %s\n", file_name);
01240
if (!
ast_streamfile(chan, file_name, language)) {
01241
if (audiofd && ctrlfd)
01242
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01243
else
01244
ast_waitstream(chan, ints);
01245 }
01246
ast_stopstream(chan);
01247 }
01248
01249
static void powiedz(
struct ast_channel *chan,
char *language,
int audiofd,
int ctrlfd,
char *ints,
odmiana *odm,
int rzad,
int i)
01250 {
01251
01252
int m1000E6 = 0;
01253
int i1000E6 = 0;
01254
int m1000E3 = 0;
01255
int i1000E3 = 0;
01256
int m1000 = 0;
01257
int i1000 = 0;
01258
int m100 = 0;
01259
int i100 = 0;
01260
01261
if (i == 0 && rzad > 0) {
01262
return;
01263 }
01264
if (i == 0) {
01265 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
cyfry[0]);
01266 }
01267
01268 m1000E6 = i % 1000000000;
01269 i1000E6 = i / 1000000000;
01270
01271 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+3, i1000E6);
01272
01273 m1000E3 = m1000E6 % 1000000;
01274 i1000E3 = m1000E6 / 1000000;
01275
01276 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+2, i1000E3);
01277
01278 m1000 = m1000E3 % 1000;
01279 i1000 = m1000E3 / 1000;
01280
01281 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+1, i1000);
01282
01283 m100 = m1000 % 100;
01284 i100 = m1000 / 100;
01285
01286
if (i100>0)
01287 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
setki[i100]);
01288
01289
if ( m100 > 0 && m100 <=9 ) {
01290
if (m1000>0)
01291 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
cyfry2[m100]);
01292
else
01293 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
cyfry[m100]);
01294 }
else if (m100 % 10 == 0) {
01295 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
dziesiatki[m100 / 10]);
01296 }
else if (m100 <= 19 ) {
01297 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
nastki[m100 % 10]);
01298 }
else if (m100 != 0) {
01299
if (odm->
separator_dziesiatek[0]==
' ') {
01300 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
dziesiatki[m100 / 10]);
01301 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->
cyfry2[m100 % 10]);
01302 }
else {
01303
char buf[10];
01304
char *b = buf;
01305 b = pl_append(b, odm->
dziesiatki[m100 / 10]);
01306 b = pl_append(b, odm->
separator_dziesiatek);
01307 b = pl_append(b, odm->
cyfry2[m100 % 10]);
01308 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, buf);
01309 }
01310 }
01311
01312
if (rzad > 0) {
01313 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, pl_rzad_na_tekst(odm, i, rzad));
01314 }
01315 }
01316
01317
01318
static int ast_say_number_full_pl(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410 {
01411
char *zenski_cyfry[] = {
"0",
"1z",
"2z",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
01412
01413
char *zenski_cyfry2[] = {
"0",
"1",
"2z",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
01414
01415
char *meski_cyfry[] = {
"0",
"1",
"2-1m",
"3-1m",
"4-1m",
"5m",
"6m",
"7m",
"8m",
"9m"};
01416
01417
char *meski_cyfry2[] = {
"0",
"1",
"2-2m",
"3-2m",
"4-2m",
"5m",
"6m",
"7m",
"8m",
"9m"};
01418
01419
char *meski_setki[] = {
"",
"100m",
"200m",
"300m",
"400m",
"500m",
"600m",
"700m",
"800m",
"900m"};
01420
01421
char *meski_dziesiatki[] = {
"",
"10m",
"20m",
"30m",
"40m",
"50m",
"60m",
"70m",
"80m",
"90m"};
01422
01423
char *meski_nastki[] = {
"",
"11m",
"12m",
"13m",
"14m",
"15m",
"16m",
"17m",
"18m",
"19m"};
01424
01425
char *nijaki_cyfry[] = {
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
01426
01427
char *nijaki_cyfry2[] = {
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"};
01428
01429
char *nijaki_setki[] = {
"",
"100",
"200",
"300",
"400",
"500",
"600",
"700",
"800",
"900"};
01430
01431
char *nijaki_dziesiatki[] = {
"",
"10",
"20",
"30",
"40",
"50",
"60",
"70",
"80",
"90"};
01432
01433
char *nijaki_nastki[] = {
"",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19"};
01434
01435
char *rzedy[][3] = { {
"1000",
"1000.2",
"1000.5"}, {
"1000000",
"1000000.2",
"1000000.5"}, {
"1000000000",
"1000000000.2",
"1000000000.5"}};
01436
01437
01438
odmiana *o;
01439
01440
static odmiana *odmiana_nieosobowa = NULL;
01441
static odmiana *odmiana_meska = NULL;
01442
static odmiana *odmiana_zenska = NULL;
01443
01444
if (odmiana_nieosobowa == NULL) {
01445 odmiana_nieosobowa = (
odmiana *)
malloc(
sizeof(
odmiana));
01446
01447 odmiana_nieosobowa->
separator_dziesiatek =
"_";
01448
01449 memcpy(odmiana_nieosobowa->
cyfry, nijaki_cyfry,
sizeof(odmiana_nieosobowa->
cyfry));
01450 memcpy(odmiana_nieosobowa->
cyfry2, nijaki_cyfry2,
sizeof(odmiana_nieosobowa->
cyfry));
01451 memcpy(odmiana_nieosobowa->
setki, nijaki_setki,
sizeof(odmiana_nieosobowa->
setki));
01452 memcpy(odmiana_nieosobowa->
dziesiatki, nijaki_dziesiatki,
sizeof(odmiana_nieosobowa->
dziesiatki));
01453 memcpy(odmiana_nieosobowa->
nastki, nijaki_nastki,
sizeof(odmiana_nieosobowa->
nastki));
01454 memcpy(odmiana_nieosobowa->
rzedy, rzedy,
sizeof(odmiana_nieosobowa->
rzedy));
01455 }
01456
01457
if (odmiana_zenska == NULL) {
01458 odmiana_zenska = (
odmiana *)
malloc(
sizeof(
odmiana));
01459
01460 odmiana_zenska->
separator_dziesiatek =
"_";
01461
01462 memcpy(odmiana_zenska->
cyfry, zenski_cyfry,
sizeof(odmiana_zenska->
cyfry));
01463 memcpy(odmiana_zenska->
cyfry2, zenski_cyfry2,
sizeof(odmiana_zenska->
cyfry));
01464 memcpy(odmiana_zenska->
setki, nijaki_setki,
sizeof(odmiana_zenska->
setki));
01465 memcpy(odmiana_zenska->
dziesiatki, nijaki_dziesiatki,
sizeof(odmiana_zenska->
dziesiatki));
01466 memcpy(odmiana_zenska->
nastki, nijaki_nastki,
sizeof(odmiana_zenska->
nastki));
01467 memcpy(odmiana_zenska->
rzedy, rzedy,
sizeof(odmiana_zenska->
rzedy));
01468 }
01469
01470
if (odmiana_meska == NULL) {
01471 odmiana_meska = (
odmiana *)
malloc(
sizeof(
odmiana));
01472
01473 odmiana_meska->
separator_dziesiatek =
"_";
01474
01475 memcpy(odmiana_meska->
cyfry, meski_cyfry,
sizeof(odmiana_meska->
cyfry));
01476 memcpy(odmiana_meska->
cyfry2, meski_cyfry2,
sizeof(odmiana_meska->
cyfry));
01477 memcpy(odmiana_meska->
setki, meski_setki,
sizeof(odmiana_meska->
setki));
01478 memcpy(odmiana_meska->
dziesiatki, meski_dziesiatki,
sizeof(odmiana_meska->
dziesiatki));
01479 memcpy(odmiana_meska->
nastki, meski_nastki,
sizeof(odmiana_meska->
nastki));
01480 memcpy(odmiana_meska->
rzedy, rzedy,
sizeof(odmiana_meska->
rzedy));
01481 }
01482
01483
if (options) {
01484
if (strncasecmp(options,
"f", 1) == 0)
01485 o = odmiana_zenska;
01486
else if (strncasecmp(options,
"m", 1) == 0)
01487 o = odmiana_meska;
01488
else
01489 o = odmiana_nieosobowa;
01490 }
else
01491 o = odmiana_nieosobowa;
01492
01493 powiedz(chan, language, audiofd, ctrlfd, ints, o, 0, num);
01494
return 0;
01495 }
01496
01497
01498
01499
01500
01501
01502
01503
static int ast_say_number_full_pt(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
01504 {
01505
int res = 0;
01506
int playh = 0;
01507
int mf = 1;
01508
char fn[256] =
"";
01509
01510
if (!num)
01511
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01512
01513
if (options && !strncasecmp(options,
"f",1))
01514 mf = -1;
01515
01516
while(!res && num ) {
01517
if (num < 20) {
01518
if ((num == 1 || num == 2) && (mf < 0))
01519 snprintf(fn,
sizeof(fn),
"digits/%dF", num);
01520
else
01521 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01522 num = 0;
01523 }
else if (num < 100) {
01524 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 10) * 10);
01525
if (num % 10)
01526 playh = 1;
01527 num = num % 10;
01528 }
else if (num < 1000) {
01529
if (num == 100)
01530 snprintf(fn,
sizeof(fn),
"digits/100");
01531
else if (num < 200)
01532 snprintf(fn,
sizeof(fn),
"digits/100E");
01533
else {
01534
if (mf < 0 && num > 199)
01535 snprintf(fn,
sizeof(fn),
"digits/%dF", (num / 100) * 100);
01536
else
01537 snprintf(fn,
sizeof(fn),
"digits/%d", (num / 100) * 100);
01538
if (num % 100)
01539 playh = 1;
01540 }
01541 num = num % 100;
01542 }
else if (num < 1000000) {
01543
if (num > 1999) {
01544 res = ast_say_number_full_pt(chan, (num / 1000) * mf, ints, language, options, audiofd, ctrlfd);
01545
if (res)
01546
return res;
01547 }
01548 snprintf(fn,
sizeof(fn),
"digits/1000");
01549
if ((num % 1000) && ((num % 1000) < 100 || !(num % 100)))
01550 playh = 1;
01551 num = num % 1000;
01552 }
else if (num < 1000000000) {
01553 res = ast_say_number_full_pt(chan, (num / 1000000), ints, language, options, audiofd, ctrlfd );
01554
if (res)
01555
return res;
01556
if (num < 2000000)
01557 snprintf(fn,
sizeof(fn),
"digits/1000000");
01558
else
01559 snprintf(fn,
sizeof(fn),
"digits/1000000S");
01560
01561
if ((num % 1000000) &&
01562
01563 ((!((num / 1000) % 1000) && ((num % 1000) < 100 || !(num % 100))) ||
01564
01565 (!(num % 1000) && (((num / 1000) % 1000) < 100 || !((num / 1000) % 100))) ) )
01566 playh = 1;
01567 num = num % 1000000;
01568 }
01569
if (!res && playh) {
01570 res = wait_file(chan, ints,
"digits/pt-e", language);
01571
ast_stopstream(chan);
01572 playh = 0;
01573 }
01574
if (!res) {
01575
if(!
ast_streamfile(chan, fn, language)) {
01576
if (audiofd && ctrlfd)
01577 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
else
01578 res =
ast_waitstream(chan, ints);
01579 }
01580
ast_stopstream(chan);
01581 }
01582 }
01583
return res;
01584 }
01585
01586
01587
static int ast_say_number_full_se(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
01588 {
01589
int res = 0;
01590
int playh = 0;
01591
char fn[256] =
"";
01592
int cn = 1;
01593
if (!num)
01594
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01595
if (options && !strncasecmp(options,
"n",1)) cn = -1;
01596
01597
while(!res && (num || playh)) {
01598
if (playh) {
01599 snprintf(fn,
sizeof(fn),
"digits/hundred");
01600 playh = 0;
01601 }
else
01602
if (num < 20) {
01603 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01604 num = 0;
01605 }
else
01606
if (num < 100) {
01607 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
01608 num -= ((num / 10) * 10);
01609 }
else
01610
if (num == 1 && cn == -1) {
01611 snprintf(fn,
sizeof(fn),
"digits/1N");
01612 num = 0;
01613 }
else {
01614
if (num < 1000){
01615 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
01616 playh++;
01617 num -= ((num / 100) * 100);
01618 }
else {
01619
if (num < 1000000) {
01620 res = ast_say_number_full_se(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
01621
if (res)
01622
return res;
01623 num = num % 1000;
01624 snprintf(fn,
sizeof(fn),
"digits/thousand");
01625 }
else {
01626
if (num < 1000000000) {
01627 res = ast_say_number_full_se(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
01628
if (res)
01629
return res;
01630 num = num % 1000000;
01631 snprintf(fn,
sizeof(fn),
"digits/million");
01632 }
else {
01633
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
01634 res = -1;
01635 }
01636 }
01637 }
01638 }
01639
if (!res) {
01640
if(!
ast_streamfile(chan, fn, language)) {
01641
if (audiofd && ctrlfd)
01642 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01643
else
01644 res =
ast_waitstream(chan, ints);
01645 }
01646
ast_stopstream(chan);
01647
01648 }
01649
01650 }
01651
return res;
01652 }
01653
01654
01655
01656
static int ast_say_number_full_tw(
struct ast_channel *chan,
int num,
char *ints,
char *language,
int audiofd,
int ctrlfd)
01657 {
01658
int res = 0;
01659
int playh = 0;
01660
char fn[256] =
"";
01661
if (!num)
01662
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01663
01664
while(!res && (num || playh)) {
01665
if (playh) {
01666 snprintf(fn,
sizeof(fn),
"digits/hundred");
01667 playh = 0;
01668 }
else if (num < 10) {
01669 snprintf(fn,
sizeof(fn),
"digits/%d", num);
01670 num = 0;
01671 }
else if (num < 100) {
01672 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
01673 num -= ((num / 10) * 10);
01674 }
else {
01675
if (num < 1000){
01676 snprintf(fn,
sizeof(fn),
"digits/%d", (num/100));
01677 playh++;
01678 num -= ((num / 100) * 100);
01679 }
else {
01680
if (num < 1000000) {
01681 res = ast_say_number_full_tw(chan, num / 1000, ints, language, audiofd, ctrlfd);
01682
if (res)
01683
return res;
01684 num = num % 1000;
01685 snprintf(fn,
sizeof(fn),
"digits/thousand");
01686 }
else {
01687
if (num < 1000000000) {
01688 res = ast_say_number_full_tw(chan, num / 1000000, ints, language, audiofd, ctrlfd);
01689
if (res)
01690
return res;
01691 num = num % 1000000;
01692 snprintf(fn,
sizeof(fn),
"digits/million");
01693 }
else {
01694
ast_log(LOG_DEBUG,
"Number '%d' is too big for me\n", num);
01695 res = -1;
01696 }
01697 }
01698 }
01699 }
01700
if (!res) {
01701
if(!
ast_streamfile(chan, fn, language)) {
01702
if (audiofd && ctrlfd)
01703 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01704
else
01705 res =
ast_waitstream(chan, ints);
01706 }
01707
ast_stopstream(chan);
01708
01709 }
01710 }
01711
return res;
01712 }
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731
01732
01733
01734
01735
01736
static int ast_say_number_full_cz(
struct ast_channel *chan,
int num,
char *ints,
char *language,
char *options,
int audiofd,
int ctrlfd)
01737 {
01738
int res = 0;
01739
int playh = 0;
01740
char fn[256] =
"";
01741
01742
int hundered = 0;
01743
int left = 0;
01744
int length = 0;
01745
01746
01747
if (!options)
01748 options =
"w";
01749
01750
if (!num)
01751
return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01752
01753
while(!res && (num || playh)) {
01754
if (num < 3 ) {
01755 snprintf(fn,
sizeof(fn),
"digits/%d%c",num,options[0]);
01756 playh = 0;
01757 num = 0;
01758 }
else if (num < 20) {
01759 snprintf(fn,
sizeof(fn),
"digits/%d",num);
01760 playh = 0;
01761 num = 0;
01762 }
else if (num < 100) {
01763 snprintf(fn,
sizeof(fn),
"digits/%d", (num /10) * 10);
01764 num -= ((num / 10) * 10);
01765 }
else if (num < 1000) {
01766 hundered = num / 100;
01767
if ( hundered == 1 ) {
01768 snprintf(fn,
sizeof(fn),
"digits/1sto");
01769 }
else if ( hundered == 2 ) {
01770 snprintf(fn,
sizeof(fn),
"digits/2ste");
01771 }
else {
01772 res = ast_say_number_full_cz(chan,hundered,ints,language,options,audiofd,ctrlfd);
01773
if (res)
01774
return res;
01775
if ( hundered == 3 || hundered == 4) {
01776 snprintf(fn,
sizeof(fn),
"digits/sta");
01777 }
else if ( hundered > 4 ) {
01778 snprintf(fn,
sizeof(fn),
"digits/set");
01779 }
01780 }
01781 num -= (hundered * 100);
01782 }
else {
01783 length = (
int)log10(num)+1;
01784
while ( (length % 3 ) != 1 ) {
01785 length--;
01786 }
01787 left = num / (exp10_int(length-1));
01788
if ( left == 2 ) {
01789
switch (length-1) {
01790
case 9: options =
"w";
01791
break;
01792
default : options =
"m";
01793 }
01794 }
01795
if ( left > 1 ) {
01796 res = ast_say_number_full_cz(chan,left,ints,language,options,audiofd,ctrlfd);
01797
if (res)
01798
return res;
01799 }
01800
if ( left >= 5 ) {
01801 snprintf(fn,
sizeof(fn),
"digits/5_E%d",length-1);
01802 }
else if ( left >= 2 && left <= 4 ) {
01803 snprintf(fn,
sizeof(fn),
"digits/2-4_E%d",length-1);
01804 }
else {
01805 snprintf(fn,
sizeof(fn),
"digits/1_E%d",length-1);
01806 }
01807 num -= left * (exp10_int(length-1));
01808 }
01809
if (!res) {
01810
if(!
ast_streamfile(chan, fn, language)) {
01811
if (audiofd && ctrlfd) {
01812 res =
ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01813 }
else {
01814 res =
ast_waitstream(chan, ints);
01815 }
01816 }
01817
ast_stopstream(chan);
01818 }
01819 }
01820
return res;
01821 }
01822
01823
01824 int ast_say_date(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
01825 {
01826
if (!strcasecmp(lang,
"en") ) {
01827
return(ast_say_date_en(chan, t, ints, lang));
01828 }
else if (!strcasecmp(lang,
"nl") ) {
01829
return(ast_say_date_nl(chan, t, ints, lang));
01830 }
else if (!strcasecmp(lang,
"pt") ) {
01831
return(ast_say_date_pt(chan, t, ints, lang));
01832 }
01833
01834
01835
return(ast_say_date_en(chan, t, ints, lang));
01836 }
01837
01838
01839
int ast_say_date_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
01840 {
01841
struct tm tm;
01842
char fn[256];
01843
int res = 0;
01844
ast_localtime(&t,&tm,NULL);
01845
if (!res) {
01846 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
01847 res =
ast_streamfile(chan, fn, lang);
01848
if (!res)
01849 res =
ast_waitstream(chan, ints);
01850 }
01851
if (!res) {
01852 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
01853 res =
ast_streamfile(chan, fn, lang);
01854
if (!res)
01855 res =
ast_waitstream(chan, ints);
01856 }
01857
if (!res)
01858 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char * ) NULL);
01859
if (!res)
01860 res =
ast_waitstream(chan, ints);
01861
if (!res)
01862 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
01863
return res;
01864 }
01865
01866
01867
int ast_say_date_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
01868 {
01869
struct tm tm;
01870
char fn[256];
01871
int res = 0;
01872
ast_localtime(&t,&tm,NULL);
01873
if (!res) {
01874 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
01875 res =
ast_streamfile(chan, fn, lang);
01876
if (!res)
01877 res =
ast_waitstream(chan, ints);
01878 }
01879
if (!res)
01880 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char * ) NULL);
01881
if (!res) {
01882 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
01883 res =
ast_streamfile(chan, fn, lang);
01884
if (!res)
01885 res =
ast_waitstream(chan, ints);
01886 }
01887
if (!res)
01888 res =
ast_waitstream(chan, ints);
01889
if (!res)
01890 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
01891
return res;
01892 }
01893
01894
01895
int ast_say_date_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
01896 {
01897
struct tm tm;
01898
char fn[256];
01899
int res = 0;
01900
ast_localtime(&t,&tm,NULL);
01901 localtime_r(&t,&tm);
01902 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
01903
if (!res)
01904 res = wait_file(chan, ints, fn, lang);
01905
if (!res)
01906 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
01907
if (!res)
01908 res = wait_file(chan, ints,
"digits/pt-de", lang);
01909 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
01910
if (!res)
01911 res = wait_file(chan, ints, fn, lang);
01912
if (!res)
01913 res = wait_file(chan, ints,
"digits/pt-de", lang);
01914
if (!res)
01915 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
01916
01917
return res;
01918 }
01919
01920 int ast_say_date_with_format(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
01921 {
01922
if (!strcasecmp(lang,
"en") ) {
01923
return(ast_say_date_with_format_en(chan, time, ints, lang, format, timezone));
01924 }
else if (!strcasecmp(lang,
"de") ) {
01925
return(ast_say_date_with_format_de(chan, time, ints, lang, format, timezone));
01926 }
else if (!strcasecmp(lang,
"es") || !strcasecmp(lang,
"mx")) {
01927
return(ast_say_date_with_format_es(chan, time, ints, lang, format, timezone));
01928 }
else if (!strcasecmp(lang,
"nl") ) {
01929
return(ast_say_date_with_format_nl(chan, time, ints, lang, format, timezone));
01930 }
else if (!strcasecmp(lang,
"pt") ) {
01931
return(ast_say_date_with_format_pt(chan, time, ints, lang, format, timezone));
01932 }
else if (!strcasecmp(lang,
"tw") ) {
01933
return(ast_say_date_with_format_tw(chan, time, ints, lang, format, timezone));
01934 }
01935
01936
01937
return(ast_say_date_with_format_en(chan, time, ints, lang, format, timezone));
01938 }
01939
01940
01941
int ast_say_date_with_format_en(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
01942 {
01943
struct tm tm;
01944
int res=0, offset, sndoffset;
01945
char sndfile[256], nextmsg[256];
01946
01947
ast_localtime(&time,&tm,timezone);
01948
01949
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
01950
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
01951
switch (format[offset]) {
01952
01953
case '\'':
01954
01955 sndoffset=0;
01956
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
01957 sndfile[sndoffset] = format[offset];
01958 sndfile[sndoffset] =
'\0';
01959 res = wait_file(chan,ints,sndfile,lang);
01960
break;
01961
case 'A':
01962
case 'a':
01963
01964 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
01965 res = wait_file(chan,ints,nextmsg,lang);
01966
break;
01967
case 'B':
01968
case 'b':
01969
case 'h':
01970
01971 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
01972 res = wait_file(chan,ints,nextmsg,lang);
01973
break;
01974
case 'd':
01975
case 'e':
01976
01977
if ((tm.tm_mday < 21) || (tm.tm_mday == 30)) {
01978 snprintf(nextmsg,
sizeof(nextmsg),
"digits/h-%d", tm.tm_mday);
01979 res = wait_file(chan,ints,nextmsg,lang);
01980 }
else if (tm.tm_mday == 31) {
01981
01982 res = wait_file(chan,ints,
"digits/30",lang);
01983
if (!res) {
01984 res = wait_file(chan,ints,
"digits/h-1",lang);
01985 }
01986 }
else {
01987
01988 res = wait_file(chan,ints,
"digits/20",lang);
01989
if (!res) {
01990 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_mday - 20);
01991 res = wait_file(chan,ints,nextmsg,lang);
01992 }
01993 }
01994
break;
01995
case 'Y':
01996
01997
if (tm.tm_year > 99) {
01998 res = wait_file(chan,ints,
"digits/2",lang);
01999
if (!res) {
02000 res = wait_file(chan,ints,
"digits/thousand",lang);
02001 }
02002
if (tm.tm_year > 100) {
02003
if (!res) {
02004
02005 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year - 100);
02006 res = wait_file(chan,ints,nextmsg,lang);
02007 }
02008 }
02009 }
else {
02010
if (tm.tm_year < 1) {
02011
02012
02013 }
else {
02014 res = wait_file(chan,ints,
"digits/19",lang);
02015
if (!res) {
02016
if (tm.tm_year <= 9) {
02017
02018 res = wait_file(chan,ints,
"digits/oh",lang);
02019
if (!res) {
02020 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02021 res = wait_file(chan,ints,nextmsg,lang);
02022 }
02023 }
else if (tm.tm_year <= 20) {
02024
02025 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02026 res = wait_file(chan,ints,nextmsg,lang);
02027 }
else {
02028
02029
int ten, one;
02030 ten = tm.tm_year / 10;
02031 one = tm.tm_year % 10;
02032 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten * 10);
02033 res = wait_file(chan,ints,nextmsg,lang);
02034
if (!res) {
02035
if (one != 0) {
02036 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02037 res = wait_file(chan,ints,nextmsg,lang);
02038 }
02039 }
02040 }
02041 }
02042 }
02043 }
02044
break;
02045
case 'I':
02046
case 'l':
02047
02048
if (tm.tm_hour == 0)
02049 snprintf(nextmsg,
sizeof(nextmsg),
"digits/12");
02050
else if (tm.tm_hour > 12)
02051 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - 12);
02052
else
02053 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
02054 res = wait_file(chan,ints,nextmsg,lang);
02055
break;
02056
case 'H':
02057
case 'k':
02058
02059
if (format[offset] ==
'H') {
02060
02061
if (tm.tm_hour < 10) {
02062 res = wait_file(chan,ints,
"digits/oh",lang);
02063 }
02064 }
else {
02065
02066
if (tm.tm_hour == 0) {
02067 res = wait_file(chan,ints,
"digits/oh",lang);
02068 }
02069 }
02070
if (!res) {
02071
if (tm.tm_hour != 0) {
02072
int remainder = tm.tm_hour;
02073
if (tm.tm_hour > 20) {
02074 res = wait_file(chan,ints,
"digits/20",lang);
02075 remainder -= 20;
02076 }
02077
if (!res) {
02078 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", remainder);
02079 res = wait_file(chan,ints,nextmsg,lang);
02080 }
02081 }
02082 }
02083
break;
02084
case 'M':
02085
02086
if (tm.tm_min == 0) {
02087 res = wait_file(chan,ints,
"digits/oclock",lang);
02088 }
else if (tm.tm_min < 10) {
02089 res = wait_file(chan,ints,
"digits/oh",lang);
02090
if (!res) {
02091 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min);
02092 res = wait_file(chan,ints,nextmsg,lang);
02093 }
02094 }
else if ((tm.tm_min < 21) || (tm.tm_min % 10 == 0)) {
02095 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min);
02096 res = wait_file(chan,ints,nextmsg,lang);
02097 }
else {
02098
int ten, one;
02099 ten = (tm.tm_min / 10) * 10;
02100 one = (tm.tm_min % 10);
02101 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02102 res = wait_file(chan,ints,nextmsg,lang);
02103
if (!res) {
02104
02105
if (one != 0) {
02106 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02107 res = wait_file(chan,ints,nextmsg,lang);
02108 }
02109 }
02110 }
02111
break;
02112
case 'P':
02113
case 'p':
02114
02115
if (tm.tm_hour > 11)
02116 snprintf(nextmsg,
sizeof(nextmsg),
"digits/p-m");
02117
else
02118 snprintf(nextmsg,
sizeof(nextmsg),
"digits/a-m");
02119 res = wait_file(chan,ints,nextmsg,lang);
02120
break;
02121
case 'Q':
02122
02123 {
02124
struct timeval now;
02125
struct tm tmnow;
02126 time_t beg_today;
02127
02128 gettimeofday(&now,NULL);
02129
ast_localtime(&now.tv_sec,&tmnow,timezone);
02130
02131
02132 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02133
if (beg_today < time) {
02134
02135 res = wait_file(chan,ints,
"digits/today",lang);
02136 }
else if (beg_today - 86400 < time) {
02137
02138 res = wait_file(chan,ints,
"digits/yesterday",lang);
02139 }
else {
02140 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02141 }
02142 }
02143
break;
02144
case 'q':
02145
02146 {
02147
struct timeval now;
02148
struct tm tmnow;
02149 time_t beg_today;
02150
02151 gettimeofday(&now,NULL);
02152
ast_localtime(&now.tv_sec,&tmnow,timezone);
02153
02154
02155 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02156
if (beg_today < time) {
02157
02158 }
else if ((beg_today - 86400) < time) {
02159
02160 res = wait_file(chan,ints,
"digits/yesterday",lang);
02161 }
else if (beg_today - 86400 * 6 < time) {
02162
02163 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
02164 }
else {
02165 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02166 }
02167 }
02168
break;
02169
case 'R':
02170 res =
ast_say_date_with_format(chan, time, ints, lang,
"HM", timezone);
02171
break;
02172
case 'S':
02173
02174
if (tm.tm_sec == 0) {
02175 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02176 res = wait_file(chan,ints,nextmsg,lang);
02177 }
else if (tm.tm_sec < 10) {
02178 res = wait_file(chan,ints,
"digits/oh",lang);
02179
if (!res) {
02180 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02181 res = wait_file(chan,ints,nextmsg,lang);
02182 }
02183 }
else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
02184 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02185 res = wait_file(chan,ints,nextmsg,lang);
02186 }
else {
02187
int ten, one;
02188 ten = (tm.tm_sec / 10) * 10;
02189 one = (tm.tm_sec % 10);
02190 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02191 res = wait_file(chan,ints,nextmsg,lang);
02192
if (!res) {
02193
02194
if (one != 0) {
02195 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02196 res = wait_file(chan,ints,nextmsg,lang);
02197 }
02198 }
02199 }
02200
break;
02201
case 'T':
02202 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
02203
break;
02204
case ' ':
02205
case ' ':
02206
02207
break;
02208
default:
02209
02210
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
02211 }
02212
02213
if (res) {
02214
break;
02215 }
02216 }
02217
return res;
02218 }
02219
02220
02221
02222
int ast_say_date_with_format_de(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
02223 {
02224
struct tm tm;
02225
int res=0, offset, sndoffset;
02226
char sndfile[256], nextmsg[256];
02227
02228
ast_localtime(&time,&tm,timezone);
02229
02230
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
02231
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
02232
switch (format[offset]) {
02233
02234
case '\'':
02235
02236 sndoffset=0;
02237
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
02238 sndfile[sndoffset] = format[offset];
02239 sndfile[sndoffset] =
'\0';
02240 res = wait_file(chan,ints,sndfile,lang);
02241
break;
02242
case 'A':
02243
case 'a':
02244
02245 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
02246 res = wait_file(chan,ints,nextmsg,lang);
02247
break;
02248
case 'B':
02249
case 'b':
02250
case 'h':
02251
02252 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
02253 res = wait_file(chan,ints,nextmsg,lang);
02254
break;
02255
case 'd':
02256
case 'e':
02257
02258
if ((tm.tm_mday < 21) || (tm.tm_mday == 30)) {
02259 snprintf(nextmsg,
sizeof(nextmsg),
"digits/h-%d", tm.tm_mday);
02260 res = wait_file(chan,ints,nextmsg,lang);
02261 }
else if (tm.tm_mday == 31) {
02262
02263 res = wait_file(chan,ints,
"digits/30",lang);
02264
if (!res) {
02265 res = wait_file(chan,ints,
"digits/h-1",lang);
02266 }
02267 }
else {
02268
02269 res = wait_file(chan,ints,
"digits/20",lang);
02270
if (!res) {
02271 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_mday - 20);
02272 res = wait_file(chan,ints,nextmsg,lang);
02273 }
02274 }
02275
break;
02276
case 'Y':
02277
02278
if (tm.tm_year > 99) {
02279 res = wait_file(chan,ints,
"digits/2",lang);
02280
if (!res) {
02281 res = wait_file(chan,ints,
"digits/thousand",lang);
02282 }
02283
if (tm.tm_year > 100) {
02284
if (!res) {
02285
02286 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year - 100);
02287 res = wait_file(chan,ints,nextmsg,lang);
02288 }
02289 }
02290 }
else {
02291
if (tm.tm_year < 1) {
02292
02293
02294 }
else {
02295 res = wait_file(chan,ints,
"digits/19",lang);
02296
if (!res) {
02297
if (tm.tm_year <= 9) {
02298
02299 res = wait_file(chan,ints,
"digits/oh",lang);
02300
if (!res) {
02301 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02302 res = wait_file(chan,ints,nextmsg,lang);
02303 }
02304 }
else if (tm.tm_year <= 20) {
02305
02306 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02307 res = wait_file(chan,ints,nextmsg,lang);
02308 }
else {
02309
02310
int ten, one;
02311 ten = tm.tm_year / 10;
02312 one = tm.tm_year % 10;
02313 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten * 10);
02314 res = wait_file(chan,ints,nextmsg,lang);
02315
if (!res) {
02316
if (one != 0) {
02317 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02318 res = wait_file(chan,ints,nextmsg,lang);
02319 }
02320 }
02321 }
02322 }
02323 }
02324 }
02325
break;
02326
case 'I':
02327
case 'l':
02328
02329
if (tm.tm_hour == 0)
02330 snprintf(nextmsg,
sizeof(nextmsg),
"digits/12");
02331
else if (tm.tm_hour > 12)
02332 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - 12);
02333
else
02334 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
02335 res = wait_file(chan,ints,nextmsg,lang);
02336
break;
02337
case 'H':
02338
case 'k':
02339
02340
if (format[offset] ==
'H') {
02341
02342
if (tm.tm_hour < 10) {
02343 res = wait_file(chan,ints,
"digits/oh",lang);
02344 }
02345 }
else {
02346
02347
if (tm.tm_hour == 0) {
02348 res = wait_file(chan,ints,
"digits/oh",lang);
02349 }
02350 }
02351
if (!res) {
02352
if (tm.tm_hour != 0) {
02353
int remainder = tm.tm_hour;
02354
if (tm.tm_hour > 20) {
02355 res = wait_file(chan,ints,
"digits/20",lang);
02356 remainder -= 20;
02357 }
02358
if (!res) {
02359 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", remainder);
02360 res = wait_file(chan,ints,nextmsg,lang);
02361 }
02362 }
02363 }
02364
break;
02365
case 'M':
02366
02367
if (tm.tm_min == 0) {
02368 res = wait_file(chan,ints,
"digits/oclock",lang);
02369 }
else if (tm.tm_min < 10) {
02370 res = wait_file(chan,ints,
"digits/oh",lang);
02371
if (!res) {
02372 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min);
02373 res = wait_file(chan,ints,nextmsg,lang);
02374 }
02375 }
else if ((tm.tm_min < 21) || (tm.tm_min % 10 == 0)) {
02376 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min);
02377 res = wait_file(chan,ints,nextmsg,lang);
02378 }
else {
02379
int ten, one;
02380 ten = (tm.tm_min / 10) * 10;
02381 one = (tm.tm_min % 10);
02382 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02383 res = wait_file(chan,ints,nextmsg,lang);
02384
if (!res) {
02385
02386
if (one != 0) {
02387 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02388 res = wait_file(chan,ints,nextmsg,lang);
02389 }
02390 }
02391 }
02392
break;
02393
case 'P':
02394
case 'p':
02395
02396
if (tm.tm_hour > 11)
02397 snprintf(nextmsg,
sizeof(nextmsg),
"digits/p-m");
02398
else
02399 snprintf(nextmsg,
sizeof(nextmsg),
"digits/a-m");
02400 res = wait_file(chan,ints,nextmsg,lang);
02401
break;
02402
case 'Q':
02403
02404 {
02405
struct timeval now;
02406
struct tm tmnow;
02407 time_t beg_today;
02408
02409 gettimeofday(&now,NULL);
02410
ast_localtime(&now.tv_sec,&tmnow,timezone);
02411
02412
02413 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02414
if (beg_today < time) {
02415
02416 res = wait_file(chan,ints,
"digits/today",lang);
02417 }
else if (beg_today - 86400 < time) {
02418
02419 res = wait_file(chan,ints,
"digits/yesterday",lang);
02420 }
else {
02421 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02422 }
02423 }
02424
break;
02425
case 'q':
02426
02427 {
02428
struct timeval now;
02429
struct tm tmnow;
02430 time_t beg_today;
02431
02432 gettimeofday(&now,NULL);
02433
ast_localtime(&now.tv_sec,&tmnow,timezone);
02434
02435
02436 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02437
if (beg_today < time) {
02438
02439 }
else if ((beg_today - 86400) < time) {
02440
02441 res = wait_file(chan,ints,
"digits/yesterday",lang);
02442 }
else if (beg_today - 86400 * 6 < time) {
02443
02444 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
02445 }
else {
02446 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02447 }
02448 }
02449
break;
02450
case 'R':
02451 res =
ast_say_date_with_format(chan, time, ints, lang,
"HM", timezone);
02452
break;
02453
case 'S':
02454
02455
if (tm.tm_sec == 0) {
02456 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02457 res = wait_file(chan,ints,nextmsg,lang);
02458 }
else if (tm.tm_sec < 10) {
02459 res = wait_file(chan,ints,
"digits/oh",lang);
02460
if (!res) {
02461 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02462 res = wait_file(chan,ints,nextmsg,lang);
02463 }
02464 }
else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
02465 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02466 res = wait_file(chan,ints,nextmsg,lang);
02467 }
else {
02468
int ten, one;
02469 ten = (tm.tm_sec / 10) * 10;
02470 one = (tm.tm_sec % 10);
02471 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02472 res = wait_file(chan,ints,nextmsg,lang);
02473
if (!res) {
02474
02475
if (one != 0) {
02476 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02477 res = wait_file(chan,ints,nextmsg,lang);
02478 }
02479 }
02480 }
02481
break;
02482
case 'T':
02483 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
02484
break;
02485
case ' ':
02486
case ' ':
02487
02488
break;
02489
default:
02490
02491
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
02492 }
02493
02494
if (res) {
02495
break;
02496 }
02497 }
02498
return res;
02499 }
02500
02501
02502
int ast_say_date_with_format_es(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
02503 {
02504
struct tm tm;
02505
int res=0, offset, sndoffset;
02506
char sndfile[256], nextmsg[256];
02507
02508
ast_localtime(&time,&tm,timezone);
02509
02510
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
02511
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
02512
switch (format[offset]) {
02513
02514
case '\'':
02515
02516 sndoffset=0;
02517
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
02518 sndfile[sndoffset] = format[offset];
02519 sndfile[sndoffset] =
'\0';
02520 snprintf(nextmsg,
sizeof(nextmsg),
"%s", sndfile);
02521 res = wait_file(chan,ints,nextmsg,lang);
02522
break;
02523
case 'A':
02524
case 'a':
02525
02526 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
02527 res = wait_file(chan,ints,nextmsg,lang);
02528
break;
02529
case 'B':
02530
case 'b':
02531
case 'h':
02532
02533 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
02534 res = wait_file(chan,ints,nextmsg,lang);
02535
break;
02536
case 'd':
02537
case 'e':
02538
02539 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
02540
break;
02541
case 'Y':
02542
02543 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
02544
break;
02545
case 'I':
02546
case 'l':
02547
02548
if (tm.tm_hour == 0)
02549 snprintf(nextmsg,
sizeof(nextmsg),
"digits/12");
02550
else if (tm.tm_hour > 12)
02551 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - 12);
02552
else
02553 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
02554 res = wait_file(chan,ints,nextmsg,lang);
02555
break;
02556
case 'H':
02557
case 'k':
02558
02559 res =
ast_say_number(chan, -tm.tm_hour, ints, lang, NULL);
02560
if (!res) {
02561
if (tm.tm_hour != 0) {
02562
int remainder = tm.tm_hour;
02563
if (tm.tm_hour > 20) {
02564 res = wait_file(chan,ints,
"digits/20",lang);
02565 remainder -= 20;
02566 }
02567
if (!res) {
02568 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", remainder);
02569 res = wait_file(chan,ints,nextmsg,lang);
02570 }
02571 }
02572 }
02573
break;
02574
case 'M':
02575
02576 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
02577
break;
02578
case 'P':
02579
case 'p':
02580
02581
if (tm.tm_hour > 12)
02582 res = wait_file(chan, ints,
"digits/p-m", lang);
02583
else if (tm.tm_hour && tm.tm_hour < 12)
02584 res = wait_file(chan, ints,
"digits/a-m", lang);
02585
break;
02586
case 'Q':
02587
02588 {
02589
struct timeval now;
02590
struct tm tmnow;
02591 time_t beg_today;
02592
02593 gettimeofday(&now,NULL);
02594
ast_localtime(&now.tv_sec,&tmnow,timezone);
02595
02596
02597 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02598
if (beg_today < time) {
02599
02600 res = wait_file(chan,ints,
"digits/today",lang);
02601 }
else if (beg_today - 86400 < time) {
02602
02603 res = wait_file(chan,ints,
"digits/yesterday",lang);
02604 }
else {
02605 res =
ast_say_date_with_format(chan, time, ints, lang,
"'digits/es-el' Ad 'digits/es-de' B 'digits/es-de' Y", timezone);
02606 }
02607 }
02608
break;
02609
case 'q':
02610
02611 {
02612
struct timeval now;
02613
struct tm tmnow;
02614 time_t beg_today;
02615
02616 gettimeofday(&now,NULL);
02617
ast_localtime(&now.tv_sec,&tmnow,timezone);
02618
02619
02620 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02621
if (beg_today < time) {
02622
02623 res = wait_file(chan,ints,
"digits/today",lang);
02624 }
else if ((beg_today - 86400) < time) {
02625
02626 res = wait_file(chan,ints,
"digits/yesterday",lang);
02627 }
else if (beg_today - 86400 * 6 < time) {
02628
02629 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
02630 }
else {
02631 res =
ast_say_date_with_format(chan, time, ints, lang,
"'digits/es-el' Ad 'digits/es-de' B 'digits/es-de' Y", timezone);
02632 }
02633 }
02634
break;
02635
case 'R':
02636 res =
ast_say_date_with_format(chan, time, ints, lang,
"H 'digits/y' M", timezone);
02637
break;
02638
case 'S':
02639
02640
if (tm.tm_sec == 0) {
02641 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02642 res = wait_file(chan,ints,nextmsg,lang);
02643 }
else if (tm.tm_sec < 10) {
02644 res = wait_file(chan,ints,
"digits/oh",lang);
02645
if (!res) {
02646 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02647 res = wait_file(chan,ints,nextmsg,lang);
02648 }
02649 }
else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
02650 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02651 res = wait_file(chan,ints,nextmsg,lang);
02652 }
else {
02653
int ten, one;
02654 ten = (tm.tm_sec / 10) * 10;
02655 one = (tm.tm_sec % 10);
02656 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02657 res = wait_file(chan,ints,nextmsg,lang);
02658
if (!res) {
02659
02660
if (one != 0) {
02661 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02662 res = wait_file(chan,ints,nextmsg,lang);
02663 }
02664 }
02665 }
02666
break;
02667
case 'T':
02668 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
02669
break;
02670
case ' ':
02671
case ' ':
02672
02673
break;
02674
default:
02675
02676
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
02677 }
02678
02679
if (res) {
02680
break;
02681 }
02682 }
02683
return res;
02684 }
02685
02686
02687
int ast_say_date_with_format_nl(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
02688 {
02689
struct tm tm;
02690
int res=0, offset, sndoffset;
02691
char sndfile[256], nextmsg[256];
02692
02693
ast_localtime(&time,&tm,timezone);
02694
02695
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
02696
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
02697
switch (format[offset]) {
02698
02699
case '\'':
02700
02701 sndoffset=0;
02702
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
02703 sndfile[sndoffset] = format[offset];
02704 sndfile[sndoffset] =
'\0';
02705 res = wait_file(chan,ints,sndfile,lang);
02706
break;
02707
case 'A':
02708
case 'a':
02709
02710 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
02711 res = wait_file(chan,ints,nextmsg,lang);
02712
break;
02713
case 'B':
02714
case 'b':
02715
case 'h':
02716
02717 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
02718 res = wait_file(chan,ints,nextmsg,lang);
02719
break;
02720
case 'd':
02721
case 'e':
02722
02723 res =
ast_say_number(chan, tm.tm_mday, ints, lang, NULL);
02724
break;
02725
case 'Y':
02726
02727
if (tm.tm_year > 99) {
02728 res = wait_file(chan,ints,
"digits/2",lang);
02729
if (!res) {
02730 res = wait_file(chan,ints,
"digits/thousand",lang);
02731 }
02732
if (tm.tm_year > 100) {
02733
if (!res) {
02734
02735 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year - 100);
02736 res = wait_file(chan,ints,nextmsg,lang);
02737 }
02738 }
02739 }
else {
02740
if (tm.tm_year < 1) {
02741
02742
02743 }
else {
02744 res = wait_file(chan,ints,
"digits/19",lang);
02745
if (!res) {
02746
if (tm.tm_year <= 9) {
02747
02748 res = wait_file(chan,ints,
"digits/oh",lang);
02749
if (!res) {
02750 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02751 res = wait_file(chan,ints,nextmsg,lang);
02752 }
02753 }
else if (tm.tm_year <= 20) {
02754
02755 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
02756 res = wait_file(chan,ints,nextmsg,lang);
02757 }
else {
02758
02759
int ten, one;
02760 ten = tm.tm_year / 10;
02761 one = tm.tm_year % 10;
02762 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten * 10);
02763 res = wait_file(chan,ints,nextmsg,lang);
02764
if (!res) {
02765
if (one != 0) {
02766 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02767 res = wait_file(chan,ints,nextmsg,lang);
02768 }
02769 }
02770 }
02771 }
02772 }
02773 }
02774
break;
02775
case 'I':
02776
case 'l':
02777
02778
if (tm.tm_hour == 0)
02779 snprintf(nextmsg,
sizeof(nextmsg),
"digits/12");
02780
else if (tm.tm_hour > 12)
02781 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - 12);
02782
else
02783 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
02784 res = wait_file(chan,ints,nextmsg,lang);
02785
break;
02786
case 'H':
02787
case 'k':
02788
02789 res =
ast_say_number(chan, tm.tm_hour, ints, lang, (
char *) NULL);
02790
if (!res) {
02791 res = wait_file(chan,ints,
"digits/nl-uur",lang);
02792 }
02793
break;
02794
case 'M':
02795
02796 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
02797
break;
02798
case 'P':
02799
case 'p':
02800
02801
if (tm.tm_hour > 11)
02802 snprintf(nextmsg,
sizeof(nextmsg),
"digits/p-m");
02803
else
02804 snprintf(nextmsg,
sizeof(nextmsg),
"digits/a-m");
02805 res = wait_file(chan,ints,nextmsg,lang);
02806
break;
02807
case 'Q':
02808
02809 {
02810
struct timeval now;
02811
struct tm tmnow;
02812 time_t beg_today;
02813
02814 gettimeofday(&now,NULL);
02815
ast_localtime(&now.tv_sec,&tmnow,timezone);
02816
02817
02818 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02819
if (beg_today < time) {
02820
02821 res = wait_file(chan,ints,
"digits/today",lang);
02822 }
else if (beg_today - 86400 < time) {
02823
02824 res = wait_file(chan,ints,
"digits/yesterday",lang);
02825 }
else {
02826 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02827 }
02828 }
02829
break;
02830
case 'q':
02831
02832 {
02833
struct timeval now;
02834
struct tm tmnow;
02835 time_t beg_today;
02836
02837 gettimeofday(&now,NULL);
02838
ast_localtime(&now.tv_sec,&tmnow,timezone);
02839
02840
02841 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
02842
if (beg_today < time) {
02843
02844 }
else if ((beg_today - 86400) < time) {
02845
02846 res = wait_file(chan,ints,
"digits/yesterday",lang);
02847 }
else if (beg_today - 86400 * 6 < time) {
02848
02849 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
02850 }
else {
02851 res =
ast_say_date_with_format(chan, time, ints, lang,
"ABdY", timezone);
02852 }
02853 }
02854
break;
02855
case 'R':
02856 res =
ast_say_date_with_format(chan, time, ints, lang,
"HM", timezone);
02857
break;
02858
case 'S':
02859
02860
if (tm.tm_sec == 0) {
02861 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02862 res = wait_file(chan,ints,nextmsg,lang);
02863 }
else if (tm.tm_sec < 10) {
02864 res = wait_file(chan,ints,
"digits/oh",lang);
02865
if (!res) {
02866 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02867 res = wait_file(chan,ints,nextmsg,lang);
02868 }
02869 }
else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
02870 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
02871 res = wait_file(chan,ints,nextmsg,lang);
02872 }
else {
02873
int ten, one;
02874 ten = (tm.tm_sec / 10) * 10;
02875 one = (tm.tm_sec % 10);
02876 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
02877 res = wait_file(chan,ints,nextmsg,lang);
02878
if (!res) {
02879
02880
if (one != 0) {
02881 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
02882 res = wait_file(chan,ints,nextmsg,lang);
02883 }
02884 }
02885 }
02886
break;
02887
case 'T':
02888 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
02889
break;
02890
case ' ':
02891
case ' ':
02892
02893
break;
02894
default:
02895
02896
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
02897 }
02898
02899
if (res) {
02900
break;
02901 }
02902 }
02903
return res;
02904 }
02905
02906
02907
int ast_say_date_with_format_pt(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
02908 {
02909
struct tm tm;
02910
int res=0, offset, sndoffset;
02911
char sndfile[256], nextmsg[256];
02912
02913
ast_localtime(&time,&tm,timezone);
02914
02915
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
02916
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
02917
switch (format[offset]) {
02918
02919
case '\'':
02920
02921 sndoffset=0;
02922
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
02923 sndfile[sndoffset] = format[offset];
02924 sndfile[sndoffset] =
'\0';
02925 snprintf(nextmsg,
sizeof(nextmsg),
"%s", sndfile);
02926 res = wait_file(chan,ints,nextmsg,lang);
02927
break;
02928
case 'A':
02929
case 'a':
02930
02931 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
02932 res = wait_file(chan,ints,nextmsg,lang);
02933
break;
02934
case 'B':
02935
case 'b':
02936
case 'h':
02937
02938 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
02939 res = wait_file(chan,ints,nextmsg,lang);
02940
break;
02941
case 'd':
02942
case 'e':
02943
02944 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
02945
break;
02946
case 'Y':
02947
02948 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
02949
break;
02950
case 'I':
02951
case 'l':
02952
02953
if (tm.tm_hour == 0) {
02954
if (format[offset] ==
'I')
02955 res = wait_file(chan, ints,
"digits/pt-ah", lang);
02956
if (!res)
02957 res = wait_file(chan, ints,
"digits/pt-meianoite", lang);
02958 }
02959
else if (tm.tm_hour == 12) {
02960
if (format[offset] ==
'I')
02961 res = wait_file(chan, ints,
"digits/pt-ao", lang);
02962
if (!res)
02963 res = wait_file(chan, ints,
"digits/pt-meiodia", lang);
02964 }
02965
else {
02966
if (format[offset] ==
'I') {
02967 res = wait_file(chan, ints,
"digits/pt-ah", lang);
02968
if ((tm.tm_hour % 12) != 1)
02969
if (!res)
02970 res = wait_file(chan, ints,
"digits/pt-sss", lang);
02971 }
02972
if (!res)
02973 res =
ast_say_number(chan, (tm.tm_hour % 12), ints, lang,
"f");
02974 }
02975
break;
02976
case 'H':
02977
case 'k':
02978
02979 res =
ast_say_number(chan, -tm.tm_hour, ints, lang, NULL);
02980
if (!res) {
02981
if (tm.tm_hour != 0) {
02982
int remainder = tm.tm_hour;
02983
if (tm.tm_hour > 20) {
02984 res = wait_file(chan,ints,
"digits/20",lang);
02985 remainder -= 20;
02986 }
02987
if (!res) {
02988 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", remainder);
02989 res = wait_file(chan,ints,nextmsg,lang);
02990 }
02991 }
02992 }
02993
break;
02994
case 'M':
02995
02996
if (tm.tm_min == 0) {
02997 res = wait_file(chan, ints,
"digits/pt-hora", lang);
02998
if (tm.tm_hour != 1)
02999
if (!res)
03000 res = wait_file(chan, ints,
"digits/pt-sss", lang); }
else {
03001 res = wait_file(chan,ints,
"digits/pt-e",lang);
03002
if (!res)
03003 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03004 }
03005
break;
03006
case 'P':
03007
case 'p':
03008
03009
if (tm.tm_hour > 12)
03010 res = wait_file(chan, ints,
"digits/p-m", lang);
03011
else if (tm.tm_hour && tm.tm_hour < 12)
03012 res = wait_file(chan, ints,
"digits/a-m", lang);
03013
break;
03014
case 'Q':
03015
03016 {
03017
struct timeval now;
03018
struct tm tmnow;
03019 time_t beg_today;
03020
03021 gettimeofday(&now,NULL);
03022
ast_localtime(&now.tv_sec,&tmnow,timezone);
03023
03024
03025 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03026
if (beg_today < time) {
03027
03028 res = wait_file(chan,ints,
"digits/today",lang);
03029 }
else if (beg_today - 86400 < time) {
03030
03031 res = wait_file(chan,ints,
"digits/yesterday",lang);
03032 }
else {
03033 res =
ast_say_date_with_format(chan, time, ints, lang,
"Ad 'digits/pt-de' B 'digits/pt-de' Y", timezone);
03034 }
03035 }
03036
break;
03037
case 'q':
03038
03039 {
03040
struct timeval now;
03041
struct tm tmnow;
03042 time_t beg_today;
03043
03044 gettimeofday(&now,NULL);
03045
ast_localtime(&now.tv_sec,&tmnow,timezone);
03046
03047
03048 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03049
if (beg_today < time) {
03050
03051 }
else if ((beg_today - 86400) < time) {
03052
03053 res = wait_file(chan,ints,
"digits/yesterday",lang);
03054 }
else if (beg_today - 86400 * 6 < time) {
03055
03056 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
03057 }
else {
03058 res =
ast_say_date_with_format(chan, time, ints, lang,
"Ad 'digits/pt-de' B 'digits/pt-de' Y", timezone);
03059 }
03060 }
03061
break;
03062
case 'R':
03063 res =
ast_say_date_with_format(chan, time, ints, lang,
"H 'digits/pt-e' M", timezone);
03064
break;
03065
case 'S':
03066
03067
if (tm.tm_sec == 0) {
03068 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
03069 res = wait_file(chan,ints,nextmsg,lang);
03070 }
else if (tm.tm_sec < 10) {
03071 res = wait_file(chan,ints,
"digits/oh",lang);
03072
if (!res) {
03073 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
03074 res = wait_file(chan,ints,nextmsg,lang);
03075 }
03076 }
else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
03077 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
03078 res = wait_file(chan,ints,nextmsg,lang);
03079 }
else {
03080
int ten, one;
03081 ten = (tm.tm_sec / 10) * 10;
03082 one = (tm.tm_sec % 10);
03083 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", ten);
03084 res = wait_file(chan,ints,nextmsg,lang);
03085
if (!res) {
03086
03087
if (one != 0) {
03088 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", one);
03089 res = wait_file(chan,ints,nextmsg,lang);
03090 }
03091 }
03092 }
03093
break;
03094
case 'T':
03095 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
03096
break;
03097
case ' ':
03098
case ' ':
03099
03100
break;
03101
default:
03102
03103
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03104 }
03105
03106
if (res) {
03107
break;
03108 }
03109 }
03110
return res;
03111 }
03112
03113
03114
int ast_say_date_with_format_tw(
struct ast_channel *chan, time_t time,
char *ints,
char *lang,
char *format,
char *timezone)
03115 {
03116
struct tm tm;
03117
int res=0, offset, sndoffset;
03118
char sndfile[256], nextmsg[256];
03119
03120
ast_localtime(&time,&tm,timezone);
03121
03122
for (offset=0 ; format[offset] !=
'\0' ; offset++) {
03123
ast_log(LOG_DEBUG,
"Parsing %c (offset %d) in %s\n", format[offset], offset, format);
03124
switch (format[offset]) {
03125
03126
case '\'':
03127
03128 sndoffset=0;
03129
for (sndoffset=0 ; (format[++offset] !=
'\'') && (sndoffset < 256) ; sndoffset++)
03130 sndfile[sndoffset] = format[offset];
03131 sndfile[sndoffset] =
'\0';
03132 res = wait_file(chan,ints,sndfile,lang);
03133
break;
03134
case 'A':
03135
case 'a':
03136
03137 snprintf(nextmsg,
sizeof(nextmsg),
"digits/day-%d", tm.tm_wday);
03138 res = wait_file(chan,ints,nextmsg,lang);
03139
break;
03140
case 'B':
03141
case 'b':
03142
case 'h':
03143
03144 snprintf(nextmsg,
sizeof(nextmsg),
"digits/mon-%d", tm.tm_mon);
03145 res = wait_file(chan,ints,nextmsg,lang);
03146
break;
03147
case 'd':
03148
case 'e':
03149
03150
if (!(tm.tm_mday % 10) || (tm.tm_mday < 10)) {
03151 snprintf(nextmsg,
sizeof(nextmsg),
"digits/h-%d", tm.tm_mday);
03152 res = wait_file(chan,ints,nextmsg,lang);
03153 }
else {
03154 snprintf(nextmsg,
sizeof(nextmsg),
"digits/h-%dh", tm.tm_mday - (tm.tm_mday % 10));
03155 res = wait_file(chan,ints,nextmsg,lang);
03156
if(!res) {
03157 snprintf(nextmsg,
sizeof(nextmsg),
"digits/h-%d", tm.tm_mday % 10);
03158 res = wait_file(chan,ints,nextmsg,lang);
03159 }
03160 }
03161
break;
03162
case 'Y':
03163
03164
if (tm.tm_year > 99) {
03165 res = wait_file(chan,ints,
"digits/2",lang);
03166
if (!res) {
03167 res = wait_file(chan,ints,
"digits/thousand",lang);
03168 }
03169
if (tm.tm_year > 100) {
03170
if (!res) {
03171 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", (tm.tm_year - 100) / 10);
03172 res = wait_file(chan,ints,nextmsg,lang);
03173
if (!res) {
03174 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", (tm.tm_year - 100) % 10);
03175 res = wait_file(chan,ints,nextmsg,lang);
03176 }
03177 }
03178 }
03179
if (!res) {
03180 res = wait_file(chan,ints,
"digits/year",lang);
03181 }
03182 }
else {
03183
if (tm.tm_year < 1) {
03184
03185
03186 }
else {
03187 res = wait_file(chan,ints,
"digits/1",lang);
03188
if (!res) {
03189 res = wait_file(chan,ints,
"digits/9",lang);
03190 }
03191
if (!res) {
03192
if (tm.tm_year <= 9) {
03193
03194 res = wait_file(chan,ints,
"digits/0",lang);
03195
if (!res) {
03196 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year);
03197 res = wait_file(chan,ints,nextmsg,lang);
03198 }
03199 }
else {
03200
03201 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year / 10);
03202 res = wait_file(chan,ints,nextmsg,lang);
03203
if (!res) {
03204 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_year % 10);
03205 res = wait_file(chan,ints,nextmsg,lang);
03206 }
03207 }
03208 }
03209 }
03210
if (!res) {
03211 res = wait_file(chan,ints,
"digits/year",lang);
03212 }
03213 }
03214
break;
03215
case 'I':
03216
case 'l':
03217
03218
if (tm.tm_hour == 0)
03219 snprintf(nextmsg,
sizeof(nextmsg),
"digits/12");
03220
else if (tm.tm_hour > 12)
03221 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - 12);
03222
else
03223 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
03224 res = wait_file(chan,ints,nextmsg,lang);
03225
if (!res) {
03226 res = wait_file(chan,ints,
"digits/oclock",lang);
03227 }
03228
break;
03229
case 'H':
03230
case 'k':
03231
03232
if (!(tm.tm_hour % 10) || tm.tm_hour < 10) {
03233
if (tm.tm_hour < 10) {
03234 res = wait_file(chan, ints,
"digits/0", lang);
03235 }
03236 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour);
03237 res = wait_file(chan,ints,nextmsg,lang);
03238 }
else {
03239 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour - (tm.tm_hour % 10));
03240 res = wait_file(chan,ints,nextmsg,lang);
03241
if (!res) {
03242 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_hour % 10);
03243 res = wait_file(chan,ints,nextmsg,lang);
03244 }
03245 }
03246
if (!res) {
03247 res = wait_file(chan,ints,
"digits/oclock",lang);
03248 }
03249
break;
03250
case 'M':
03251
03252
if (!(tm.tm_min % 10) || tm.tm_min < 10) {
03253
if (tm.tm_min < 10) {
03254 res = wait_file(chan, ints,
"digits/0", lang);
03255 }
03256 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min);
03257 res = wait_file(chan,ints,nextmsg,lang);
03258 }
else {
03259 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min - (tm.tm_min % 10));
03260 res = wait_file(chan,ints,nextmsg,lang);
03261
if (!res) {
03262 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_min % 10);
03263 res = wait_file(chan,ints,nextmsg,lang);
03264 }
03265 }
03266
if (!res) {
03267 res = wait_file(chan,ints,
"digits/minute",lang);
03268 }
03269
break;
03270
case 'P':
03271
case 'p':
03272
03273
if (tm.tm_hour > 11)
03274 snprintf(nextmsg,
sizeof(nextmsg),
"digits/p-m");
03275
else
03276 snprintf(nextmsg,
sizeof(nextmsg),
"digits/a-m");
03277 res = wait_file(chan,ints,nextmsg,lang);
03278
break;
03279
case 'Q':
03280
03281 {
03282
struct timeval now;
03283
struct tm tmnow;
03284 time_t beg_today;
03285
03286 gettimeofday(&now,NULL);
03287
ast_localtime(&now.tv_sec,&tmnow,timezone);
03288
03289
03290 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03291
if (beg_today < time) {
03292
03293 res = wait_file(chan,ints,
"digits/today",lang);
03294 }
else if (beg_today - 86400 < time) {
03295
03296 res = wait_file(chan,ints,
"digits/yesterday",lang);
03297 }
else {
03298 res =
ast_say_date_with_format(chan, time, ints, lang,
"YBdA", timezone);
03299 }
03300 }
03301
break;
03302
case 'q':
03303
03304 {
03305
struct timeval now;
03306
struct tm tmnow;
03307 time_t beg_today;
03308
03309 gettimeofday(&now,NULL);
03310
ast_localtime(&now.tv_sec,&tmnow,timezone);
03311
03312
03313 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03314
if (beg_today < time) {
03315
03316 }
else if ((beg_today - 86400) < time) {
03317
03318 res = wait_file(chan,ints,
"digits/yesterday",lang);
03319 }
else if (beg_today - 86400 * 6 < time) {
03320
03321 res =
ast_say_date_with_format(chan, time, ints, lang,
"A", timezone);
03322 }
else {
03323 res =
ast_say_date_with_format(chan, time, ints, lang,
"YBdA", timezone);
03324 }
03325 }
03326
break;
03327
case 'R':
03328 res =
ast_say_date_with_format(chan, time, ints, lang,
"HM", timezone);
03329
break;
03330
case 'S':
03331
03332
if (!(tm.tm_sec % 10) || tm.tm_sec < 10) {
03333
if (tm.tm_sec < 10) {
03334 res = wait_file(chan, ints,
"digits/0", lang);
03335 }
03336 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec);
03337 res = wait_file(chan,ints,nextmsg,lang);
03338 }
else {
03339 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec - (tm.tm_sec % 10));
03340 res = wait_file(chan,ints,nextmsg,lang);
03341
if (!res) {
03342 snprintf(nextmsg,
sizeof(nextmsg),
"digits/%d", tm.tm_sec % 10);
03343 res = wait_file(chan,ints,nextmsg,lang);
03344 }
03345 }
03346
if (!res) {
03347 res = wait_file(chan,ints,
"digits/second",lang);
03348 }
03349
break;
03350
case 'T':
03351 res =
ast_say_date_with_format(chan, time, ints, lang,
"HMS", timezone);
03352
break;
03353
case ' ':
03354
case ' ':
03355
03356
break;
03357
default:
03358
03359
ast_log(LOG_WARNING,
"Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03360 }
03361
03362
if (res) {
03363
break;
03364 }
03365 }
03366
return res;
03367 }
03368
03369
03370 int ast_say_time(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03371 {
03372
if (!strcasecmp(lang,
"en") ) {
03373
return(ast_say_time_en(chan, t, ints, lang));
03374 }
else if (!strcasecmp(lang,
"nl") ) {
03375
return(ast_say_time_nl(chan, t, ints, lang));
03376 }
else if (!strcasecmp(lang,
"pt") ) {
03377
return(ast_say_time_pt(chan, t, ints, lang));
03378 }
else if (!strcasecmp(lang,
"tw") ) {
03379
return(ast_say_time_tw(chan, t, ints, lang));
03380 }
03381
03382
03383
return(ast_say_time_en(chan, t, ints, lang));
03384 }
03385
03386
03387
int ast_say_time_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03388 {
03389
struct tm tm;
03390
int res = 0;
03391
int hour, pm=0;
03392 localtime_r(&t,&tm);
03393 hour = tm.tm_hour;
03394
if (!hour)
03395 hour = 12;
03396
else if (hour == 12)
03397 pm = 1;
03398
else if (hour > 12) {
03399 hour -= 12;
03400 pm = 1;
03401 }
03402
if (!res)
03403 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03404
03405
if (tm.tm_min > 9) {
03406
if (!res)
03407 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03408 }
else if (tm.tm_min) {
03409
if (!res)
03410 res =
ast_streamfile(chan,
"digits/oh", lang);
03411
if (!res)
03412 res =
ast_waitstream(chan, ints);
03413
if (!res)
03414 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03415 }
else {
03416
if (!res)
03417 res =
ast_streamfile(chan,
"digits/oclock", lang);
03418
if (!res)
03419 res =
ast_waitstream(chan, ints);
03420 }
03421
if (pm) {
03422
if (!res)
03423 res =
ast_streamfile(chan,
"digits/p-m", lang);
03424 }
else {
03425
if (!res)
03426 res =
ast_streamfile(chan,
"digits/a-m", lang);
03427 }
03428
if (!res)
03429 res =
ast_waitstream(chan, ints);
03430
return res;
03431 }
03432
03433
03434
int ast_say_time_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03435 {
03436
struct tm tm;
03437
int res = 0;
03438
int hour;
03439 localtime_r(&t,&tm);
03440 hour = tm.tm_hour;
03441
if (!res)
03442 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03443
03444
if (!res)
03445 res =
ast_streamfile(chan,
"digits/nl-uur", lang);
03446
if (!res)
03447 res =
ast_waitstream(chan, ints);
03448
if (!res)
03449
if (tm.tm_min > 0)
03450 res =
ast_say_number(chan, tm.tm_min, ints, lang, NULL);
03451
return res;
03452 }
03453
03454
03455
int ast_say_time_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03456 {
03457
struct tm tm;
03458
int res = 0;
03459
int hour;
03460 localtime_r(&t,&tm);
03461 hour = tm.tm_hour;
03462
if (!res)
03463 res =
ast_say_number(chan, hour, ints, lang,
"f");
03464
if (tm.tm_min) {
03465
if (!res)
03466 res = wait_file(chan, ints,
"digits/pt-e", lang);
03467
if (!res)
03468 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03469 }
else {
03470
if (!res)
03471 res = wait_file(chan, ints,
"digits/pt-hora", lang);
03472
if (tm.tm_hour != 1)
03473
if (!res)
03474 res = wait_file(chan, ints,
"digits/pt-sss", lang);
03475 }
03476
if (!res)
03477 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03478
return res;
03479 }
03480
03481
03482
int ast_say_time_tw(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03483 {
03484
struct tm tm;
03485
int res = 0;
03486
int hour, pm=0;
03487 localtime_r(&t,&tm);
03488 hour = tm.tm_hour;
03489
if (!hour)
03490 hour = 12;
03491
else if (hour == 12)
03492 pm = 1;
03493
else if (hour > 12) {
03494 hour -= 12;
03495 pm = 1;
03496 }
03497
if (pm) {
03498
if (!res)
03499 res =
ast_streamfile(chan,
"digits/p-m", lang);
03500 }
else {
03501
if (!res)
03502 res =
ast_streamfile(chan,
"digits/a-m", lang);
03503 }
03504
if (!res)
03505 res =
ast_waitstream(chan, ints);
03506
if (!res)
03507 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03508
if (!res)
03509 res =
ast_streamfile(chan,
"digits/oclock", lang);
03510
if (!res)
03511 res =
ast_waitstream(chan, ints);
03512
if (!res)
03513 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03514
if (!res)
03515 res =
ast_streamfile(chan,
"digits/minute", lang);
03516
if (!res)
03517 res =
ast_waitstream(chan, ints);
03518
return res;
03519 }
03520
03521
03522 int ast_say_datetime(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03523 {
03524
if (!strcasecmp(lang,
"en") ) {
03525
return(ast_say_datetime_en(chan, t, ints, lang));
03526 }
else if (!strcasecmp(lang,
"nl") ) {
03527
return(ast_say_datetime_nl(chan, t, ints, lang));
03528 }
else if (!strcasecmp(lang,
"pt") ) {
03529
return(ast_say_datetime_pt(chan, t, ints, lang));
03530 }
else if (!strcasecmp(lang,
"tw") ) {
03531
return(ast_say_datetime_tw(chan, t, ints, lang));
03532 }
03533
03534
03535
return(ast_say_datetime_en(chan, t, ints, lang));
03536 }
03537
03538
03539
int ast_say_datetime_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03540 {
03541
struct tm tm;
03542
char fn[256];
03543
int res = 0;
03544
int hour, pm=0;
03545 localtime_r(&t,&tm);
03546
if (!res) {
03547 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
03548 res =
ast_streamfile(chan, fn, lang);
03549
if (!res)
03550 res =
ast_waitstream(chan, ints);
03551 }
03552
if (!res) {
03553 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
03554 res =
ast_streamfile(chan, fn, lang);
03555
if (!res)
03556 res =
ast_waitstream(chan, ints);
03557 }
03558
if (!res)
03559 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
03560
03561 hour = tm.tm_hour;
03562
if (!hour)
03563 hour = 12;
03564
else if (hour == 12)
03565 pm = 1;
03566
else if (hour > 12) {
03567 hour -= 12;
03568 pm = 1;
03569 }
03570
if (!res)
03571 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03572
03573
if (tm.tm_min > 9) {
03574
if (!res)
03575 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03576 }
else if (tm.tm_min) {
03577
if (!res)
03578 res =
ast_streamfile(chan,
"digits/oh", lang);
03579
if (!res)
03580 res =
ast_waitstream(chan, ints);
03581
if (!res)
03582 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03583 }
else {
03584
if (!res)
03585 res =
ast_streamfile(chan,
"digits/oclock", lang);
03586
if (!res)
03587 res =
ast_waitstream(chan, ints);
03588 }
03589
if (pm) {
03590
if (!res)
03591 res =
ast_streamfile(chan,
"digits/p-m", lang);
03592 }
else {
03593
if (!res)
03594 res =
ast_streamfile(chan,
"digits/a-m", lang);
03595 }
03596
if (!res)
03597 res =
ast_waitstream(chan, ints);
03598
if (!res)
03599 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
03600
return res;
03601 }
03602
03603
03604
int ast_say_datetime_nl(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03605 {
03606
struct tm tm;
03607
int res = 0;
03608 localtime_r(&t,&tm);
03609 res =
ast_say_date(chan, t, ints, lang);
03610
if (!res) {
03611 res =
ast_streamfile(chan,
"digits/nl-om", lang);
03612
if (!res)
03613 res =
ast_waitstream(chan, ints);
03614 }
03615
if (!res)
03616
ast_say_time(chan, t, ints, lang);
03617
return res;
03618 }
03619
03620
03621
int ast_say_datetime_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03622 {
03623
struct tm tm;
03624
char fn[256];
03625
int res = 0;
03626
int hour, pm=0;
03627 localtime_r(&t,&tm);
03628
if (!res) {
03629 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
03630 res =
ast_streamfile(chan, fn, lang);
03631
if (!res)
03632 res =
ast_waitstream(chan, ints);
03633 }
03634
if (!res) {
03635 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
03636 res =
ast_streamfile(chan, fn, lang);
03637
if (!res)
03638 res =
ast_waitstream(chan, ints);
03639 }
03640
if (!res)
03641 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
03642
03643 hour = tm.tm_hour;
03644
if (!hour)
03645 hour = 12;
03646
else if (hour == 12)
03647 pm = 1;
03648
else if (hour > 12) {
03649 hour -= 12;
03650 pm = 1;
03651 }
03652
if (!res)
03653 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03654
03655
if (tm.tm_min > 9) {
03656
if (!res)
03657 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03658 }
else if (tm.tm_min) {
03659
if (!res)
03660 res =
ast_streamfile(chan,
"digits/oh", lang);
03661
if (!res)
03662 res =
ast_waitstream(chan, ints);
03663
if (!res)
03664 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03665 }
else {
03666
if (!res)
03667 res =
ast_streamfile(chan,
"digits/oclock", lang);
03668
if (!res)
03669 res =
ast_waitstream(chan, ints);
03670 }
03671
if (pm) {
03672
if (!res)
03673 res =
ast_streamfile(chan,
"digits/p-m", lang);
03674 }
else {
03675
if (!res)
03676 res =
ast_streamfile(chan,
"digits/a-m", lang);
03677 }
03678
if (!res)
03679 res =
ast_waitstream(chan, ints);
03680
if (!res)
03681 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
03682
return res;
03683 }
03684
03685
03686
int ast_say_datetime_tw(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03687 {
03688
struct tm tm;
03689
char fn[256];
03690
int res = 0;
03691
int hour, pm=0;
03692 localtime_r(&t,&tm);
03693
if (!res)
03694 res =
ast_say_number(chan, tm.tm_year + 1900, ints, lang, (
char *) NULL);
03695
if (!res) {
03696 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
03697 res =
ast_streamfile(chan, fn, lang);
03698
if (!res)
03699 res =
ast_waitstream(chan, ints);
03700 }
03701
if (!res)
03702 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
03703
if (!res) {
03704 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
03705 res =
ast_streamfile(chan, fn, lang);
03706
if (!res)
03707 res =
ast_waitstream(chan, ints);
03708 }
03709
03710 hour = tm.tm_hour;
03711
if (!hour)
03712 hour = 12;
03713
else if (hour == 12)
03714 pm = 1;
03715
else if (hour > 12) {
03716 hour -= 12;
03717 pm = 1;
03718 }
03719
if (pm) {
03720
if (!res)
03721 res =
ast_streamfile(chan,
"digits/p-m", lang);
03722 }
else {
03723
if (!res)
03724 res =
ast_streamfile(chan,
"digits/a-m", lang);
03725 }
03726
if (!res)
03727 res =
ast_waitstream(chan, ints);
03728
if (!res)
03729 res =
ast_say_number(chan, hour, ints, lang, (
char *) NULL);
03730
if (!res)
03731 res =
ast_streamfile(chan,
"digits/oclock", lang);
03732
if (!res)
03733 res =
ast_waitstream(chan, ints);
03734
if (!res)
03735 res =
ast_say_number(chan, tm.tm_min, ints, lang, (
char *) NULL);
03736
if (!res)
03737 res =
ast_streamfile(chan,
"digits/minute", lang);
03738
if (!res)
03739 res =
ast_waitstream(chan, ints);
03740
return res;
03741 }
03742
03743
03744 int ast_say_datetime_from_now(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03745 {
03746
if (!strcasecmp(lang,
"en") ) {
03747
return(ast_say_datetime_from_now_en(chan, t, ints, lang));
03748 }
else if (!strcasecmp(lang,
"pt") ) {
03749
return(ast_say_datetime_from_now_pt(chan, t, ints, lang));
03750 }
03751
03752
03753
return(ast_say_datetime_from_now_en(chan, t, ints, lang));
03754 }
03755
03756
03757
int ast_say_datetime_from_now_en(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03758 {
03759
int res=0;
03760 time_t nowt;
03761
int daydiff;
03762
struct tm tm;
03763
struct tm now;
03764
char fn[256];
03765
03766 time(&nowt);
03767
03768 localtime_r(&t,&tm);
03769 localtime_r(&nowt,&now);
03770 daydiff = now.tm_yday - tm.tm_yday;
03771
if ((daydiff < 0) || (daydiff > 6)) {
03772
03773
if (!res) {
03774 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
03775 res =
ast_streamfile(chan, fn, lang);
03776
if (!res)
03777 res =
ast_waitstream(chan, ints);
03778 }
03779
if (!res)
03780 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
03781
03782 }
else if (daydiff) {
03783
03784
if (!res) {
03785 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
03786 res =
ast_streamfile(chan, fn, lang);
03787
if (!res)
03788 res =
ast_waitstream(chan, ints);
03789 }
03790 }
03791
if (!res)
03792 res =
ast_say_time(chan, t, ints, lang);
03793
return res;
03794 }
03795
03796
03797
int ast_say_datetime_from_now_pt(
struct ast_channel *chan, time_t t,
char *ints,
char *lang)
03798 {
03799
int res=0;
03800 time_t nowt;
03801
int daydiff;
03802
struct tm tm;
03803
struct tm now;
03804
char fn[256];
03805
03806 time(&nowt);
03807
03808 localtime_r(&t,&tm);
03809 localtime_r(&nowt,&now);
03810 daydiff = now.tm_yday - tm.tm_yday;
03811
if ((daydiff < 0) || (daydiff > 6)) {
03812
03813
if (!res)
03814 res =
ast_say_number(chan, tm.tm_mday, ints, lang, (
char *) NULL);
03815
if (!res)
03816 res = wait_file(chan, ints,
"digits/pt-de", lang);
03817 snprintf(fn,
sizeof(fn),
"digits/mon-%d", tm.tm_mon);
03818
if (!res)
03819 res = wait_file(chan, ints, fn, lang);
03820
03821 }
else if (daydiff) {
03822
03823 snprintf(fn,
sizeof(fn),
"digits/day-%d", tm.tm_wday);
03824
if (!res)
03825 res = wait_file(chan, ints, fn, lang);
03826 }
03827 snprintf(fn,
sizeof(fn),
"digits/pt-ah");
03828
if (!res)
03829 res = wait_file(chan, ints, fn, lang);
03830
if (tm.tm_hour != 1)
03831
if (!res)
03832 res = wait_file(chan, ints,
"digits/pt-sss", lang);
03833
if (!res)
03834 res =
ast_say_time(chan, t, ints, lang);
03835
return res;
03836 }