00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #include <sys/types.h>
00029 #include <string.h>
00030 #include <stdlib.h>
00031 #include <netinet/in.h>
00032 #include <time.h>
00033 #include <ctype.h>
00034 #include <math.h>
00035 #include <stdio.h>
00036
00037 #ifdef SOLARIS
00038 #include <iso/limits_iso.h>
00039 #endif
00040
00041 #include "asterisk.h"
00042
00043 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 7221 $")
00044
00045 #include "asterisk/file.h"
00046 #include "asterisk/channel.h"
00047 #include "asterisk/logger.h"
00048 #include "asterisk/options.h"
00049 #include "asterisk/say.h"
00050 #include "asterisk/lock.h"
00051 #include "asterisk/localtime.h"
00052 #include "asterisk/utils.h"
00053
00054
00055 static int wait_file(struct ast_channel *chan, const char *ints, const char *file, const char *lang);
00056
00057 int ast_say_character_str_full(struct ast_channel *chan, const char *str, const char *ints, const char *lang, int audiofd, int ctrlfd)
00058 {
00059 const char *fn;
00060 char fnbuf[256];
00061 char ltr;
00062 int num = 0;
00063 int res = 0;
00064
00065 while (str[num]) {
00066 fn = NULL;
00067 switch (str[num]) {
00068 case ('*'):
00069 fn = "digits/star";
00070 break;
00071 case ('#'):
00072 fn = "digits/pound";
00073 break;
00074 case ('!'):
00075 fn = "letters/exclaimation-point";
00076 break;
00077 case ('@'):
00078 fn = "letters/at";
00079 break;
00080 case ('$'):
00081 fn = "letters/dollar";
00082 break;
00083 case ('-'):
00084 fn = "letters/dash";
00085 break;
00086 case ('.'):
00087 fn = "letters/dot";
00088 break;
00089 case ('='):
00090 fn = "letters/equals";
00091 break;
00092 case ('+'):
00093 fn = "letters/plus";
00094 break;
00095 case ('/'):
00096 fn = "letters/slash";
00097 break;
00098 case (' '):
00099 fn = "letters/space";
00100 break;
00101 case ('0'):
00102 case ('1'):
00103 case ('2'):
00104 case ('3'):
00105 case ('4'):
00106 case ('5'):
00107 case ('6'):
00108 case ('7'):
00109 case ('8'):
00110 case ('9'):
00111 strcpy(fnbuf, "digits/X");
00112 fnbuf[7] = str[num];
00113 fn = fnbuf;
00114 break;
00115 default:
00116 ltr = str[num];
00117 if ('A' <= ltr && ltr <= 'Z') ltr += 'a' - 'A';
00118 strcpy(fnbuf, "letters/X");
00119 fnbuf[8] = ltr;
00120 fn = fnbuf;
00121 }
00122 res = ast_streamfile(chan, fn, lang);
00123 if (!res)
00124 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00125 ast_stopstream(chan);
00126 num++;
00127 }
00128
00129 return res;
00130 }
00131
00132 int ast_say_character_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
00133 {
00134 return ast_say_character_str_full(chan, str, ints, lang, -1, -1);
00135 }
00136
00137 int ast_say_phonetic_str_full(struct ast_channel *chan, const char *str, const char *ints, const char *lang, int audiofd, int ctrlfd)
00138 {
00139 const char *fn;
00140 char fnbuf[256];
00141 char ltr;
00142 int num = 0;
00143 int res = 0;
00144
00145 while (str[num]) {
00146 fn = NULL;
00147 switch (str[num]) {
00148 case ('*'):
00149 fn = "digits/star";
00150 break;
00151 case ('#'):
00152 fn = "digits/pound";
00153 break;
00154 case ('!'):
00155 fn = "letters/exclaimation-point";
00156 break;
00157 case ('@'):
00158 fn = "letters/at";
00159 break;
00160 case ('$'):
00161 fn = "letters/dollar";
00162 break;
00163 case ('-'):
00164 fn = "letters/dash";
00165 break;
00166 case ('.'):
00167 fn = "letters/dot";
00168 break;
00169 case ('='):
00170 fn = "letters/equals";
00171 break;
00172 case ('+'):
00173 fn = "letters/plus";
00174 break;
00175 case ('/'):
00176 fn = "letters/slash";
00177 break;
00178 case (' '):
00179 fn = "letters/space";
00180 break;
00181 case ('0'):
00182 case ('1'):
00183 case ('2'):
00184 case ('3'):
00185 case ('4'):
00186 case ('5'):
00187 case ('6'):
00188 case ('7'):
00189 case ('8'):
00190 strcpy(fnbuf, "digits/X");
00191 fnbuf[7] = str[num];
00192 fn = fnbuf;
00193 break;
00194 default:
00195 ltr = str[num];
00196 if ('A' <= ltr && ltr <= 'Z') ltr += 'a' - 'A';
00197 strcpy(fnbuf, "phonetic/X_p");
00198 fnbuf[9] = ltr;
00199 fn = fnbuf;
00200 }
00201 res = ast_streamfile(chan, fn, lang);
00202 if (!res)
00203 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00204 ast_stopstream(chan);
00205 num++;
00206 }
00207
00208 return res;
00209 }
00210
00211 int ast_say_phonetic_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
00212 {
00213 return ast_say_phonetic_str_full(chan, str, ints, lang, -1, -1);
00214 }
00215
00216 int ast_say_digit_str_full(struct ast_channel *chan, const char *str, const char *ints, const char *lang, int audiofd, int ctrlfd)
00217 {
00218 const char *fn;
00219 char fnbuf[256];
00220 int num = 0;
00221 int res = 0;
00222
00223 while (str[num] && !res) {
00224 fn = NULL;
00225 switch (str[num]) {
00226 case ('*'):
00227 fn = "digits/star";
00228 break;
00229 case ('#'):
00230 fn = "digits/pound";
00231 break;
00232 case ('-'):
00233 fn = "digits/minus";
00234 break;
00235 case '0':
00236 case '1':
00237 case '2':
00238 case '3':
00239 case '4':
00240 case '5':
00241 case '6':
00242 case '7':
00243 case '8':
00244 case '9':
00245 strcpy(fnbuf, "digits/X");
00246 fnbuf[7] = str[num];
00247 fn = fnbuf;
00248 break;
00249 }
00250 if (fn) {
00251 res = ast_streamfile(chan, fn, lang);
00252 if (!res)
00253 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00254 ast_stopstream(chan);
00255 }
00256 num++;
00257 }
00258
00259 return res;
00260 }
00261
00262 int ast_say_digit_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
00263 {
00264 return ast_say_digit_str_full(chan, str, ints, lang, -1, -1);
00265 }
00266
00267 int ast_say_digits_full(struct ast_channel *chan, int num, const char *ints, const char *lang, int audiofd, int ctrlfd)
00268 {
00269 char fn2[256];
00270
00271 snprintf(fn2, sizeof(fn2), "%d", num);
00272 return ast_say_digit_str_full(chan, fn2, ints, lang, audiofd, ctrlfd);
00273 }
00274
00275 int ast_say_digits(struct ast_channel *chan, int num, const char *ints, const char *lang)
00276 {
00277 return ast_say_digits_full(chan, num, ints, lang, -1, -1);
00278 }
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338 static int ast_say_number_full_en(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00339 static int ast_say_number_full_cz(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00340 static int ast_say_number_full_da(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00341 static int ast_say_number_full_de(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00342 static int ast_say_number_full_en_GB(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00343 static int ast_say_number_full_es(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00344 static int ast_say_number_full_fr(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00345 static int ast_say_number_full_he(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00346 static int ast_say_number_full_it(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00347 static int ast_say_number_full_nl(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00348 static int ast_say_number_full_no(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00349 static int ast_say_number_full_pl(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00350 static int ast_say_number_full_pt(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00351 static int ast_say_number_full_se(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00352 static int ast_say_number_full_tw(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00353 static int ast_say_number_full_gr(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00354 static int ast_say_number_full_ru(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00355
00356
00357 static int ast_say_enumeration_full_en(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd);
00358 static int ast_say_enumeration_full_da(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00359 static int ast_say_enumeration_full_de(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd);
00360
00361
00362 static int ast_say_date_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00363 static int ast_say_date_da(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00364 static int ast_say_date_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00365 static int ast_say_date_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00366 static int ast_say_date_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00367 static int ast_say_date_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00368 static int ast_say_date_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00369
00370 static int ast_say_date_with_format_en(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00371 static int ast_say_date_with_format_da(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00372 static int ast_say_date_with_format_de(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00373 static int ast_say_date_with_format_es(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00374 static int ast_say_date_with_format_he(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00375 static int ast_say_date_with_format_fr(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00376 static int ast_say_date_with_format_it(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00377 static int ast_say_date_with_format_nl(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00378 static int ast_say_date_with_format_pt(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00379 static int ast_say_date_with_format_tw(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00380 static int ast_say_date_with_format_gr(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone);
00381
00382 static int ast_say_time_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00383 static int ast_say_time_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00384 static int ast_say_time_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00385 static int ast_say_time_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00386 static int ast_say_time_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00387 static int ast_say_time_pt_BR(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00388 static int ast_say_time_tw(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00389 static int ast_say_time_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00390
00391 static int ast_say_datetime_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00392 static int ast_say_datetime_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00393 static int ast_say_datetime_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00394 static int ast_say_datetime_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00395 static int ast_say_datetime_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00396 static int ast_say_datetime_pt_BR(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00397 static int ast_say_datetime_tw(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00398 static int ast_say_datetime_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00399
00400 static int ast_say_datetime_from_now_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00401 static int ast_say_datetime_from_now_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00402 static int ast_say_datetime_from_now_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang);
00403
00404 static int wait_file(struct ast_channel *chan, const char *ints, const char *file, const char *lang)
00405 {
00406 int res;
00407 if ((res = ast_streamfile(chan, file, lang)))
00408 ast_log(LOG_WARNING, "Unable to play message %s\n", file);
00409 if (!res)
00410 res = ast_waitstream(chan, ints);
00411 return res;
00412 }
00413
00414
00415
00416 int ast_say_number_full(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
00417 {
00418 if (!strcasecmp(language,"en") ) {
00419 return(ast_say_number_full_en(chan, num, ints, language, audiofd, ctrlfd));
00420 } else if (!strcasecmp(language, "cz") ) {
00421 return(ast_say_number_full_cz(chan, num, ints, language, options, audiofd, ctrlfd));
00422 } else if (!strcasecmp(language, "da") ) {
00423 return(ast_say_number_full_da(chan, num, ints, language, options, audiofd, ctrlfd));
00424 } else if (!strcasecmp(language, "de") ) {
00425 return(ast_say_number_full_de(chan, num, ints, language, options, audiofd, ctrlfd));
00426 } else if (!strcasecmp(language, "en_GB") ) {
00427 return(ast_say_number_full_en_GB(chan, num, ints, language, audiofd, ctrlfd));
00428 } else if (!strcasecmp(language, "no") ) {
00429 return(ast_say_number_full_no(chan, num, ints, language, options, audiofd, ctrlfd));
00430 } else if (!strcasecmp(language, "es") || !strcasecmp(language, "mx")) {
00431 return(ast_say_number_full_es(chan, num, ints, language, options, audiofd, ctrlfd));
00432 } else if (!strcasecmp(language, "fr") ) {
00433 return(ast_say_number_full_fr(chan, num, ints, language, options, audiofd, ctrlfd));
00434 } else if (!strcasecmp(language, "he") ) {
00435 return(ast_say_number_full_he(chan, num, ints, language, options, audiofd, ctrlfd));
00436 } else if (!strcasecmp(language, "it") ) {
00437 return(ast_say_number_full_it(chan, num, ints, language, audiofd, ctrlfd));
00438 } else if (!strcasecmp(language, "nl") ) {
00439 return(ast_say_number_full_nl(chan, num, ints, language, audiofd, ctrlfd));
00440 } else if (!strcasecmp(language, "pl") ) {
00441 return(ast_say_number_full_pl(chan, num, ints, language, options, audiofd, ctrlfd));
00442 } else if (!strcasecmp(language, "pt") || !strcasecmp(language, "pt_BR")) {
00443 return(ast_say_number_full_pt(chan, num, ints, language, options, audiofd, ctrlfd));
00444 } else if (!strcasecmp(language, "se") ) {
00445 return(ast_say_number_full_se(chan, num, ints, language, options, audiofd, ctrlfd));
00446 } else if (!strcasecmp(language, "tw")) {
00447 return(ast_say_number_full_tw(chan, num, ints, language, audiofd, ctrlfd));
00448 } else if (!strcasecmp(language, "gr") ) {
00449 return(ast_say_number_full_gr(chan, num, ints, language, audiofd, ctrlfd));
00450 } else if (!strcasecmp(language, "ru") ) {
00451 return(ast_say_number_full_ru(chan, num, ints, language, options, audiofd, ctrlfd));
00452 }
00453
00454
00455 return(ast_say_number_full_en(chan, num, ints, language, audiofd, ctrlfd));
00456 }
00457
00458
00459 int ast_say_number(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options)
00460 {
00461 return(ast_say_number_full(chan, num, ints, language, options, -1, -1));
00462 }
00463
00464
00465
00466 static int ast_say_number_full_en(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
00467 {
00468 int res = 0;
00469 int playh = 0;
00470 char fn[256] = "";
00471 if (!num)
00472 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00473
00474 while(!res && (num || playh)) {
00475 if (num < 0) {
00476 snprintf(fn, sizeof(fn), "digits/minus");
00477 if ( num > INT_MIN ) {
00478 num = -num;
00479 } else {
00480 num = 0;
00481 }
00482 } else if (playh) {
00483 snprintf(fn, sizeof(fn), "digits/hundred");
00484 playh = 0;
00485 } else if (num < 20) {
00486 snprintf(fn, sizeof(fn), "digits/%d", num);
00487 num = 0;
00488 } else if (num < 100) {
00489 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
00490 num -= ((num / 10) * 10);
00491 } else {
00492 if (num < 1000){
00493 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
00494 playh++;
00495 num -= ((num / 100) * 100);
00496 } else {
00497 if (num < 1000000) {
00498 res = ast_say_number_full_en(chan, num / 1000, ints, language, audiofd, ctrlfd);
00499 if (res)
00500 return res;
00501 num = num % 1000;
00502 snprintf(fn, sizeof(fn), "digits/thousand");
00503 } else {
00504 if (num < 1000000000) {
00505 res = ast_say_number_full_en(chan, num / 1000000, ints, language, audiofd, ctrlfd);
00506 if (res)
00507 return res;
00508 num = num % 1000000;
00509 snprintf(fn, sizeof(fn), "digits/million");
00510 } else {
00511 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
00512 res = -1;
00513 }
00514 }
00515 }
00516 }
00517 if (!res) {
00518 if(!ast_streamfile(chan, fn, language)) {
00519 if ((audiofd > -1) && (ctrlfd > -1))
00520 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00521 else
00522 res = ast_waitstream(chan, ints);
00523 }
00524 ast_stopstream(chan);
00525 }
00526 }
00527 return res;
00528 }
00529
00530 static int exp10_int(int power)
00531 {
00532 int x, res= 1;
00533 for (x=0;x<power;x++)
00534 res *= 10;
00535 return res;
00536 }
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559 static int ast_say_number_full_cz(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
00560 {
00561 int res = 0;
00562 int playh = 0;
00563 char fn[256] = "";
00564
00565 int hundered = 0;
00566 int left = 0;
00567 int length = 0;
00568
00569
00570 if (!options)
00571 options = "w";
00572
00573 if (!num)
00574 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00575
00576 while(!res && (num || playh)) {
00577 if (num < 0) {
00578 snprintf(fn, sizeof(fn), "digits/minus");
00579 if ( num > INT_MIN ) {
00580 num = -num;
00581 } else {
00582 num = 0;
00583 }
00584 } else if (num < 3 ) {
00585 snprintf(fn, sizeof(fn), "digits/%d%c",num,options[0]);
00586 playh = 0;
00587 num = 0;
00588 } else if (num < 20) {
00589 snprintf(fn, sizeof(fn), "digits/%d",num);
00590 playh = 0;
00591 num = 0;
00592 } else if (num < 100) {
00593 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
00594 num -= ((num / 10) * 10);
00595 } else if (num < 1000) {
00596 hundered = num / 100;
00597 if ( hundered == 1 ) {
00598 snprintf(fn, sizeof(fn), "digits/1sto");
00599 } else if ( hundered == 2 ) {
00600 snprintf(fn, sizeof(fn), "digits/2ste");
00601 } else {
00602 res = ast_say_number_full_cz(chan,hundered,ints,language,options,audiofd,ctrlfd);
00603 if (res)
00604 return res;
00605 if (hundered == 3 || hundered == 4) {
00606 snprintf(fn, sizeof(fn), "digits/sta");
00607 } else if ( hundered > 4 ) {
00608 snprintf(fn, sizeof(fn), "digits/set");
00609 }
00610 }
00611 num -= (hundered * 100);
00612 } else {
00613 length = (int)log10(num)+1;
00614 while ( (length % 3 ) != 1 ) {
00615 length--;
00616 }
00617 left = num / (exp10_int(length-1));
00618 if ( left == 2 ) {
00619 switch (length-1) {
00620 case 9: options = "w";
00621 break;
00622 default : options = "m";
00623 }
00624 }
00625 if ( left > 1 ) {
00626 res = ast_say_number_full_cz(chan,left,ints,language,options,audiofd,ctrlfd);
00627 if (res)
00628 return res;
00629 }
00630 if ( left >= 5 ) {
00631 snprintf(fn, sizeof(fn), "digits/5_E%d",length-1);
00632 } else if ( left >= 2 && left <= 4 ) {
00633 snprintf(fn, sizeof(fn), "digits/2-4_E%d",length-1);
00634 } else {
00635 snprintf(fn, sizeof(fn), "digits/1_E%d",length-1);
00636 }
00637 num -= left * (exp10_int(length-1));
00638 }
00639 if (!res) {
00640 if(!ast_streamfile(chan, fn, language)) {
00641 if ((audiofd > -1) && (ctrlfd > -1)) {
00642 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00643 } else {
00644 res = ast_waitstream(chan, ints);
00645 }
00646 }
00647 ast_stopstream(chan);
00648 }
00649 }
00650 return res;
00651 }
00652
00653
00654
00655
00656
00657 static int ast_say_number_full_da(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
00658 {
00659 int res = 0;
00660 int playh = 0;
00661 int playa = 0;
00662 int cn = 1;
00663 char fn[256] = "";
00664 if (!num)
00665 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00666
00667 if (options && !strncasecmp(options, "n",1)) cn = -1;
00668
00669 while(!res && (num || playh || playa )) {
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680 if (num < 0) {
00681 snprintf(fn, sizeof(fn), "digits/minus");
00682 if ( num > INT_MIN ) {
00683 num = -num;
00684 } else {
00685 num = 0;
00686 }
00687 } else if (playh) {
00688 snprintf(fn, sizeof(fn), "digits/hundred");
00689 playh = 0;
00690 } else if (playa) {
00691 snprintf(fn, sizeof(fn), "digits/and");
00692 playa = 0;
00693 } else if (num == 1 && cn == -1) {
00694 snprintf(fn, sizeof(fn), "digits/1N");
00695 num = 0;
00696 } else if (num < 20) {
00697 snprintf(fn, sizeof(fn), "digits/%d", num);
00698 num = 0;
00699 } else if (num < 100) {
00700 int ones = num % 10;
00701 if (ones) {
00702 snprintf(fn, sizeof(fn), "digits/%d-and", ones);
00703 num -= ones;
00704 } else {
00705 snprintf(fn, sizeof(fn), "digits/%d", num);
00706 num = 0;
00707 }
00708 } else {
00709 if (num < 1000) {
00710 int hundreds = num / 100;
00711 if (hundreds == 1)
00712 snprintf(fn, sizeof(fn), "digits/1N");
00713 else
00714 snprintf(fn, sizeof(fn), "digits/%d", (num / 100));
00715
00716 playh++;
00717 num -= 100 * hundreds;
00718 if (num)
00719 playa++;
00720
00721 } else {
00722 if (num < 1000000) {
00723 res = ast_say_number_full_da(chan, num / 1000, ints, language, "n", audiofd, ctrlfd);
00724 if (res)
00725 return res;
00726 num = num % 1000;
00727 snprintf(fn, sizeof(fn), "digits/thousand");
00728 } else {
00729 if (num < 1000000000) {
00730 int millions = num / 1000000;
00731 res = ast_say_number_full_da(chan, millions, ints, language, "c", audiofd, ctrlfd);
00732 if (res)
00733 return res;
00734 if (millions == 1)
00735 snprintf(fn, sizeof(fn), "digits/million");
00736 else
00737 snprintf(fn, sizeof(fn), "digits/millions");
00738 num = num % 1000000;
00739 } else {
00740 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
00741 res = -1;
00742 }
00743 }
00744 if (num && num < 100)
00745 playa++;
00746 }
00747 }
00748 if (!res) {
00749 if(!ast_streamfile(chan, fn, language)) {
00750 if ((audiofd > -1) && (ctrlfd > -1))
00751 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00752 else
00753 res = ast_waitstream(chan, ints);
00754 }
00755 ast_stopstream(chan);
00756 }
00757 }
00758 return res;
00759 }
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770 static int ast_say_number_full_de(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
00771 {
00772 int res = 0, t = 0;
00773 int mf = 1;
00774 char fn[256] = "";
00775 char fna[256] = "";
00776 if (!num)
00777 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00778
00779 if (options && (!strncasecmp(options, "f",1)))
00780 mf = -1;
00781
00782 while(!res && num) {
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793 if (num < 0) {
00794 snprintf(fn, sizeof(fn), "digits/minus");
00795 if ( num > INT_MIN ) {
00796 num = -num;
00797 } else {
00798 num = 0;
00799 }
00800 } else if (num < 100 && t) {
00801 snprintf(fn, sizeof(fn), "digits/and");
00802 t = 0;
00803 } else if (num == 1 && mf == -1) {
00804 snprintf(fn, sizeof(fn), "digits/%dF", num);
00805 num = 0;
00806 } else if (num < 20) {
00807 snprintf(fn, sizeof(fn), "digits/%d", num);
00808 num = 0;
00809 } else if (num < 100) {
00810 int ones = num % 10;
00811 if (ones) {
00812 snprintf(fn, sizeof(fn), "digits/%d-and", ones);
00813 num -= ones;
00814 } else {
00815 snprintf(fn, sizeof(fn), "digits/%d", num);
00816 num = 0;
00817 }
00818 } else if (num == 100 && t == 0) {
00819 snprintf(fn, sizeof(fn), "digits/hundred");
00820 num = 0;
00821 } else if (num < 1000) {
00822 int hundreds = num / 100;
00823 num = num % 100;
00824 if (hundreds == 1) {
00825 snprintf(fn, sizeof(fn), "digits/1N");
00826 } else {
00827 snprintf(fn, sizeof(fn), "digits/%d", hundreds);
00828 }
00829 snprintf(fna, sizeof(fna), "digits/hundred");
00830 t = 1;
00831 } else if (num == 1000 && t == 0) {
00832 snprintf(fn, sizeof(fn), "digits/thousand");
00833 num = 0;
00834 } else if (num < 1000000) {
00835 int thousands = num / 1000;
00836 num = num % 1000;
00837 t = 1;
00838 if (thousands == 1) {
00839 snprintf(fn, sizeof(fn), "digits/1N");
00840 snprintf(fna, sizeof(fna), "digits/thousand");
00841 } else {
00842 res = ast_say_number_full_de(chan, thousands, ints, language, options, audiofd, ctrlfd);
00843 if (res)
00844 return res;
00845 snprintf(fn, sizeof(fn), "digits/thousand");
00846 }
00847 } else if (num < 1000000000) {
00848 int millions = num / 1000000;
00849 num = num % 1000000;
00850 t = 1;
00851 if (millions == 1) {
00852 snprintf(fn, sizeof(fn), "digits/1F");
00853 snprintf(fna, sizeof(fna), "digits/million");
00854 } else {
00855 res = ast_say_number_full_de(chan, millions, ints, language, options, audiofd, ctrlfd);
00856 if (res)
00857 return res;
00858 snprintf(fn, sizeof(fn), "digits/millions");
00859 }
00860 } else if (num <= INT_MAX) {
00861 int billions = num / 1000000000;
00862 num = num % 1000000000;
00863 t = 1;
00864 if (billions == 1) {
00865 snprintf(fn, sizeof(fn), "digits/1F");
00866 snprintf(fna, sizeof(fna), "digits/milliard");
00867 } else {
00868 res = ast_say_number_full_de(chan, billions, ints, language, options, audiofd, ctrlfd);
00869 if (res) {
00870 return res;
00871 }
00872 snprintf(fn, sizeof(fn), "digits/milliards");
00873 }
00874 } else {
00875 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
00876 res = -1;
00877 }
00878 if (!res) {
00879 if(!ast_streamfile(chan, fn, language)) {
00880 if ((audiofd > -1) && (ctrlfd > -1))
00881 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00882 else
00883 res = ast_waitstream(chan, ints);
00884 }
00885 ast_stopstream(chan);
00886 if (!res) {
00887 if (strlen(fna) != 0 && !ast_streamfile(chan, fna, language)) {
00888 if ((audiofd > -1) && (ctrlfd > -1))
00889 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00890 else
00891 res = ast_waitstream(chan, ints);
00892 }
00893 ast_stopstream(chan);
00894 strcpy(fna, "");
00895 }
00896 }
00897 }
00898 return res;
00899 }
00900
00901
00902
00903
00904
00905 static int ast_say_number_full_en_GB(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
00906 {
00907 int res = 0;
00908 int playh = 0;
00909 int playa = 0;
00910 char fn[256] = "";
00911 if (!num)
00912 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00913
00914 while(!res && (num || playh || playa )) {
00915 if (num < 0) {
00916 snprintf(fn, sizeof(fn), "digits/minus");
00917 if ( num > INT_MIN ) {
00918 num = -num;
00919 } else {
00920 num = 0;
00921 }
00922 } else if (playh) {
00923 snprintf(fn, sizeof(fn), "digits/hundred");
00924 playh = 0;
00925 } else if (playa) {
00926 snprintf(fn, sizeof(fn), "digits/and");
00927 playa = 0;
00928 } else if (num < 20) {
00929 snprintf(fn, sizeof(fn), "digits/%d", num);
00930 num = 0;
00931 } else if (num < 100) {
00932 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
00933 num -= ((num / 10) * 10);
00934 } else if (num < 1000) {
00935 int hundreds = num / 100;
00936 snprintf(fn, sizeof(fn), "digits/%d", (num / 100));
00937
00938 playh++;
00939 num -= 100 * hundreds;
00940 if (num)
00941 playa++;
00942 } else if (num < 1000000) {
00943 res = ast_say_number_full_en_GB(chan, num / 1000, ints, language, audiofd, ctrlfd);
00944 if (res)
00945 return res;
00946 snprintf(fn, sizeof(fn), "digits/thousand");
00947 num = num % 1000;
00948 if (num && num < 100)
00949 playa++;
00950 } else if (num < 1000000000) {
00951 int millions = num / 1000000;
00952 res = ast_say_number_full_en_GB(chan, millions, ints, language, audiofd, ctrlfd);
00953 if (res)
00954 return res;
00955 snprintf(fn, sizeof(fn), "digits/million");
00956 num = num % 1000000;
00957 if (num && num < 100)
00958 playa++;
00959 } else {
00960 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
00961 res = -1;
00962 }
00963
00964 if (!res) {
00965 if(!ast_streamfile(chan, fn, language)) {
00966 if ((audiofd > -1) && (ctrlfd > -1))
00967 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
00968 else
00969 res = ast_waitstream(chan, ints);
00970 }
00971 ast_stopstream(chan);
00972 }
00973 }
00974 return res;
00975 }
00976
00977
00978
00979
00980
00981
00982
00983 static int ast_say_number_full_es(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
00984 {
00985 int res = 0;
00986 int playa = 0;
00987 int mf = 0;
00988 char fn[256] = "";
00989 if (!num)
00990 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
00991
00992 if (options) {
00993 if (!strncasecmp(options, "f",1))
00994 mf = -1;
00995 else if (!strncasecmp(options, "m", 1))
00996 mf = 1;
00997 }
00998
00999 while (!res && num) {
01000 if (num < 0) {
01001 snprintf(fn, sizeof(fn), "digits/minus");
01002 if ( num > INT_MIN ) {
01003 num = -num;
01004 } else {
01005 num = 0;
01006 }
01007 } else if (playa) {
01008 snprintf(fn, sizeof(fn), "digits/and");
01009 playa = 0;
01010 } else if (num == 1) {
01011 if (mf < 0)
01012 snprintf(fn, sizeof(fn), "digits/%dF", num);
01013 else if (mf > 0)
01014 snprintf(fn, sizeof(fn), "digits/%dM", num);
01015 else
01016 snprintf(fn, sizeof(fn), "digits/%d", num);
01017 num = 0;
01018 } else if (num < 31) {
01019 snprintf(fn, sizeof(fn), "digits/%d", num);
01020 num = 0;
01021 } else if (num < 100) {
01022 snprintf(fn, sizeof(fn), "digits/%d", (num/10)*10);
01023 num -= ((num/10)*10);
01024 if (num)
01025 playa++;
01026 } else if (num == 100) {
01027 snprintf(fn, sizeof(fn), "digits/100");
01028 num = 0;
01029 } else if (num < 200) {
01030 snprintf(fn, sizeof(fn), "digits/100-and");
01031 num -= 100;
01032 } else {
01033 if (num < 1000) {
01034 snprintf(fn, sizeof(fn), "digits/%d", (num/100)*100);
01035 num -= ((num/100)*100);
01036 } else if (num < 2000) {
01037 num = num % 1000;
01038 snprintf(fn, sizeof(fn), "digits/thousand");
01039 } else {
01040 if (num < 1000000) {
01041 res = ast_say_number_full_es(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
01042 if (res)
01043 return res;
01044 num = num % 1000;
01045 snprintf(fn, sizeof(fn), "digits/thousand");
01046 } else {
01047 if (num < 2147483640) {
01048 if ((num/1000000) == 1) {
01049 res = ast_say_number_full_es(chan, num / 1000000, ints, language, "M", audiofd, ctrlfd);
01050 if (res)
01051 return res;
01052 snprintf(fn, sizeof(fn), "digits/million");
01053 } else {
01054 res = ast_say_number_full_es(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
01055 if (res)
01056 return res;
01057 snprintf(fn, sizeof(fn), "digits/millions");
01058 }
01059 num = num % 1000000;
01060 } else {
01061 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01062 res = -1;
01063 }
01064 }
01065 }
01066 }
01067
01068 if (!res) {
01069 if(!ast_streamfile(chan, fn, language)) {
01070 if ((audiofd > -1) && (ctrlfd > -1))
01071 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01072 else
01073 res = ast_waitstream(chan, ints);
01074 }
01075 ast_stopstream(chan);
01076
01077 }
01078
01079 }
01080 return res;
01081 }
01082
01083
01084
01085
01086
01087 static int ast_say_number_full_fr(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
01088 {
01089 int res = 0;
01090 int playh = 0;
01091 int playa = 0;
01092 int mf = 1;
01093 char fn[256] = "";
01094 if (!num)
01095 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01096
01097 if (options && !strncasecmp(options, "f",1))
01098 mf = -1;
01099
01100 while(!res && (num || playh || playa)) {
01101 if (num < 0) {
01102 snprintf(fn, sizeof(fn), "digits/minus");
01103 if ( num > INT_MIN ) {
01104 num = -num;
01105 } else {
01106 num = 0;
01107 }
01108 } else if (playh) {
01109 snprintf(fn, sizeof(fn), "digits/hundred");
01110 playh = 0;
01111 } else if (playa) {
01112 snprintf(fn, sizeof(fn), "digits/et");
01113 playa = 0;
01114 } else if (num == 1) {
01115 if (mf < 0)
01116 snprintf(fn, sizeof(fn), "digits/%dF", num);
01117 else
01118 snprintf(fn, sizeof(fn), "digits/%d", num);
01119 num = 0;
01120 } else if (num < 21) {
01121 snprintf(fn, sizeof(fn), "digits/%d", num);
01122 num = 0;
01123 } else if (num < 70) {
01124 snprintf(fn, sizeof(fn), "digits/%d", (num/10)*10);
01125 if ((num % 10) == 1) playa++;
01126 num = num % 10;
01127 } else if (num < 80) {
01128 snprintf(fn, sizeof(fn), "digits/60");
01129 if ((num % 10) == 1) playa++;
01130 num = num - 60;
01131 } else if (num < 100) {
01132 snprintf(fn, sizeof(fn), "digits/80");
01133 num = num - 80;
01134 } else if (num < 200) {
01135 snprintf(fn, sizeof(fn), "digits/hundred");
01136 num = num - 100;
01137 } else if (num < 1000) {
01138 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
01139 playh++;
01140 num = num % 100;
01141 } else if (num < 2000) {
01142 snprintf(fn, sizeof(fn), "digits/thousand");
01143 num = num - 1000;
01144 } else if (num < 1000000) {
01145 res = ast_say_number_full_fr(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
01146 if (res)
01147 return res;
01148 snprintf(fn, sizeof(fn), "digits/thousand");
01149 num = num % 1000;
01150 } else if (num < 1000000000) {
01151 res = ast_say_number_full_fr(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
01152 if (res)
01153 return res;
01154 snprintf(fn, sizeof(fn), "digits/million");
01155 num = num % 1000000;
01156 } else {
01157 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01158 res = -1;
01159 }
01160 if (!res) {
01161 if(!ast_streamfile(chan, fn, language)) {
01162 if ((audiofd > -1) && (ctrlfd > -1))
01163 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01164 else
01165 res = ast_waitstream(chan, ints);
01166 }
01167 ast_stopstream(chan);
01168 }
01169 }
01170 return res;
01171 }
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218 #define SAY_NUM_BUF_SIZE 256
01219 static int ast_say_number_full_he(struct ast_channel *chan, int num,
01220 const char *ints, const char *language, const char *options,
01221 int audiofd, int ctrlfd)
01222 {
01223 int res = 0;
01224 int state = 0;
01225 int mf = 1;
01226 char fn[SAY_NUM_BUF_SIZE] = "";
01227 ast_verbose(VERBOSE_PREFIX_3 "ast_say_digits_full: started. "
01228 "num: %d, options=\"%s\"\n",
01229 num, options
01230 );
01231 if (!num)
01232 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01233
01234 if (options && !strncasecmp(options, "f",1))
01235 mf = -1;
01236
01237
01238 while(!res && (num || (state>0) )) {
01239
01240
01241
01242
01243
01244
01245
01246 ast_verbose(VERBOSE_PREFIX_3 "ast_say_digits_full: num: %d, "
01247 "state=%d, options=\"%s\", mf=%d\n",
01248 num, state, options, mf
01249 );
01250 if (state==1) {
01251 snprintf(fn, sizeof(fn), "digits/hundred");
01252 state = 0;
01253 } else if (state==2) {
01254 snprintf(fn, sizeof(fn), "digits/ve");
01255 state = 0;
01256 } else if (state==3) {
01257 snprintf(fn, sizeof(fn), "digits/thousands");
01258 state=0;
01259 } else if (num <21) {
01260 if (mf < 0)
01261 snprintf(fn, sizeof(fn), "digits/%dF", num);
01262 else
01263 snprintf(fn, sizeof(fn), "digits/%d", num);
01264 num = 0;
01265 } else if (num < 100) {
01266 snprintf(fn, sizeof(fn), "digits/%d", (num/10)*10);
01267 num = num % 10;
01268 if (num>0) state=2;
01269 } else if (num < 200) {
01270 snprintf(fn, sizeof(fn), "digits/hundred");
01271 num = num - 100;
01272 } else if (num < 300) {
01273 snprintf(fn, sizeof(fn), "digits/hundred");
01274 num = num - 100;
01275 } else if (num < 1000) {
01276 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
01277 state=1;
01278 num = num % 100;
01279 } else if (num < 2000) {
01280 snprintf(fn, sizeof(fn), "digits/thousand");
01281 num = num - 1000;
01282 } else if (num < 3000) {
01283 snprintf(fn, sizeof(fn), "digits/2thousand");
01284 num = num - 2000;
01285 if (num>0) state=2;
01286 } else if (num < 20000) {
01287 snprintf(fn, sizeof(fn), "digits/%ds",(num/1000));
01288 num = num % 1000;
01289 state=3;
01290 } else if (num < 1000000) {
01291 res = ast_say_number_full_he(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
01292 if (res)
01293 return res;
01294 snprintf(fn, sizeof(fn), "digits/thousand");
01295 num = num % 1000;
01296 } else if (num < 1000000000) {
01297 res = ast_say_number_full_he(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
01298 if (res)
01299 return res;
01300 snprintf(fn, sizeof(fn), "digits/million");
01301 num = num % 1000000;
01302 } else {
01303 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01304 res = -1;
01305 }
01306 if (!res) {
01307 if(!ast_streamfile(chan, fn, language)) {
01308 if ((audiofd > -1) && (ctrlfd > -1))
01309 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01310 else
01311 res = ast_waitstream(chan, ints);
01312 }
01313 ast_stopstream(chan);
01314 }
01315 }
01316 return res;
01317 }
01318
01319
01320 static int ast_say_number_full_it(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
01321 {
01322 int res = 0;
01323 int playh = 0;
01324 int tempnum = 0;
01325 char fn[256] = "";
01326
01327 if (!num)
01328 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
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 while(!res && (num || playh)) {
01355 if (num < 0) {
01356 snprintf(fn, sizeof(fn), "digits/minus");
01357 if ( num > INT_MIN ) {
01358 num = -num;
01359 } else {
01360 num = 0;
01361 }
01362 } else if (playh) {
01363 snprintf(fn, sizeof(fn), "digits/hundred");
01364 playh = 0;
01365 } else if (num < 20) {
01366 snprintf(fn, sizeof(fn), "digits/%d", num);
01367 num = 0;
01368 } else if (num == 21) {
01369 snprintf(fn, sizeof(fn), "digits/%d", num);
01370 num = 0;
01371 } else if (num == 28) {
01372 snprintf(fn, sizeof(fn), "digits/%d", num);
01373 num = 0;
01374 } else if (num == 31) {
01375 snprintf(fn, sizeof(fn), "digits/%d", num);
01376 num = 0;
01377 } else if (num == 38) {
01378 snprintf(fn, sizeof(fn), "digits/%d", num);
01379 num = 0;
01380 } else if (num == 41) {
01381 snprintf(fn, sizeof(fn), "digits/%d", num);
01382 num = 0;
01383 } else if (num == 48) {
01384 snprintf(fn, sizeof(fn), "digits/%d", num);
01385 num = 0;
01386 } else if (num == 51) {
01387 snprintf(fn, sizeof(fn), "digits/%d", num);
01388 num = 0;
01389 } else if (num == 58) {
01390 snprintf(fn, sizeof(fn), "digits/%d", num);
01391 num = 0;
01392 } else if (num == 61) {
01393 snprintf(fn, sizeof(fn), "digits/%d", num);
01394 num = 0;
01395 } else if (num == 68) {
01396 snprintf(fn, sizeof(fn), "digits/%d", num);
01397 num = 0;
01398 } else if (num == 71) {
01399 snprintf(fn, sizeof(fn), "digits/%d", num);
01400 num = 0;
01401 } else if (num == 78) {
01402 snprintf(fn, sizeof(fn), "digits/%d", num);
01403 num = 0;
01404 } else if (num == 81) {
01405 snprintf(fn, sizeof(fn), "digits/%d", num);
01406 num = 0;
01407 } else if (num == 88) {
01408 snprintf(fn, sizeof(fn), "digits/%d", num);
01409 num = 0;
01410 } else if (num == 91) {
01411 snprintf(fn, sizeof(fn), "digits/%d", num);
01412 num = 0;
01413 } else if (num == 98) {
01414 snprintf(fn, sizeof(fn), "digits/%d", num);
01415 num = 0;
01416 } else if (num < 100) {
01417 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
01418 num -= ((num / 10) * 10);
01419 } else {
01420 if (num < 1000) {
01421 if ((num / 100) > 1) {
01422 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
01423 playh++;
01424 } else {
01425 snprintf(fn, sizeof(fn), "digits/hundred");
01426 }
01427 num -= ((num / 100) * 100);
01428 } else {
01429 if (num < 1000000) {
01430 if ((num/1000) > 1)
01431 res = ast_say_number_full_it(chan, num / 1000, ints, language, audiofd, ctrlfd);
01432 if (res)
01433 return res;
01434 tempnum = num;
01435 num = num % 1000;
01436 if ((tempnum / 1000) < 2)
01437 snprintf(fn, sizeof(fn), "digits/thousand");
01438 else
01439 snprintf(fn, sizeof(fn), "digits/thousands");
01440 } else {
01441 if (num < 1000000000) {
01442 if ((num / 1000000) > 1)
01443 res = ast_say_number_full_it(chan, num / 1000000, ints, language, audiofd, ctrlfd);
01444 if (res)
01445 return res;
01446 tempnum = num;
01447 num = num % 1000000;
01448 if ((tempnum / 1000000) < 2)
01449 snprintf(fn, sizeof(fn), "digits/million");
01450 else
01451 snprintf(fn, sizeof(fn), "digits/millions");
01452 } else {
01453 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01454 res = -1;
01455 }
01456 }
01457 }
01458 }
01459 if (!res) {
01460 if(!ast_streamfile(chan, fn, language)) {
01461 if ((audiofd > -1) && (ctrlfd > -1))
01462 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01463 else
01464 res = ast_waitstream(chan, ints);
01465 }
01466 ast_stopstream(chan);
01467 }
01468 }
01469 return res;
01470 }
01471
01472
01473
01474
01475 static int ast_say_number_full_nl(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
01476 {
01477 int res = 0;
01478 int playh = 0;
01479 int units = 0;
01480 char fn[256] = "";
01481 if (!num)
01482 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01483 while (!res && (num || playh )) {
01484 if (num < 0) {
01485 snprintf(fn, sizeof(fn), "digits/minus");
01486 if ( num > INT_MIN ) {
01487 num = -num;
01488 } else {
01489 num = 0;
01490 }
01491 } else if (playh) {
01492 snprintf(fn, sizeof(fn), "digits/hundred");
01493 playh = 0;
01494 } else if (num < 20) {
01495 snprintf(fn, sizeof(fn), "digits/%d", num);
01496 num = 0;
01497 } else if (num < 100) {
01498 units = num % 10;
01499 if (units > 0) {
01500 res = ast_say_number_full_nl(chan, units, ints, language, audiofd, ctrlfd);
01501 if (res)
01502 return res;
01503 num = num - units;
01504 snprintf(fn, sizeof(fn), "digits/nl-en");
01505 } else {
01506 snprintf(fn, sizeof(fn), "digits/%d", num - units);
01507 num = 0;
01508 }
01509 } else {
01510 if (num < 1000) {
01511 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
01512 playh++;
01513 num -= ((num / 100) * 100);
01514 } else {
01515 if (num < 1000000) {
01516 res = ast_say_number_full_en(chan, num / 1000, ints, language, audiofd, ctrlfd);
01517 if (res)
01518 return res;
01519 num = num % 1000;
01520 snprintf(fn, sizeof(fn), "digits/thousand");
01521 } else {
01522 if (num < 1000000000) {
01523 res = ast_say_number_full_en(chan, num / 1000000, ints, language, audiofd, ctrlfd);
01524 if (res)
01525 return res;
01526 num = num % 1000000;
01527 snprintf(fn, sizeof(fn), "digits/million");
01528 } else {
01529 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01530 res = -1;
01531 }
01532 }
01533 }
01534 }
01535
01536 if (!res) {
01537 if(!ast_streamfile(chan, fn, language)) {
01538 if ((audiofd > -1) && (ctrlfd > -1))
01539 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01540 else
01541 res = ast_waitstream(chan, ints);
01542 }
01543 ast_stopstream(chan);
01544 }
01545 }
01546 return res;
01547 }
01548
01549
01550
01551
01552
01553 static int ast_say_number_full_no(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
01554 {
01555 int res = 0;
01556 int playh = 0;
01557 int playa = 0;
01558 int cn = 1;
01559 char fn[256] = "";
01560
01561 if (!num)
01562 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01563
01564 if (options && !strncasecmp(options, "n",1)) cn = -1;
01565
01566 while(!res && (num || playh || playa )) {
01567
01568
01569
01570
01571
01572
01573 if (num < 0) {
01574 snprintf(fn, sizeof(fn), "digits/minus");
01575 if ( num > INT_MIN ) {
01576 num = -num;
01577 } else {
01578 num = 0;
01579 }
01580 } else if (playh) {
01581 snprintf(fn, sizeof(fn), "digits/hundred");
01582 playh = 0;
01583 } else if (playa) {
01584 snprintf(fn, sizeof(fn), "digits/and");
01585 playa = 0;
01586 } else if (num == 1 && cn == -1) {
01587 snprintf(fn, sizeof(fn), "digits/1N");
01588 num = 0;
01589 } else if (num < 20) {
01590 snprintf(fn, sizeof(fn), "digits/%d", num);
01591 num = 0;
01592 } else if (num < 100) {
01593 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
01594 num -= ((num / 10) * 10);
01595 } else if (num < 1000) {
01596 int hundreds = num / 100;
01597 if (hundreds == 1)
01598 snprintf(fn, sizeof(fn), "digits/1N");
01599 else
01600 snprintf(fn, sizeof(fn), "digits/%d", (num / 100));
01601
01602 playh++;
01603 num -= 100 * hundreds;
01604 if (num)
01605 playa++;
01606 } else if (num < 1000000) {
01607 res = ast_say_number_full_no(chan, num / 1000, ints, language, "n", audiofd, ctrlfd);
01608 if (res)
01609 return res;
01610 snprintf(fn, sizeof(fn), "digits/thousand");
01611 num = num % 1000;
01612 if (num && num < 100)
01613 playa++;
01614 } else if (num < 1000000000) {
01615 int millions = num / 1000000;
01616 res = ast_say_number_full_no(chan, millions, ints, language, "c", audiofd, ctrlfd);
01617 if (res)
01618 return res;
01619 snprintf(fn, sizeof(fn), "digits/million");
01620 num = num % 1000000;
01621 if (num && num < 100)
01622 playa++;
01623 } else {
01624 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
01625 res = -1;
01626 }
01627
01628 if (!res) {
01629 if(!ast_streamfile(chan, fn, language)) {
01630 if ((audiofd > -1) && (ctrlfd > -1))
01631 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01632 else
01633 res = ast_waitstream(chan, ints);
01634 }
01635 ast_stopstream(chan);
01636 }
01637 }
01638 return res;
01639 }
01640
01641 typedef struct {
01642 char *separator_dziesiatek;
01643 char *cyfry[10];
01644 char *cyfry2[10];
01645 char *setki[10];
01646 char *dziesiatki[10];
01647 char *nastki[10];
01648 char *rzedy[3][3];
01649 } odmiana;
01650
01651 static char *pl_rzad_na_tekst(odmiana *odm, int i, int rzad)
01652 {
01653 if (rzad==0)
01654 return "";
01655
01656 if (i==1)
01657 return odm->rzedy[rzad - 1][0];
01658 if ((i > 21 || i < 11) && i%10 > 1 && i%10 < 5)
01659 return odm->rzedy[rzad - 1][1];
01660 else
01661 return odm->rzedy[rzad - 1][2];
01662 }
01663
01664 static char* pl_append(char* buffer, char* str)
01665 {
01666 strcpy(buffer, str);
01667 buffer += strlen(str);
01668 return buffer;
01669 }
01670
01671 static void pl_odtworz_plik(struct ast_channel *chan, const char *language, int audiofd, int ctrlfd, const char *ints, char *fn)
01672 {
01673 char file_name[255] = "digits/";
01674 strcat(file_name, fn);
01675 ast_log(LOG_DEBUG, "Trying to play: %s\n", file_name);
01676 if (!ast_streamfile(chan, file_name, language)) {
01677 if ((audiofd > -1) && (ctrlfd > -1))
01678 ast_waitstream_full(chan, ints, audiofd, ctrlfd);
01679 else
01680 ast_waitstream(chan, ints);
01681 }
01682 ast_stopstream(chan);
01683 }
01684
01685 static void powiedz(struct ast_channel *chan, const char *language, int audiofd, int ctrlfd, const char *ints, odmiana *odm, int rzad, int i)
01686 {
01687
01688 int m1000E6 = 0;
01689 int i1000E6 = 0;
01690 int m1000E3 = 0;
01691 int i1000E3 = 0;
01692 int m1000 = 0;
01693 int i1000 = 0;
01694 int m100 = 0;
01695 int i100 = 0;
01696
01697 if (i == 0 && rzad > 0) {
01698 return;
01699 }
01700 if (i == 0) {
01701 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->cyfry[0]);
01702 }
01703
01704 m1000E6 = i % 1000000000;
01705 i1000E6 = i / 1000000000;
01706
01707 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+3, i1000E6);
01708
01709 m1000E3 = m1000E6 % 1000000;
01710 i1000E3 = m1000E6 / 1000000;
01711
01712 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+2, i1000E3);
01713
01714 m1000 = m1000E3 % 1000;
01715 i1000 = m1000E3 / 1000;
01716
01717 powiedz(chan, language, audiofd, ctrlfd, ints, odm, rzad+1, i1000);
01718
01719 m100 = m1000 % 100;
01720 i100 = m1000 / 100;
01721
01722 if (i100>0)
01723 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->setki[i100]);
01724
01725 if ( m100 > 0 && m100 <=9 ) {
01726 if (m1000>0)
01727 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->cyfry2[m100]);
01728 else
01729 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->cyfry[m100]);
01730 } else if (m100 % 10 == 0) {
01731 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->dziesiatki[m100 / 10]);
01732 } else if (m100 <= 19 ) {
01733 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->nastki[m100 % 10]);
01734 } else if (m100 != 0) {
01735 if (odm->separator_dziesiatek[0]==' ') {
01736 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->dziesiatki[m100 / 10]);
01737 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, odm->cyfry2[m100 % 10]);
01738 } else {
01739 char buf[10];
01740 char *b = buf;
01741 b = pl_append(b, odm->dziesiatki[m100 / 10]);
01742 b = pl_append(b, odm->separator_dziesiatek);
01743 b = pl_append(b, odm->cyfry2[m100 % 10]);
01744 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, buf);
01745 }
01746 }
01747
01748 if (rzad > 0) {
01749 pl_odtworz_plik(chan, language, audiofd, ctrlfd, ints, pl_rzad_na_tekst(odm, i, rzad));
01750 }
01751 }
01752
01753
01754 static int ast_say_number_full_pl(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846 {
01847 char *zenski_cyfry[] = {"0","1z", "2z", "3", "4", "5", "6", "7", "8", "9"};
01848
01849 char *zenski_cyfry2[] = {"0","1", "2z", "3", "4", "5", "6", "7", "8", "9"};
01850
01851 char *meski_cyfry[] = {"0","1", "2-1m", "3-1m", "4-1m", "5m", "6m", "7m", "8m", "9m"};
01852
01853 char *meski_cyfry2[] = {"0","1", "2-2m", "3-2m", "4-2m", "5m", "6m", "7m", "8m", "9m"};
01854
01855 char *meski_setki[] = {"", "100m", "200m", "300m", "400m", "500m", "600m", "700m", "800m", "900m"};
01856
01857 char *meski_dziesiatki[] = {"", "10m", "20m", "30m", "40m", "50m", "60m", "70m", "80m", "90m"};
01858
01859 char *meski_nastki[] = {"", "11m", "12m", "13m", "14m", "15m", "16m", "17m", "18m", "19m"};
01860
01861 char *nijaki_cyfry[] = {"0","1", "2", "3", "4", "5", "6", "7", "8", "9"};
01862
01863 char *nijaki_cyfry2[] = {"0","1", "2", "3", "4", "5", "6", "7", "8", "9"};
01864
01865 char *nijaki_setki[] = {"", "100", "200", "300", "400", "500", "600", "700", "800", "900"};
01866
01867 char *nijaki_dziesiatki[] = {"", "10", "20", "30", "40", "50", "60", "70", "80", "90"};
01868
01869 char *nijaki_nastki[] = {"", "11", "12", "13", "14", "15", "16", "17", "18", "19"};
01870
01871 char *rzedy[][3] = { {"1000", "1000.2", "1000.5"}, {"1000000", "1000000.2", "1000000.5"}, {"1000000000", "1000000000.2", "1000000000.5"}};
01872
01873
01874 odmiana *o;
01875
01876 static odmiana *odmiana_nieosobowa = NULL;
01877 static odmiana *odmiana_meska = NULL;
01878 static odmiana *odmiana_zenska = NULL;
01879
01880 if (odmiana_nieosobowa == NULL) {
01881 odmiana_nieosobowa = (odmiana *) malloc(sizeof(odmiana));
01882
01883 odmiana_nieosobowa->separator_dziesiatek = "_";
01884
01885 memcpy(odmiana_nieosobowa->cyfry, nijaki_cyfry, sizeof(odmiana_nieosobowa->cyfry));
01886 memcpy(odmiana_nieosobowa->cyfry2, nijaki_cyfry2, sizeof(odmiana_nieosobowa->cyfry));
01887 memcpy(odmiana_nieosobowa->setki, nijaki_setki, sizeof(odmiana_nieosobowa->setki));
01888 memcpy(odmiana_nieosobowa->dziesiatki, nijaki_dziesiatki, sizeof(odmiana_nieosobowa->dziesiatki));
01889 memcpy(odmiana_nieosobowa->nastki, nijaki_nastki, sizeof(odmiana_nieosobowa->nastki));
01890 memcpy(odmiana_nieosobowa->rzedy, rzedy, sizeof(odmiana_nieosobowa->rzedy));
01891 }
01892
01893 if (odmiana_zenska == NULL) {
01894 odmiana_zenska = (odmiana *) malloc(sizeof(odmiana));
01895
01896 odmiana_zenska->separator_dziesiatek = " ";
01897
01898 memcpy(odmiana_zenska->cyfry, zenski_cyfry, sizeof(odmiana_zenska->cyfry));
01899 memcpy(odmiana_zenska->cyfry2, zenski_cyfry2, sizeof(odmiana_zenska->cyfry));
01900 memcpy(odmiana_zenska->setki, nijaki_setki, sizeof(odmiana_zenska->setki));
01901 memcpy(odmiana_zenska->dziesiatki, nijaki_dziesiatki, sizeof(odmiana_zenska->dziesiatki));
01902 memcpy(odmiana_zenska->nastki, nijaki_nastki, sizeof(odmiana_zenska->nastki));
01903 memcpy(odmiana_zenska->rzedy, rzedy, sizeof(odmiana_zenska->rzedy));
01904 }
01905
01906 if (odmiana_meska == NULL) {
01907 odmiana_meska = (odmiana *) malloc(sizeof(odmiana));
01908
01909 odmiana_meska->separator_dziesiatek = " ";
01910
01911 memcpy(odmiana_meska->cyfry, meski_cyfry, sizeof(odmiana_meska->cyfry));
01912 memcpy(odmiana_meska->cyfry2, meski_cyfry2, sizeof(odmiana_meska->cyfry));
01913 memcpy(odmiana_meska->setki, meski_setki, sizeof(odmiana_meska->setki));
01914 memcpy(odmiana_meska->dziesiatki, meski_dziesiatki, sizeof(odmiana_meska->dziesiatki));
01915 memcpy(odmiana_meska->nastki, meski_nastki, sizeof(odmiana_meska->nastki));
01916 memcpy(odmiana_meska->rzedy, rzedy, sizeof(odmiana_meska->rzedy));
01917 }
01918
01919 if (options) {
01920 if (strncasecmp(options, "f", 1) == 0)
01921 o = odmiana_zenska;
01922 else if (strncasecmp(options, "m", 1) == 0)
01923 o = odmiana_meska;
01924 else
01925 o = odmiana_nieosobowa;
01926 } else
01927 o = odmiana_nieosobowa;
01928
01929 powiedz(chan, language, audiofd, ctrlfd, ints, o, 0, num);
01930 return 0;
01931 }
01932
01933
01934
01935
01936
01937
01938
01939 static int ast_say_number_full_pt(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
01940 {
01941 int res = 0;
01942 int playh = 0;
01943 int mf = 1;
01944 char fn[256] = "";
01945
01946 if (!num)
01947 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
01948
01949 if (options && !strncasecmp(options, "f",1))
01950 mf = -1;
01951
01952 while(!res && num ) {
01953 if (num < 0) {
01954 snprintf(fn, sizeof(fn), "digits/minus");
01955 if ( num > INT_MIN ) {
01956 num = -num;
01957 } else {
01958 num = 0;
01959 }
01960 } else if (num < 20) {
01961 if ((num == 1 || num == 2) && (mf < 0))
01962 snprintf(fn, sizeof(fn), "digits/%dF", num);
01963 else
01964 snprintf(fn, sizeof(fn), "digits/%d", num);
01965 num = 0;
01966 } else if (num < 100) {
01967 snprintf(fn, sizeof(fn), "digits/%d", (num / 10) * 10);
01968 if (num % 10)
01969 playh = 1;
01970 num = num % 10;
01971 } else if (num < 1000) {
01972 if (num == 100)
01973 snprintf(fn, sizeof(fn), "digits/100");
01974 else if (num < 200)
01975 snprintf(fn, sizeof(fn), "digits/100E");
01976 else {
01977 if (mf < 0 && num > 199)
01978 snprintf(fn, sizeof(fn), "digits/%dF", (num / 100) * 100);
01979 else
01980 snprintf(fn, sizeof(fn), "digits/%d", (num / 100) * 100);
01981 if (num % 100)
01982 playh = 1;
01983 }
01984 num = num % 100;
01985 } else if (num < 1000000) {
01986 if (num > 1999) {
01987 res = ast_say_number_full_pt(chan, (num / 1000) * mf, ints, language, options, audiofd, ctrlfd);
01988 if (res)
01989 return res;
01990 }
01991 snprintf(fn, sizeof(fn), "digits/1000");
01992 if ((num % 1000) && ((num % 1000) < 100 || !(num % 100)))
01993 playh = 1;
01994 num = num % 1000;
01995 } else if (num < 1000000000) {
01996 res = ast_say_number_full_pt(chan, (num / 1000000), ints, language, options, audiofd, ctrlfd );
01997 if (res)
01998 return res;
01999 if (num < 2000000)
02000 snprintf(fn, sizeof(fn), "digits/1000000");
02001 else
02002 snprintf(fn, sizeof(fn), "digits/1000000S");
02003
02004 if ((num % 1000000) &&
02005
02006 ((!((num / 1000) % 1000) && ((num % 1000) < 100 || !(num % 100))) ||
02007
02008 (!(num % 1000) && (((num / 1000) % 1000) < 100 || !((num / 1000) % 100))) ) )
02009 playh = 1;
02010 num = num % 1000000;
02011 } else {
02012
02013 ast_log(LOG_WARNING, "Number '%d' is too big to say.", num);
02014 res = -1;
02015 }
02016 if (!res) {
02017 if (!ast_streamfile(chan, fn, language)) {
02018 if ((audiofd > -1) && (ctrlfd > -1))
02019 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02020 else
02021 res = ast_waitstream(chan, ints);
02022 }
02023 ast_stopstream(chan);
02024 }
02025 if (!res && playh) {
02026 res = wait_file(chan, ints, "digits/pt-e", language);
02027 ast_stopstream(chan);
02028 playh = 0;
02029 }
02030 }
02031 return res;
02032 }
02033
02034
02035 static int ast_say_number_full_se(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
02036 {
02037 int res = 0;
02038 int playh = 0;
02039 char fn[256] = "";
02040 int cn = 1;
02041 if (!num)
02042 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
02043 if (options && !strncasecmp(options, "n",1)) cn = -1;
02044
02045 while(!res && (num || playh)) {
02046 if (num < 0) {
02047 snprintf(fn, sizeof(fn), "digits/minus");
02048 if ( num > INT_MIN ) {
02049 num = -num;
02050 } else {
02051 num = 0;
02052 }
02053 } else if (playh) {
02054 snprintf(fn, sizeof(fn), "digits/hundred");
02055 playh = 0;
02056 } else if (num < 20) {
02057 snprintf(fn, sizeof(fn), "digits/%d", num);
02058 num = 0;
02059 } else if (num < 100) {
02060 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
02061 num -= ((num / 10) * 10);
02062 } else if (num == 1 && cn == -1) {
02063 snprintf(fn, sizeof(fn), "digits/1N");
02064 num = 0;
02065 } else {
02066 if (num < 1000){
02067 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
02068 playh++;
02069 num -= ((num / 100) * 100);
02070 } else {
02071 if (num < 1000000) {
02072 res = ast_say_number_full_se(chan, num / 1000, ints, language, options, audiofd, ctrlfd);
02073 if (res) {
02074 return res;
02075 }
02076 num = num % 1000;
02077 snprintf(fn, sizeof(fn), "digits/thousand");
02078 } else {
02079 if (num < 1000000000) {
02080 res = ast_say_number_full_se(chan, num / 1000000, ints, language, options, audiofd, ctrlfd);
02081 if (res) {
02082 return res;
02083 }
02084 num = num % 1000000;
02085 snprintf(fn, sizeof(fn), "digits/million");
02086 } else {
02087 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02088 res = -1;
02089 }
02090 }
02091 }
02092 }
02093 if (!res) {
02094 if(!ast_streamfile(chan, fn, language)) {
02095 if ((audiofd > -1) && (ctrlfd > -1))
02096 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02097 else
02098 res = ast_waitstream(chan, ints);
02099 ast_stopstream(chan);
02100 }
02101 }
02102 }
02103 return res;
02104 }
02105
02106
02107 static int ast_say_number_full_tw(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
02108 {
02109 int res = 0;
02110 int playh = 0;
02111 char fn[256] = "";
02112 if (!num)
02113 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
02114
02115 while(!res && (num || playh)) {
02116 if (num < 0) {
02117 snprintf(fn, sizeof(fn), "digits/minus");
02118 if ( num > INT_MIN ) {
02119 num = -num;
02120 } else {
02121 num = 0;
02122 }
02123 } else if (playh) {
02124 snprintf(fn, sizeof(fn), "digits/hundred");
02125 playh = 0;
02126 } else if (num < 10) {
02127 snprintf(fn, sizeof(fn), "digits/%d", num);
02128 num = 0;
02129 } else if (num < 100) {
02130 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
02131 num -= ((num / 10) * 10);
02132 } else {
02133 if (num < 1000){
02134 snprintf(fn, sizeof(fn), "digits/%d", (num/100));
02135 playh++;
02136 num -= ((num / 100) * 100);
02137 } else {
02138 if (num < 1000000) {
02139 res = ast_say_number_full_tw(chan, num / 1000, ints, language, audiofd, ctrlfd);
02140 if (res)
02141 return res;
02142 num = num % 1000;
02143 snprintf(fn, sizeof(fn), "digits/thousand");
02144 } else {
02145 if (num < 1000000000) {
02146 res = ast_say_number_full_tw(chan, num / 1000000, ints, language, audiofd, ctrlfd);
02147 if (res)
02148 return res;
02149 num = num % 1000000;
02150 snprintf(fn, sizeof(fn), "digits/million");
02151 } else {
02152 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02153 res = -1;
02154 }
02155 }
02156 }
02157 }
02158 if (!res) {
02159 if(!ast_streamfile(chan, fn, language)) {
02160 if ((audiofd > -1) && (ctrlfd > -1))
02161 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02162 else
02163 res = ast_waitstream(chan, ints);
02164 }
02165 ast_stopstream(chan);
02166 }
02167 }
02168 return res;
02169 }
02170
02171
02172
02173 static int get_lastdigits_ru(int num) {
02174 if (num < 20) {
02175 return num;
02176 } else if (num < 100) {
02177 return get_lastdigits_ru(num % 10);
02178 } else if (num < 1000) {
02179 return get_lastdigits_ru(num % 100);
02180 }
02181 return 0;
02182 }
02183
02184
02185
02186
02187
02188
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199 static int ast_say_number_full_ru(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
02200 {
02201 int res = 0;
02202 int lastdigits = 0;
02203 char fn[256] = "";
02204 if (!num)
02205 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
02206
02207 while(!res && (num)) {
02208 if (num < 0) {
02209 snprintf(fn, sizeof(fn), "digits/minus");
02210 if ( num > INT_MIN ) {
02211 num = -num;
02212 } else {
02213 num = 0;
02214 }
02215 } else if (num < 20) {
02216 if(options && strlen(options) == 1 && num < 3) {
02217 snprintf(fn, sizeof(fn), "digits/%d%s", num, options);
02218 } else {
02219 snprintf(fn, sizeof(fn), "digits/%d", num);
02220 }
02221 num = 0;
02222 } else if (num < 100) {
02223 snprintf(fn, sizeof(fn), "digits/%d", num - (num % 10));
02224 num %= 10;
02225 } else if (num < 1000){
02226 snprintf(fn, sizeof(fn), "digits/%d", num - (num % 100));
02227 num %= 100;
02228 } else if (num < 1000000) {
02229 lastdigits = get_lastdigits_ru(num / 1000);
02230
02231 if (lastdigits < 3) {
02232 res = ast_say_number_full_ru(chan, num / 1000, ints, language, "f", audiofd, ctrlfd);
02233 } else {
02234 res = ast_say_number_full_ru(chan, num / 1000, ints, language, NULL, audiofd, ctrlfd);
02235 }
02236 if (res)
02237 return res;
02238 if (lastdigits == 1) {
02239 snprintf(fn, sizeof(fn), "digits/thousand");
02240 } else if (lastdigits > 1 && lastdigits < 5) {
02241 snprintf(fn, sizeof(fn), "digits/thousands-i");
02242 } else {
02243 snprintf(fn, sizeof(fn), "digits/thousands");
02244 }
02245 num %= 1000;
02246 } else if (num < 1000000000) {
02247 lastdigits = get_lastdigits_ru(num / 1000000);
02248
02249 res = ast_say_number_full_ru(chan, num / 1000000, ints, language, NULL, audiofd, ctrlfd);
02250 if (res)
02251 return res;
02252 if (lastdigits == 1) {
02253 snprintf(fn, sizeof(fn), "digits/million");
02254 } else if (lastdigits > 1 && lastdigits < 5) {
02255 snprintf(fn, sizeof(fn), "digits/million-a");
02256 } else {
02257 snprintf(fn, sizeof(fn), "digits/millions");
02258 }
02259 num %= 1000000;
02260 } else {
02261 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02262 res = -1;
02263 }
02264 if (!res) {
02265 if (!ast_streamfile(chan, fn, language)) {
02266 if ((audiofd > -1) && (ctrlfd > -1))
02267 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02268 else
02269 res = ast_waitstream(chan, ints);
02270 }
02271 ast_stopstream(chan);
02272 }
02273 }
02274 return res;
02275 }
02276
02277
02278
02279
02280 int ast_say_enumeration_full(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
02281 {
02282 if (!strcasecmp(language,"en") ) {
02283 return(ast_say_enumeration_full_en(chan, num, ints, language, audiofd, ctrlfd));
02284 } else if (!strcasecmp(language, "da") ) {
02285 return(ast_say_enumeration_full_da(chan, num, ints, language, options, audiofd, ctrlfd));
02286 } else if (!strcasecmp(language, "de") ) {
02287 return(ast_say_enumeration_full_de(chan, num, ints, language, options, audiofd, ctrlfd));
02288 }
02289
02290
02291 return(ast_say_enumeration_full_en(chan, num, ints, language, audiofd, ctrlfd));
02292 }
02293
02294
02295 int ast_say_enumeration(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options)
02296 {
02297 return(ast_say_enumeration_full(chan, num, ints, language, options, -1, -1));
02298 }
02299
02300
02301
02302 static int ast_say_enumeration_full_en(struct ast_channel *chan, int num, const char *ints, const char *language, int audiofd, int ctrlfd)
02303 {
02304 int res = 0, t = 0;
02305 char fn[256] = "";
02306
02307 while(!res && num) {
02308 if (num < 0) {
02309 snprintf(fn, sizeof(fn), "digits/minus");
02310 if ( num > INT_MIN ) {
02311 num = -num;
02312 } else {
02313 num = 0;
02314 }
02315 } else if (num < 20) {
02316 snprintf(fn, sizeof(fn), "digits/h-%d", num);
02317 num = 0;
02318 } else if (num < 100) {
02319 int tens = num / 10;
02320 num = num % 10;
02321 if (num == 0) {
02322 snprintf(fn, sizeof(fn), "digits/h-%d", (tens * 10));
02323 } else {
02324 snprintf(fn, sizeof(fn), "digits/%d", (tens * 10));
02325 }
02326 } else if (num < 1000) {
02327 int hundreds = num / 100;
02328 num = num % 100;
02329 if (hundreds > 1 || t == 1) {
02330 res = ast_say_number_full_en(chan, hundreds, ints, language, audiofd, ctrlfd);
02331 }
02332 if (res)
02333 return res;
02334 if (num) {
02335 snprintf(fn, sizeof(fn), "digits/hundred");
02336 } else {
02337 snprintf(fn, sizeof(fn), "digits/h-hundred");
02338 }
02339 } else if (num < 1000000) {
02340 int thousands = num / 1000;
02341 num = num % 1000;
02342 if (thousands > 1 || t == 1) {
02343 res = ast_say_number_full_en(chan, thousands, ints, language, audiofd, ctrlfd);
02344 }
02345 if (res)
02346 return res;
02347 if (num) {
02348 snprintf(fn, sizeof(fn), "digits/thousand");
02349 } else {
02350 snprintf(fn, sizeof(fn), "digits/h-thousand");
02351 }
02352 t = 1;
02353 } else if (num < 1000000000) {
02354 int millions = num / 1000000;
02355 num = num % 1000000;
02356 t = 1;
02357 res = ast_say_number_full_en(chan, millions, ints, language, audiofd, ctrlfd);
02358 if (res)
02359 return res;
02360 if (num) {
02361 snprintf(fn, sizeof(fn), "digits/million");
02362 } else {
02363 snprintf(fn, sizeof(fn), "digits/h-million");
02364 }
02365 } else if (num < INT_MAX) {
02366 int billions = num / 1000000000;
02367 num = num % 1000000000;
02368 t = 1;
02369 res = ast_say_number_full_en(chan, billions, ints, language, audiofd, ctrlfd);
02370 if (res)
02371 return res;
02372 if (num) {
02373 snprintf(fn, sizeof(fn), "digits/billion");
02374 } else {
02375 snprintf(fn, sizeof(fn), "digits/h-billion");
02376 }
02377 } else if (num == INT_MAX) {
02378 snprintf(fn, sizeof(fn), "digits/h-last");
02379 num = 0;
02380 } else {
02381 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02382 res = -1;
02383 }
02384
02385 if (!res) {
02386 if (!ast_streamfile(chan, fn, language)) {
02387 if ((audiofd > -1) && (ctrlfd > -1)) {
02388 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02389 } else {
02390 res = ast_waitstream(chan, ints);
02391 }
02392 }
02393 ast_stopstream(chan);
02394 }
02395 }
02396 return res;
02397 }
02398
02399
02400 static int ast_say_enumeration_full_da(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
02401 {
02402
02403 int res = 0, t = 0;
02404 char fn[256] = "", fna[256] = "";
02405 char *gender;
02406
02407 if (options && !strncasecmp(options, "f",1)) {
02408 gender = "F";
02409 } else if (options && !strncasecmp(options, "n",1)) {
02410 gender = "N";
02411 } else {
02412 gender = "";
02413 }
02414
02415 if (!num)
02416 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
02417
02418 while(!res && num) {
02419 if (num < 0) {
02420 snprintf(fn, sizeof(fn), "digits/minus");
02421 if ( num > INT_MIN ) {
02422 num = -num;
02423 } else {
02424 num = 0;
02425 }
02426 } else if (num < 100 && t) {
02427 snprintf(fn, sizeof(fn), "digits/and");
02428 t = 0;
02429 } else if (num < 20) {
02430 snprintf(fn, sizeof(fn), "digits/h-%d%s", num, gender);
02431 num = 0;
02432 } else if (num < 100) {
02433 int ones = num % 10;
02434 if (ones) {
02435 snprintf(fn, sizeof(fn), "digits/%d-and", ones);
02436 num -= ones;
02437 } else {
02438 snprintf(fn, sizeof(fn), "digits/h-%d%s", num, gender);
02439 num = 0;
02440 }
02441 } else if (num == 100 && t == 0) {
02442 snprintf(fn, sizeof(fn), "digits/h-hundred%s", gender);
02443 num = 0;
02444 } else if (num < 1000) {
02445 int hundreds = num / 100;
02446 num = num % 100;
02447 if (hundreds == 1) {
02448 snprintf(fn, sizeof(fn), "digits/1N");
02449 } else {
02450 snprintf(fn, sizeof(fn), "digits/%d", hundreds);
02451 }
02452 if (num) {
02453 snprintf(fna, sizeof(fna), "digits/hundred");
02454 } else {
02455 snprintf(fna, sizeof(fna), "digits/h-hundred%s", gender);
02456 }
02457 t = 1;
02458 } else if (num < 1000000) {
02459 int thousands = num / 1000;
02460 num = num % 1000;
02461 if (thousands == 1) {
02462 if (num) {
02463 snprintf(fn, sizeof(fn), "digits/1N");
02464 snprintf(fna, sizeof(fna), "digits/thousand");
02465 } else {
02466 if (t) {
02467 snprintf(fn, sizeof(fn), "digits/1N");
02468 snprintf(fna, sizeof(fna), "digits/h-thousand%s", gender);
02469 } else {
02470 snprintf(fn, sizeof(fn), "digits/h-thousand%s", gender);
02471 }
02472 }
02473 } else {
02474 res = ast_say_number_full_de(chan, thousands, ints, language, options, audiofd, ctrlfd);
02475 if (res) {
02476 return res;
02477 }
02478 if (num) {
02479 snprintf(fn, sizeof(fn), "digits/thousand");
02480 } else {
02481 snprintf(fn, sizeof(fn), "digits/h-thousand%s", gender);
02482 }
02483 }
02484 t = 1;
02485 } else if (num < 1000000000) {
02486 int millions = num / 1000000;
02487 num = num % 1000000;
02488 if (millions == 1) {
02489 if (num) {
02490 snprintf(fn, sizeof(fn), "digits/1F");
02491 snprintf(fna, sizeof(fna), "digits/million");
02492 } else {
02493 snprintf(fn, sizeof(fn), "digits/1N");
02494 snprintf(fna, sizeof(fna), "digits/h-million%s", gender);
02495 }
02496 } else {
02497 res = ast_say_number_full_de(chan, millions, ints, language, options, audiofd, ctrlfd);
02498 if (res) {
02499 return res;
02500 }
02501 if (num) {
02502 snprintf(fn, sizeof(fn), "digits/millions");
02503 } else {
02504 snprintf(fn, sizeof(fn), "digits/h-million%s", gender);
02505 }
02506 }
02507 t = 1;
02508 } else if (num < INT_MAX) {
02509 int billions = num / 1000000000;
02510 num = num % 1000000000;
02511 if (billions == 1) {
02512 if (num) {
02513 snprintf(fn, sizeof(fn), "digits/1F");
02514 snprintf(fna, sizeof(fna), "digits/milliard");
02515 } else {
02516 snprintf(fn, sizeof(fn), "digits/1N");
02517 snprintf(fna, sizeof(fna), "digits/h-milliard%s", gender);
02518 }
02519 } else {
02520 res = ast_say_number_full_de(chan, billions, ints, language, options, audiofd, ctrlfd);
02521 if (res)
02522 return res;
02523 if (num) {
02524 snprintf(fn, sizeof(fna), "digits/milliards");
02525 } else {
02526 snprintf(fn, sizeof(fna), "digits/h-milliard%s", gender);
02527 }
02528 }
02529 t = 1;
02530 } else if (num == INT_MAX) {
02531 snprintf(fn, sizeof(fn), "digits/h-last%s", gender);
02532 num = 0;
02533 } else {
02534 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02535 res = -1;
02536 }
02537
02538 if (!res) {
02539 if (!ast_streamfile(chan, fn, language)) {
02540 if ((audiofd > -1) && (ctrlfd > -1))
02541 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02542 else
02543 res = ast_waitstream(chan, ints);
02544 }
02545 ast_stopstream(chan);
02546 if (!res) {
02547 if (strlen(fna) != 0 && !ast_streamfile(chan, fna, language)) {
02548 if ((audiofd > -1) && (ctrlfd > -1)) {
02549 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02550 } else {
02551 res = ast_waitstream(chan, ints);
02552 }
02553 }
02554 ast_stopstream(chan);
02555 strcpy(fna, "");
02556 }
02557 }
02558 }
02559 return res;
02560 }
02561
02562
02563 static int ast_say_enumeration_full_de(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options, int audiofd, int ctrlfd)
02564 {
02565
02566 int res = 0, t = 0;
02567 char fn[256] = "", fna[256] = "";
02568 char *gender;
02569
02570 if (options && !strncasecmp(options, "f",1)) {
02571 gender = "F";
02572 } else if (options && !strncasecmp(options, "n",1)) {
02573 gender = "N";
02574 } else {
02575 gender = "";
02576 }
02577
02578 if (!num)
02579 return ast_say_digits_full(chan, 0,ints, language, audiofd, ctrlfd);
02580
02581 while(!res && num) {
02582 if (num < 0) {
02583 snprintf(fn, sizeof(fn), "digits/minus");
02584 if ( num > INT_MIN ) {
02585 num = -num;
02586 } else {
02587 num = 0;
02588 }
02589 } else if (num < 100 && t) {
02590 snprintf(fn, sizeof(fn), "digits/and");
02591 t = 0;
02592 } else if (num < 20) {
02593 snprintf(fn, sizeof(fn), "digits/h-%d%s", num, gender);
02594 num = 0;
02595 } else if (num < 100) {
02596 int ones = num % 10;
02597 if (ones) {
02598 snprintf(fn, sizeof(fn), "digits/%d-and", ones);
02599 num -= ones;
02600 } else {
02601 snprintf(fn, sizeof(fn), "digits/h-%d%s", num, gender);
02602 num = 0;
02603 }
02604 } else if (num == 100 && t == 0) {
02605 snprintf(fn, sizeof(fn), "digits/h-hundred%s", gender);
02606 num = 0;
02607 } else if (num < 1000) {
02608 int hundreds = num / 100;
02609 num = num % 100;
02610 if (hundreds == 1) {
02611 snprintf(fn, sizeof(fn), "digits/1N");
02612 } else {
02613 snprintf(fn, sizeof(fn), "digits/%d", hundreds);
02614 }
02615 if (num) {
02616 snprintf(fna, sizeof(fna), "digits/hundred");
02617 } else {
02618 snprintf(fna, sizeof(fna), "digits/h-hundred%s", gender);
02619 }
02620 t = 1;
02621 } else if (num < 1000000) {
02622 int thousands = num / 1000;
02623 num = num % 1000;
02624 if (thousands == 1) {
02625 if (num) {
02626 snprintf(fn, sizeof(fn), "digits/1N");
02627 snprintf(fna, sizeof(fna), "digits/thousand");
02628 } else {
02629 if (t) {
02630 snprintf(fn, sizeof(fn), "digits/1N");
02631 snprintf(fna, sizeof(fna), "digits/h-thousand%s", gender);
02632 } else {
02633 snprintf(fn, sizeof(fn), "digits/h-thousand%s", gender);
02634 }
02635 }
02636 } else {
02637 res = ast_say_number_full_de(chan, thousands, ints, language, options, audiofd, ctrlfd);
02638 if (res) {
02639 return res;
02640 }
02641 if (num) {
02642 snprintf(fn, sizeof(fn), "digits/thousand");
02643 } else {
02644 snprintf(fn, sizeof(fn), "digits/h-thousand%s", gender);
02645 }
02646 }
02647 t = 1;
02648 } else if (num < 1000000000) {
02649 int millions = num / 1000000;
02650 num = num % 1000000;
02651 if (millions == 1) {
02652 if (num) {
02653 snprintf(fn, sizeof(fn), "digits/1F");
02654 snprintf(fna, sizeof(fna), "digits/million");
02655 } else {
02656 snprintf(fn, sizeof(fn), "digits/1N");
02657 snprintf(fna, sizeof(fna), "digits/h-million%s", gender);
02658 }
02659 } else {
02660 res = ast_say_number_full_de(chan, millions, ints, language, options, audiofd, ctrlfd);
02661 if (res) {
02662 return res;
02663 }
02664 if (num) {
02665 snprintf(fn, sizeof(fn), "digits/millions");
02666 } else {
02667 snprintf(fn, sizeof(fn), "digits/h-million%s", gender);
02668 }
02669 }
02670 t = 1;
02671 } else if (num < INT_MAX) {
02672 int billions = num / 1000000000;
02673 num = num % 1000000000;
02674 if (billions == 1) {
02675 if (num) {
02676 snprintf(fn, sizeof(fn), "digits/1F");
02677 snprintf(fna, sizeof(fna), "digits/milliard");
02678 } else {
02679 snprintf(fn, sizeof(fn), "digits/1N");
02680 snprintf(fna, sizeof(fna), "digits/h-milliard%s", gender);
02681 }
02682 } else {
02683 res = ast_say_number_full_de(chan, billions, ints, language, options, audiofd, ctrlfd);
02684 if (res)
02685 return res;
02686 if (num) {
02687 snprintf(fn, sizeof(fna), "digits/milliards");
02688 } else {
02689 snprintf(fn, sizeof(fna), "digits/h-milliard%s", gender);
02690 }
02691 }
02692 t = 1;
02693 } else if (num == INT_MAX) {
02694 snprintf(fn, sizeof(fn), "digits/h-last%s", gender);
02695 num = 0;
02696 } else {
02697 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
02698 res = -1;
02699 }
02700
02701 if (!res) {
02702 if (!ast_streamfile(chan, fn, language)) {
02703 if ((audiofd > -1) && (ctrlfd > -1))
02704 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02705 else
02706 res = ast_waitstream(chan, ints);
02707 }
02708 ast_stopstream(chan);
02709 if (!res) {
02710 if (strlen(fna) != 0 && !ast_streamfile(chan, fna, language)) {
02711 if ((audiofd > -1) && (ctrlfd > -1)) {
02712 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
02713 } else {
02714 res = ast_waitstream(chan, ints);
02715 }
02716 }
02717 ast_stopstream(chan);
02718 strcpy(fna, "");
02719 }
02720 }
02721 }
02722 return res;
02723 }
02724
02725 int ast_say_date(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02726 {
02727 if (!strcasecmp(lang, "en") ) {
02728 return(ast_say_date_en(chan, t, ints, lang));
02729 } else if (!strcasecmp(lang, "da") ) {
02730 return(ast_say_date_da(chan, t, ints, lang));
02731 } else if (!strcasecmp(lang, "de") ) {
02732 return(ast_say_date_de(chan, t, ints, lang));
02733 } else if (!strcasecmp(lang, "fr") ) {
02734 return(ast_say_date_fr(chan, t, ints, lang));
02735 } else if (!strcasecmp(lang, "nl") ) {
02736 return(ast_say_date_nl(chan, t, ints, lang));
02737 } else if (!strcasecmp(lang, "pt") || !strcasecmp(lang, "pt_BR")) {
02738 return(ast_say_date_pt(chan, t, ints, lang));
02739 } else if (!strcasecmp(lang, "gr") ) {
02740 return(ast_say_date_gr(chan, t, ints, lang));
02741 }
02742
02743
02744 return(ast_say_date_en(chan, t, ints, lang));
02745 }
02746
02747
02748 int ast_say_date_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02749 {
02750 struct tm tm;
02751 char fn[256];
02752 int res = 0;
02753 ast_localtime(&t,&tm,NULL);
02754 if (!res) {
02755 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02756 res = ast_streamfile(chan, fn, lang);
02757 if (!res)
02758 res = ast_waitstream(chan, ints);
02759 }
02760 if (!res) {
02761 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02762 res = ast_streamfile(chan, fn, lang);
02763 if (!res)
02764 res = ast_waitstream(chan, ints);
02765 }
02766 if (!res)
02767 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char * ) NULL);
02768 if (!res)
02769 res = ast_waitstream(chan, ints);
02770 if (!res)
02771 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
02772 return res;
02773 }
02774
02775
02776 int ast_say_date_da(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02777 {
02778 struct tm tm;
02779 char fn[256];
02780 int res = 0;
02781 ast_localtime(&t,&tm,NULL);
02782 if (!res) {
02783 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02784 res = ast_streamfile(chan, fn, lang);
02785 if (!res)
02786 res = ast_waitstream(chan, ints);
02787 }
02788 if (!res)
02789 res = ast_say_enumeration(chan, tm.tm_mday, ints, lang, (char * ) NULL);
02790 if (!res)
02791 res = ast_waitstream(chan, ints);
02792 if (!res) {
02793 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02794 res = ast_streamfile(chan, fn, lang);
02795 if (!res)
02796 res = ast_waitstream(chan, ints);
02797 }
02798 if (!res) {
02799
02800 int year = tm.tm_year + 1900;
02801 if (year > 1999) {
02802 res = ast_say_number(chan, year, ints, lang, (char *) NULL);
02803 } else {
02804 if (year < 1100) {
02805
02806
02807 } else {
02808
02809 snprintf(fn,sizeof(fn), "digits/%d", (year / 100) );
02810 res = wait_file(chan, ints, fn, lang);
02811 if (!res) {
02812 res = wait_file(chan,ints, "digits/hundred", lang);
02813 if (!res && year % 100 != 0) {
02814 res = ast_say_number(chan, (year % 100), ints, lang, (char *) NULL);
02815 }
02816 }
02817 }
02818 }
02819 }
02820 return res;
02821 }
02822
02823
02824 int ast_say_date_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02825 {
02826 struct tm tm;
02827 char fn[256];
02828 int res = 0;
02829 ast_localtime(&t,&tm,NULL);
02830 if (!res) {
02831 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02832 res = ast_streamfile(chan, fn, lang);
02833 if (!res)
02834 res = ast_waitstream(chan, ints);
02835 }
02836 if (!res)
02837 res = ast_say_enumeration(chan, tm.tm_mday, ints, lang, (char * ) NULL);
02838 if (!res)
02839 res = ast_waitstream(chan, ints);
02840 if (!res) {
02841 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02842 res = ast_streamfile(chan, fn, lang);
02843 if (!res)
02844 res = ast_waitstream(chan, ints);
02845 }
02846 if (!res) {
02847
02848 int year = tm.tm_year + 1900;
02849 if (year > 1999) {
02850 res = ast_say_number(chan, year, ints, lang, (char *) NULL);
02851 } else {
02852 if (year < 1100) {
02853
02854
02855 } else {
02856
02857
02858 snprintf(fn,sizeof(fn), "digits/%d", (year / 100) );
02859 res = wait_file(chan, ints, fn, lang);
02860 if (!res) {
02861 res = wait_file(chan,ints, "digits/hundred", lang);
02862 if (!res && year % 100 != 0) {
02863 res = ast_say_number(chan, (year % 100), ints, lang, (char *) NULL);
02864 }
02865 }
02866 }
02867 }
02868 }
02869 return res;
02870 }
02871
02872
02873 int ast_say_date_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02874 {
02875 struct tm tm;
02876 char fn[256];
02877 int res = 0;
02878 ast_localtime(&t,&tm,NULL);
02879 if (!res) {
02880 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02881 res = ast_streamfile(chan, fn, lang);
02882 if (!res)
02883 res = ast_waitstream(chan, ints);
02884 }
02885 if (!res)
02886 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char * ) NULL);
02887 if (!res)
02888 res = ast_waitstream(chan, ints);
02889 if (!res) {
02890 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02891 res = ast_streamfile(chan, fn, lang);
02892 if (!res)
02893 res = ast_waitstream(chan, ints);
02894 }
02895 if (!res)
02896 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
02897 return res;
02898 }
02899
02900
02901 int ast_say_date_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02902 {
02903 struct tm tm;
02904 char fn[256];
02905 int res = 0;
02906 ast_localtime(&t,&tm,NULL);
02907 if (!res) {
02908 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02909 res = ast_streamfile(chan, fn, lang);
02910 if (!res)
02911 res = ast_waitstream(chan, ints);
02912 }
02913 if (!res)
02914 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char * ) NULL);
02915 if (!res) {
02916 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02917 res = ast_streamfile(chan, fn, lang);
02918 if (!res)
02919 res = ast_waitstream(chan, ints);
02920 }
02921 if (!res)
02922 res = ast_waitstream(chan, ints);
02923 if (!res)
02924 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
02925 return res;
02926 }
02927
02928
02929 int ast_say_date_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
02930 {
02931 struct tm tm;
02932 char fn[256];
02933 int res = 0;
02934 ast_localtime(&t,&tm,NULL);
02935 localtime_r(&t,&tm);
02936 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
02937 if (!res)
02938 res = wait_file(chan, ints, fn, lang);
02939 if (!res)
02940 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
02941 if (!res)
02942 res = wait_file(chan, ints, "digits/pt-de", lang);
02943 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
02944 if (!res)
02945 res = wait_file(chan, ints, fn, lang);
02946 if (!res)
02947 res = wait_file(chan, ints, "digits/pt-de", lang);
02948 if (!res)
02949 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
02950
02951 return res;
02952 }
02953
02954 int ast_say_date_with_format(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
02955 {
02956 if (!strcasecmp(lang, "en") ) {
02957 return(ast_say_date_with_format_en(chan, time, ints, lang, format, timezone));
02958 } else if (!strcasecmp(lang, "da") ) {
02959 return(ast_say_date_with_format_da(chan, time, ints, lang, format, timezone));
02960 } else if (!strcasecmp(lang, "de") ) {
02961 return(ast_say_date_with_format_de(chan, time, ints, lang, format, timezone));
02962 } else if (!strcasecmp(lang, "es") || !strcasecmp(lang, "mx")) {
02963 return(ast_say_date_with_format_es(chan, time, ints, lang, format, timezone));
02964 } else if (!strcasecmp(lang, "he")) {
02965 return(ast_say_date_with_format_he(chan, time, ints, lang, format, timezone));
02966 } else if (!strcasecmp(lang, "fr") ) {
02967 return(ast_say_date_with_format_fr(chan, time, ints, lang, format, timezone));
02968 } else if (!strcasecmp(lang, "it") ) {
02969 return(ast_say_date_with_format_it(chan, time, ints, lang, format, timezone));
02970 } else if (!strcasecmp(lang, "nl") ) {
02971 return(ast_say_date_with_format_nl(chan, time, ints, lang, format, timezone));
02972 } else if (!strcasecmp(lang, "pt") || !strcasecmp(lang, "pt_BR")) {
02973 return(ast_say_date_with_format_pt(chan, time, ints, lang, format, timezone));
02974 } else if (!strcasecmp(lang, "tw") ) {
02975 return(ast_say_date_with_format_tw(chan, time, ints, lang, format, timezone));
02976 } else if (!strcasecmp(lang, "gr") ) {
02977 return(ast_say_date_with_format_gr(chan, time, ints, lang, format, timezone));
02978 }
02979
02980
02981 return(ast_say_date_with_format_en(chan, time, ints, lang, format, timezone));
02982 }
02983
02984
02985 int ast_say_date_with_format_en(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
02986 {
02987 struct tm tm;
02988 int res=0, offset, sndoffset;
02989 char sndfile[256], nextmsg[256];
02990
02991 ast_localtime(&time,&tm,timezone);
02992
02993 for (offset=0 ; format[offset] != '\0' ; offset++) {
02994 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
02995 switch (format[offset]) {
02996
02997 case '\'':
02998
02999 sndoffset=0;
03000 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
03001 sndfile[sndoffset] = format[offset];
03002 sndfile[sndoffset] = '\0';
03003 res = wait_file(chan,ints,sndfile,lang);
03004 break;
03005 case 'A':
03006 case 'a':
03007
03008 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
03009 res = wait_file(chan,ints,nextmsg,lang);
03010 break;
03011 case 'B':
03012 case 'b':
03013 case 'h':
03014
03015 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
03016 res = wait_file(chan,ints,nextmsg,lang);
03017 break;
03018 case 'm':
03019
03020 res = ast_say_enumeration(chan, (tm.tm_mon + 1), ints, lang, (char *) NULL);
03021 break;
03022 case 'd':
03023 case 'e':
03024
03025 res = ast_say_enumeration(chan, tm.tm_mday, ints, lang, (char *) NULL);
03026 break;
03027 case 'Y':
03028
03029 if (tm.tm_year > 99) {
03030 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
03031 } else {
03032 if (tm.tm_year < 1) {
03033
03034
03035 } else {
03036 res = wait_file(chan,ints, "digits/19",lang);
03037 if (!res) {
03038 if (tm.tm_year <= 9) {
03039
03040 res = wait_file(chan,ints, "digits/oh",lang);
03041 if (!res) {
03042 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
03043 res = wait_file(chan,ints,nextmsg,lang);
03044 }
03045 } else if (tm.tm_year <= 20) {
03046
03047 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
03048 res = wait_file(chan,ints,nextmsg,lang);
03049 } else {
03050
03051 int ten, one;
03052 ten = tm.tm_year / 10;
03053 one = tm.tm_year % 10;
03054 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten * 10);
03055 res = wait_file(chan,ints,nextmsg,lang);
03056 if (!res) {
03057 if (one != 0) {
03058 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
03059 res = wait_file(chan,ints,nextmsg,lang);
03060 }
03061 }
03062 }
03063 }
03064 }
03065 }
03066 break;
03067 case 'I':
03068 case 'l':
03069
03070 if (tm.tm_hour == 0)
03071 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
03072 else if (tm.tm_hour > 12)
03073 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
03074 else
03075 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
03076 res = wait_file(chan,ints,nextmsg,lang);
03077 break;
03078 case 'H':
03079 case 'k':
03080
03081 if (format[offset] == 'H') {
03082
03083 if (tm.tm_hour < 10) {
03084 res = wait_file(chan,ints, "digits/oh",lang);
03085 }
03086 } else {
03087
03088 if (tm.tm_hour == 0) {
03089 res = wait_file(chan,ints, "digits/oh",lang);
03090 }
03091 }
03092 if (!res) {
03093 if (tm.tm_hour != 0) {
03094 int remainder = tm.tm_hour;
03095 if (tm.tm_hour > 20) {
03096 res = wait_file(chan,ints, "digits/20",lang);
03097 remainder -= 20;
03098 }
03099 if (!res) {
03100 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", remainder);
03101 res = wait_file(chan,ints,nextmsg,lang);
03102 }
03103 }
03104 }
03105 break;
03106 case 'M':
03107 case 'N':
03108
03109 if (tm.tm_min == 0) {
03110 if (format[offset] == 'M') {
03111 res = wait_file(chan, ints, "digits/oclock", lang);
03112 } else {
03113 res = wait_file(chan, ints, "digits/hundred", lang);
03114 }
03115 } else if (tm.tm_min < 10) {
03116 res = wait_file(chan,ints, "digits/oh",lang);
03117 if (!res) {
03118 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_min);
03119 res = wait_file(chan,ints,nextmsg,lang);
03120 }
03121 } else {
03122 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
03123 }
03124 break;
03125 case 'P':
03126 case 'p':
03127
03128 if (tm.tm_hour > 11)
03129 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
03130 else
03131 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
03132 res = wait_file(chan,ints,nextmsg,lang);
03133 break;
03134 case 'Q':
03135
03136 {
03137 struct timeval now;
03138 struct tm tmnow;
03139 time_t beg_today;
03140
03141 gettimeofday(&now,NULL);
03142 ast_localtime(&now.tv_sec,&tmnow,timezone);
03143
03144
03145 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03146 if (beg_today < time) {
03147
03148 res = wait_file(chan,ints, "digits/today",lang);
03149 } else if (beg_today - 86400 < time) {
03150
03151 res = wait_file(chan,ints, "digits/yesterday",lang);
03152 } else {
03153 res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
03154 }
03155 }
03156 break;
03157 case 'q':
03158
03159 {
03160 struct timeval now;
03161 struct tm tmnow;
03162 time_t beg_today;
03163
03164 gettimeofday(&now,NULL);
03165 ast_localtime(&now.tv_sec,&tmnow,timezone);
03166
03167
03168 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03169 if (beg_today < time) {
03170
03171 } else if ((beg_today - 86400) < time) {
03172
03173 res = wait_file(chan,ints, "digits/yesterday",lang);
03174 } else if (beg_today - 86400 * 6 < time) {
03175
03176 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
03177 } else {
03178 res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
03179 }
03180 }
03181 break;
03182 case 'R':
03183 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
03184 break;
03185 case 'S':
03186
03187 if (tm.tm_sec == 0) {
03188 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
03189 res = wait_file(chan,ints,nextmsg,lang);
03190 } else if (tm.tm_sec < 10) {
03191 res = wait_file(chan,ints, "digits/oh",lang);
03192 if (!res) {
03193 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
03194 res = wait_file(chan,ints,nextmsg,lang);
03195 }
03196 } else {
03197 res = ast_say_number(chan, tm.tm_sec, ints, lang, (char *) NULL);
03198 }
03199 break;
03200 case 'T':
03201 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
03202 break;
03203 case ' ':
03204 case ' ':
03205
03206 break;
03207 default:
03208
03209 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03210 }
03211
03212 if (res) {
03213 break;
03214 }
03215 }
03216 return res;
03217 }
03218
03219
03220 int ast_say_date_with_format_da(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
03221 {
03222 struct tm tm;
03223 int res=0, offset, sndoffset;
03224 char sndfile[256], nextmsg[256];
03225
03226 ast_localtime(&time,&tm,timezone);
03227
03228 for (offset=0 ; format[offset] != '\0' ; offset++) {
03229 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
03230 switch (format[offset]) {
03231
03232 case '\'':
03233
03234 sndoffset=0;
03235 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
03236 sndfile[sndoffset] = format[offset];
03237 sndfile[sndoffset] = '\0';
03238 res = wait_file(chan,ints,sndfile,lang);
03239 break;
03240 case 'A':
03241 case 'a':
03242
03243 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
03244 res = wait_file(chan,ints,nextmsg,lang);
03245 break;
03246 case 'B':
03247 case 'b':
03248 case 'h':
03249
03250 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
03251 res = wait_file(chan,ints,nextmsg,lang);
03252 break;
03253 case 'm':
03254
03255 res = ast_say_enumeration(chan, (tm.tm_mon + 1), ints, lang, "m");
03256 break;
03257 case 'd':
03258 case 'e':
03259
03260 res = ast_say_enumeration(chan, tm.tm_mday, ints, lang, "m");
03261 break;
03262 case 'Y':
03263
03264 {
03265 int year = tm.tm_year + 1900;
03266 if (year > 1999) {
03267 res = ast_say_number(chan, year, ints, lang, (char *) NULL);
03268 } else {
03269 if (year < 1100) {
03270
03271
03272 } else {
03273
03274
03275 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", (year / 100) );
03276 res = wait_file(chan,ints,nextmsg,lang);
03277 if (!res) {
03278 res = wait_file(chan,ints, "digits/hundred",lang);
03279 if (!res && year % 100 != 0) {
03280 res = ast_say_number(chan, (year % 100), ints, lang, (char *) NULL);
03281 }
03282 }
03283 }
03284 }
03285 }
03286 break;
03287 case 'I':
03288 case 'l':
03289
03290 res = wait_file(chan,ints,"digits/oclock",lang);
03291 if (tm.tm_hour == 0)
03292 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
03293 else if (tm.tm_hour > 12)
03294 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
03295 else
03296 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
03297 if (!res) {
03298 res = wait_file(chan,ints,nextmsg,lang);
03299 }
03300 break;
03301 case 'H':
03302
03303 if (tm.tm_hour < 10 && tm.tm_hour > 0) {
03304 res = wait_file(chan,ints, "digits/0",lang);
03305 }
03306
03307 case 'k':
03308
03309 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char *) NULL);
03310 break;
03311 case 'M':
03312
03313 if (tm.tm_min > 0 || format[offset+ 1 ] == 'S' ) {
03314 res = ast_say_number(chan, tm.tm_min, ints, lang, "f");
03315 }
03316 if ( !res && format[offset + 1] == 'S' ) {
03317 if (tm.tm_min == 1) {
03318 res = wait_file(chan,ints,"digits/minute",lang);
03319 } else {
03320 res = wait_file(chan,ints,"digits/minutes",lang);
03321 }
03322 }
03323 break;
03324 case 'P':
03325 case 'p':
03326
03327 if (tm.tm_hour > 11)
03328 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
03329 else
03330 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
03331 res = wait_file(chan,ints,nextmsg,lang);
03332 break;
03333 case 'Q':
03334
03335 {
03336 struct timeval now;
03337 struct tm tmnow;
03338 time_t beg_today;
03339
03340 gettimeofday(&now,NULL);
03341 ast_localtime(&now.tv_sec,&tmnow,timezone);
03342
03343
03344 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03345 if (beg_today < time) {
03346
03347 res = wait_file(chan,ints, "digits/today",lang);
03348 } else if (beg_today - 86400 < time) {
03349
03350 res = wait_file(chan,ints, "digits/yesterday",lang);
03351 } else {
03352 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
03353 }
03354 }
03355 break;
03356 case 'q':
03357
03358 {
03359 struct timeval now;
03360 struct tm tmnow;
03361 time_t beg_today;
03362
03363 gettimeofday(&now,NULL);
03364 ast_localtime(&now.tv_sec,&tmnow,timezone);
03365
03366
03367 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03368 if (beg_today < time) {
03369
03370 } else if ((beg_today - 86400) < time) {
03371
03372 res = wait_file(chan,ints, "digits/yesterday",lang);
03373 } else if (beg_today - 86400 * 6 < time) {
03374
03375 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
03376 } else {
03377 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
03378 }
03379 }
03380 break;
03381 case 'R':
03382 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
03383 break;
03384 case 'S':
03385
03386 res = wait_file(chan,ints, "digits/and",lang);
03387 if (!res) {
03388 res = ast_say_number(chan, tm.tm_sec, ints, lang, "f");
03389 if (!res) {
03390 res = wait_file(chan,ints, "digits/seconds",lang);
03391 }
03392 }
03393 break;
03394 case 'T':
03395 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
03396 break;
03397 case ' ':
03398 case ' ':
03399
03400 break;
03401 default:
03402
03403 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03404 }
03405
03406 if (res) {
03407 break;
03408 }
03409 }
03410 return res;
03411 }
03412
03413
03414 int ast_say_date_with_format_de(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
03415 {
03416 struct tm tm;
03417 int res=0, offset, sndoffset;
03418 char sndfile[256], nextmsg[256];
03419
03420 ast_localtime(&time,&tm,timezone);
03421
03422 for (offset=0 ; format[offset] != '\0' ; offset++) {
03423 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
03424 switch (format[offset]) {
03425
03426 case '\'':
03427
03428 sndoffset=0;
03429 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
03430 sndfile[sndoffset] = format[offset];
03431 sndfile[sndoffset] = '\0';
03432 res = wait_file(chan,ints,sndfile,lang);
03433 break;
03434 case 'A':
03435 case 'a':
03436
03437 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
03438 res = wait_file(chan,ints,nextmsg,lang);
03439 break;
03440 case 'B':
03441 case 'b':
03442 case 'h':
03443
03444 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
03445 res = wait_file(chan,ints,nextmsg,lang);
03446 break;
03447 case 'm':
03448
03449 res = ast_say_enumeration(chan, (tm.tm_mon + 1), ints, lang, "m");
03450 break;
03451 case 'd':
03452 case 'e':
03453
03454 res = ast_say_enumeration(chan, tm.tm_mday, ints, lang, "m");
03455 break;
03456 case 'Y':
03457
03458 {
03459 int year = tm.tm_year + 1900;
03460 if (year > 1999) {
03461 res = ast_say_number(chan, year, ints, lang, (char *) NULL);
03462 } else {
03463 if (year < 1100) {
03464
03465
03466 } else {
03467
03468
03469 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", (year / 100) );
03470 res = wait_file(chan,ints,nextmsg,lang);
03471 if (!res) {
03472 res = wait_file(chan,ints, "digits/hundred",lang);
03473 if (!res && year % 100 != 0) {
03474 res = ast_say_number(chan, (year % 100), ints, lang, (char *) NULL);
03475 }
03476 }
03477 }
03478 }
03479 }
03480 break;
03481 case 'I':
03482 case 'l':
03483
03484 if (tm.tm_hour == 0)
03485 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
03486 else if (tm.tm_hour > 12)
03487 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
03488 else
03489 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
03490 res = wait_file(chan,ints,nextmsg,lang);
03491 if (!res) {
03492 res = wait_file(chan,ints,"digits/oclock",lang);
03493 }
03494 break;
03495 case 'H':
03496 case 'k':
03497
03498 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char *) NULL);
03499 if (!res) {
03500 res = wait_file(chan,ints,"digits/oclock",lang);
03501 }
03502 break;
03503 case 'M':
03504
03505 if (tm.tm_min > 0 || format[offset+ 1 ] == 'S' ) {
03506 res = ast_say_number(chan, tm.tm_min, ints, lang, "f");
03507 }
03508 if ( !res && format[offset + 1] == 'S' ) {
03509 if (tm.tm_min == 1) {
03510 res = wait_file(chan,ints,"digits/minute",lang);
03511 } else {
03512 res = wait_file(chan,ints,"digits/minutes",lang);
03513 }
03514 }
03515 break;
03516 case 'P':
03517 case 'p':
03518
03519 if (tm.tm_hour > 11)
03520 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
03521 else
03522 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
03523 res = wait_file(chan,ints,nextmsg,lang);
03524 break;
03525 case 'Q':
03526
03527 {
03528 struct timeval now;
03529 struct tm tmnow;
03530 time_t beg_today;
03531
03532 gettimeofday(&now,NULL);
03533 ast_localtime(&now.tv_sec,&tmnow,timezone);
03534
03535
03536 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03537 if (beg_today < time) {
03538
03539 res = wait_file(chan,ints, "digits/today",lang);
03540 } else if (beg_today - 86400 < time) {
03541
03542 res = wait_file(chan,ints, "digits/yesterday",lang);
03543 } else {
03544 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
03545 }
03546 }
03547 break;
03548 case 'q':
03549
03550 {
03551 struct timeval now;
03552 struct tm tmnow;
03553 time_t beg_today;
03554
03555 gettimeofday(&now,NULL);
03556 ast_localtime(&now.tv_sec,&tmnow,timezone);
03557
03558
03559 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03560 if (beg_today < time) {
03561
03562 } else if ((beg_today - 86400) < time) {
03563
03564 res = wait_file(chan,ints, "digits/yesterday",lang);
03565 } else if (beg_today - 86400 * 6 < time) {
03566
03567 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
03568 } else {
03569 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
03570 }
03571 }
03572 break;
03573 case 'R':
03574 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
03575 break;
03576 case 'S':
03577
03578 res = wait_file(chan,ints, "digits/and",lang);
03579 if (!res) {
03580 res = ast_say_number(chan, tm.tm_sec, ints, lang, "f");
03581 if (!res) {
03582 res = wait_file(chan,ints, "digits/seconds",lang);
03583 }
03584 }
03585 break;
03586 case 'T':
03587 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
03588 break;
03589 case ' ':
03590 case ' ':
03591
03592 break;
03593 default:
03594
03595 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03596 }
03597
03598 if (res) {
03599 break;
03600 }
03601 }
03602 return res;
03603 }
03604
03605
03606
03607
03608
03609
03610
03611
03612
03613
03614
03615
03616
03617
03618
03619
03620
03621
03622
03623
03624
03625 #define IL_DATE_STR "AdBY"
03626 #define IL_TIME_STR "IMp"
03627 #define IL_DATE_STR_FULL IL_DATE_STR " 'digits/at' " IL_TIME_STR
03628 int ast_say_date_with_format_he(struct ast_channel *chan, time_t time,
03629 const char *ints, const char *lang, const char *format,
03630 const char *timezone)
03631 {
03632
03633
03634
03635 struct tm tm;
03636 int res=0, offset, sndoffset;
03637 char sndfile[256], nextmsg[256];
03638
03639 ast_localtime(&time,&tm,timezone);
03640
03641 for (offset=0 ; format[offset] != '\0' ; offset++) {
03642 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
03643 switch (format[offset]) {
03644
03645 case '\'':
03646
03647 sndoffset=0;
03648 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
03649 sndfile[sndoffset] = format[offset];
03650 sndfile[sndoffset] = '\0';
03651 res = wait_file(chan,ints,sndfile,lang);
03652 break;
03653 case 'A':
03654 case 'a':
03655
03656 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
03657 res = wait_file(chan,ints,nextmsg,lang);
03658 break;
03659 case 'B':
03660 case 'b':
03661 case 'h':
03662
03663 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
03664 res = wait_file(chan,ints,nextmsg,lang);
03665 break;
03666 case 'd':
03667 case 'e':
03668
03669
03670
03671
03672
03673
03674
03675 res = ast_say_number_full_he(chan, tm.tm_mday,
03676 ints, lang, "m", -1, -1
03677 );
03678 break;
03679 case 'Y':
03680 res = ast_say_number_full_he(chan, tm.tm_year+1900,
03681 ints, lang, "f", -1, -1
03682 );
03683 break;
03684 case 'I':
03685 case 'l':
03686 {
03687 int hour = tm.tm_hour;
03688 hour = hour%12;
03689 if (hour == 0) hour=12;
03690
03691 res = ast_say_number_full_he(chan, hour,
03692 ints, lang, "f", -1, -1
03693 );
03694 }
03695 break;
03696 case 'H':
03697 case 'k':
03698
03699
03700 if ((format[offset] == 'H') &&
03701 (tm.tm_hour <10)&&(tm.tm_hour>0)
03702 ) {
03703 res = wait_file(chan,ints, "digits/oh",lang);
03704 }
03705
03706 res = ast_say_number_full_he(chan, tm.tm_hour,
03707 ints, lang, "f", -1, -1
03708 );
03709 break;
03710 case 'M':
03711 res = ast_say_number_full_he(chan, tm.tm_min,
03712 ints, lang,"f", -1, -1
03713 );
03714 break;
03715 case 'P':
03716 case 'p':
03717
03718 if (tm.tm_hour > 11)
03719 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
03720 else
03721 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
03722 res = wait_file(chan,ints,nextmsg,lang);
03723 break;
03724 case 'Q':
03725
03726 case 'q':
03727
03728
03729 {
03730 struct timeval now;
03731 struct tm tmnow;
03732 time_t beg_today;
03733 char todo = format[offset];
03734
03735 gettimeofday(&now,NULL);
03736 ast_localtime(&now.tv_sec,&tmnow,timezone);
03737
03738
03739 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03740 if (beg_today < time) {
03741
03742 if (todo == 'Q') {
03743 res = wait_file(chan,
03744 ints,
03745 "digits/today",
03746 lang);
03747 }
03748 } else if (beg_today - 86400 < time) {
03749
03750 res = wait_file(chan,ints, "digits/yesterday",lang);
03751 } else if ((todo != 'Q') &&
03752 (beg_today - 86400 * 6 < time))
03753 {
03754
03755 res = ast_say_date_with_format_he(chan,
03756 time, ints, lang,
03757 "A", timezone);
03758 } else {
03759 res = ast_say_date_with_format_he(chan,
03760 time, ints, lang,
03761 IL_DATE_STR, timezone);
03762 }
03763 }
03764 break;
03765 case 'R':
03766 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
03767 break;
03768 case 'S':
03769 res = ast_say_number_full_he(chan, tm.tm_sec,
03770 ints, lang, "f", -1, -1
03771 );
03772 break;
03773 case 'T':
03774 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
03775 break;
03776
03777
03778 case 'c':
03779 res = ast_say_date_with_format_he(chan, time,
03780 ints, lang, IL_DATE_STR_FULL, timezone);
03781 break;
03782 case 'x':
03783 res = ast_say_date_with_format_he(chan, time,
03784 ints, lang, IL_DATE_STR, timezone);
03785 break;
03786 case 'X':
03787 res = ast_say_date_with_format_he(chan, time,
03788 ints, lang, IL_TIME_STR, timezone);
03789 break;
03790 case ' ':
03791 case ' ':
03792
03793 break;
03794 default:
03795
03796 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03797 }
03798
03799 if (res) {
03800 break;
03801 }
03802 }
03803 return res;
03804 }
03805
03806
03807
03808 int ast_say_date_with_format_es(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
03809 {
03810 struct tm tm;
03811 int res=0, offset, sndoffset;
03812 char sndfile[256], nextmsg[256];
03813
03814 ast_localtime(&time,&tm,timezone);
03815
03816 for (offset=0 ; format[offset] != '\0' ; offset++) {
03817 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
03818 switch (format[offset]) {
03819
03820 case '\'':
03821
03822 sndoffset=0;
03823 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
03824 sndfile[sndoffset] = format[offset];
03825 sndfile[sndoffset] = '\0';
03826 snprintf(nextmsg,sizeof(nextmsg), "%s", sndfile);
03827 res = wait_file(chan,ints,nextmsg,lang);
03828 break;
03829 case 'A':
03830 case 'a':
03831
03832 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
03833 res = wait_file(chan,ints,nextmsg,lang);
03834 break;
03835 case 'B':
03836 case 'b':
03837 case 'h':
03838
03839 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
03840 res = wait_file(chan,ints,nextmsg,lang);
03841 break;
03842 case 'm':
03843
03844 if (!strcasecmp(lang, "pt_BR")) {
03845 res = ast_say_number(chan, tm.tm_mon+1, ints, lang, (char *) NULL);
03846 } else {
03847 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
03848 res = wait_file(chan,ints,nextmsg,lang);
03849 }
03850 break;
03851 case 'd':
03852 case 'e':
03853
03854 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
03855 break;
03856 case 'Y':
03857
03858 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
03859 break;
03860 case 'I':
03861 case 'l':
03862
03863 if (tm.tm_hour == 0)
03864 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
03865 else if (tm.tm_hour > 12)
03866 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
03867 else
03868 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
03869 res = wait_file(chan,ints,nextmsg,lang);
03870 break;
03871 case 'H':
03872 case 'k':
03873
03874 res = ast_say_number(chan, tm.tm_hour, ints, lang, NULL);
03875 break;
03876 case 'M':
03877
03878 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
03879 break;
03880 case 'P':
03881 case 'p':
03882
03883 if (tm.tm_hour > 12)
03884 res = wait_file(chan, ints, "digits/p-m", lang);
03885 else if (tm.tm_hour && tm.tm_hour < 12)
03886 res = wait_file(chan, ints, "digits/a-m", lang);
03887 break;
03888 case 'Q':
03889
03890 {
03891 struct timeval now;
03892 struct tm tmnow;
03893 time_t beg_today;
03894
03895 gettimeofday(&now,NULL);
03896 ast_localtime(&now.tv_sec,&tmnow,timezone);
03897
03898
03899 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03900 if (beg_today < time) {
03901
03902 res = wait_file(chan,ints, "digits/today",lang);
03903 } else if (beg_today - 86400 < time) {
03904
03905 res = wait_file(chan,ints, "digits/yesterday",lang);
03906 } else {
03907 res = ast_say_date_with_format(chan, time, ints, lang, "'digits/es-el' Ad 'digits/es-de' B 'digits/es-de' Y", timezone);
03908 }
03909 }
03910 break;
03911 case 'q':
03912
03913 {
03914 struct timeval now;
03915 struct tm tmnow;
03916 time_t beg_today;
03917
03918 gettimeofday(&now,NULL);
03919 ast_localtime(&now.tv_sec,&tmnow,timezone);
03920
03921
03922 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
03923 if (beg_today < time) {
03924
03925 res = wait_file(chan,ints, "digits/today",lang);
03926 } else if ((beg_today - 86400) < time) {
03927
03928 res = wait_file(chan,ints, "digits/yesterday",lang);
03929 } else if (beg_today - 86400 * 6 < time) {
03930
03931 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
03932 } else {
03933 res = ast_say_date_with_format(chan, time, ints, lang, "'digits/es-el' Ad 'digits/es-de' B 'digits/es-de' Y", timezone);
03934 }
03935 }
03936 break;
03937 case 'R':
03938 res = ast_say_date_with_format(chan, time, ints, lang, "H 'digits/y' M", timezone);
03939 break;
03940 case 'S':
03941
03942 if (tm.tm_sec == 0) {
03943 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
03944 res = wait_file(chan,ints,nextmsg,lang);
03945 } else if (tm.tm_sec < 10) {
03946 res = wait_file(chan,ints, "digits/oh",lang);
03947 if (!res) {
03948 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
03949 res = wait_file(chan,ints,nextmsg,lang);
03950 }
03951 } else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
03952 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
03953 res = wait_file(chan,ints,nextmsg,lang);
03954 } else {
03955 int ten, one;
03956 ten = (tm.tm_sec / 10) * 10;
03957 one = (tm.tm_sec % 10);
03958 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten);
03959 res = wait_file(chan,ints,nextmsg,lang);
03960 if (!res) {
03961
03962 if (one != 0) {
03963 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
03964 res = wait_file(chan,ints,nextmsg,lang);
03965 }
03966 }
03967 }
03968 break;
03969 case 'T':
03970 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
03971 break;
03972 case ' ':
03973 case ' ':
03974
03975 break;
03976 default:
03977
03978 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
03979 }
03980
03981 if (res) {
03982 break;
03983 }
03984 }
03985 return res;
03986 }
03987
03988
03989
03990
03991 int ast_say_date_with_format_fr(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
03992 {
03993 struct tm tm;
03994 int res=0, offset, sndoffset;
03995 char sndfile[256], nextmsg[256];
03996
03997 ast_localtime(&time,&tm,timezone);
03998
03999 for (offset=0 ; format[offset] != '\0' ; offset++) {
04000 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
04001 switch (format[offset]) {
04002
04003 case '\'':
04004
04005 sndoffset=0;
04006 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
04007 sndfile[sndoffset] = format[offset];
04008 sndfile[sndoffset] = '\0';
04009 res = wait_file(chan,ints,sndfile,lang);
04010 break;
04011 case 'A':
04012 case 'a':
04013
04014 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
04015 res = wait_file(chan,ints,nextmsg,lang);
04016 break;
04017 case 'B':
04018 case 'b':
04019 case 'h':
04020
04021 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
04022 res = wait_file(chan,ints,nextmsg,lang);
04023 break;
04024 case 'm':
04025
04026 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
04027 res = wait_file(chan,ints,nextmsg,lang);
04028 break;
04029 case 'd':
04030 case 'e':
04031
04032 if (tm.tm_mday == 1) {
04033 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mday);
04034 res = wait_file(chan,ints,nextmsg,lang);
04035 } else {
04036 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char * ) NULL);
04037 }
04038 break;
04039 case 'Y':
04040
04041 if (tm.tm_year > 99) {
04042 res = wait_file(chan,ints, "digits/2",lang);
04043 if (!res) {
04044 res = wait_file(chan,ints, "digits/thousand",lang);
04045 }
04046 if (tm.tm_year > 100) {
04047 if (!res) {
04048 res = ast_say_number(chan, tm.tm_year - 100, ints, lang, (char * ) NULL);
04049 }
04050 }
04051 } else {
04052 if (tm.tm_year < 1) {
04053
04054
04055 } else {
04056 res = wait_file(chan,ints, "digits/thousand",lang);
04057 if (!res) {
04058 wait_file(chan,ints, "digits/9",lang);
04059 wait_file(chan,ints, "digits/hundred",lang);
04060 res = ast_say_number(chan, tm.tm_year, ints, lang, (char * ) NULL);
04061 }
04062 }
04063 }
04064 break;
04065 case 'I':
04066 case 'l':
04067
04068 if (tm.tm_hour == 0)
04069 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
04070 else if (tm.tm_hour > 12)
04071 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
04072 else
04073 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
04074 res = wait_file(chan,ints,nextmsg,lang);
04075 if (!res)
04076 res = wait_file(chan,ints, "digits/oclock",lang);
04077 break;
04078 case 'H':
04079 case 'k':
04080
04081 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char * ) NULL);
04082 if (!res) {
04083 if (format[offset] == 'H') {
04084 res = wait_file(chan,ints, "digits/oclock",lang);
04085 }
04086 }
04087 if (!res)
04088 res = wait_file(chan,ints, "digits/oclock",lang);
04089 break;
04090 case 'M':
04091
04092 if (tm.tm_min == 0) {
04093 break;
04094 }
04095 res = ast_say_number(chan, tm.tm_min, ints, lang, (char * ) NULL);
04096 break;
04097 case 'P':
04098 case 'p':
04099
04100 if (tm.tm_hour > 11)
04101 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
04102 else
04103 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
04104 res = wait_file(chan,ints,nextmsg,lang);
04105 break;
04106 case 'Q':
04107
04108 {
04109 struct timeval now;
04110 struct tm tmnow;
04111 time_t beg_today;
04112
04113 gettimeofday(&now,NULL);
04114 ast_localtime(&now.tv_sec,&tmnow,timezone);
04115
04116
04117 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04118 if (beg_today < time) {
04119
04120 res = wait_file(chan,ints, "digits/today",lang);
04121 } else if (beg_today - 86400 < time) {
04122
04123 res = wait_file(chan,ints, "digits/yesterday",lang);
04124 } else {
04125 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
04126 }
04127 }
04128 break;
04129 case 'q':
04130
04131 {
04132 struct timeval now;
04133 struct tm tmnow;
04134 time_t beg_today;
04135
04136 gettimeofday(&now,NULL);
04137 ast_localtime(&now.tv_sec,&tmnow,timezone);
04138
04139
04140 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04141 if (beg_today < time) {
04142
04143 } else if ((beg_today - 86400) < time) {
04144
04145 res = wait_file(chan,ints, "digits/yesterday",lang);
04146 } else if (beg_today - 86400 * 6 < time) {
04147
04148 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
04149 } else {
04150 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
04151 }
04152 }
04153 break;
04154 case 'R':
04155 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
04156 break;
04157 case 'S':
04158
04159 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char * ) NULL);
04160 if (!res) {
04161 res = wait_file(chan,ints, "digits/second",lang);
04162 }
04163 break;
04164 case 'T':
04165 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
04166 break;
04167 case ' ':
04168 case ' ':
04169
04170 break;
04171 default:
04172
04173 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
04174 }
04175
04176 if (res) {
04177 break;
04178 }
04179 }
04180 return res;
04181 }
04182
04183 int ast_say_date_with_format_it(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
04184 {
04185 struct tm tm;
04186 int res=0, offset, sndoffset;
04187 char sndfile[256], nextmsg[256];
04188
04189 ast_localtime(&time,&tm,timezone);
04190
04191 for (offset=0 ; format[offset] != '\0' ; offset++) {
04192 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
04193 switch (format[offset]) {
04194
04195 case '\'':
04196
04197 sndoffset=0;
04198 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
04199 sndfile[sndoffset] = format[offset];
04200 sndfile[sndoffset] = '\0';
04201 res = wait_file(chan,ints,sndfile,lang);
04202 break;
04203 case 'A':
04204 case 'a':
04205
04206 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
04207 res = wait_file(chan,ints,nextmsg,lang);
04208 break;
04209 case 'B':
04210 case 'b':
04211 case 'h':
04212
04213 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
04214 res = wait_file(chan,ints,nextmsg,lang);
04215 break;
04216 case 'm':
04217
04218 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
04219 res = wait_file(chan,ints,nextmsg,lang);
04220 break;
04221 case 'd':
04222 case 'e':
04223
04224 if (tm.tm_mday == 1) {
04225 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mday);
04226 res = wait_file(chan,ints,nextmsg,lang);
04227 } else {
04228 if (!res) {
04229 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
04230 }
04231 }
04232 break;
04233 case 'Y':
04234
04235 if (tm.tm_year > 99) {
04236 res = wait_file(chan,ints, "digits/ore-2000",lang);
04237 if (tm.tm_year > 100) {
04238 if (!res) {
04239
04240 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year - 100);
04241 res = wait_file(chan,ints,nextmsg,lang);
04242 }
04243 }
04244 } else {
04245 if (tm.tm_year < 1) {
04246
04247
04248 } else {
04249 res = wait_file(chan,ints, "digits/ore-1900",lang);
04250 if ((!res) && (tm.tm_year != 0)) {
04251 if (tm.tm_year <= 21) {
04252
04253 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
04254 res = wait_file(chan,ints,nextmsg,lang);
04255 } else {
04256
04257 int ten, one;
04258 ten = tm.tm_year / 10;
04259 one = tm.tm_year % 10;
04260 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten * 10);
04261 res = wait_file(chan,ints,nextmsg,lang);
04262 if (!res) {
04263 if (one != 0) {
04264 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
04265 res = wait_file(chan,ints,nextmsg,lang);
04266 }
04267 }
04268 }
04269 }
04270 }
04271 }
04272 break;
04273 case 'I':
04274 case 'l':
04275
04276 if (tm.tm_hour == 0)
04277 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
04278 else if (tm.tm_hour > 12)
04279 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
04280 else
04281 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
04282 res = wait_file(chan,ints,nextmsg,lang);
04283 break;
04284 case 'H':
04285 case 'k':
04286
04287 if (tm.tm_hour == 0) {
04288 res = wait_file(chan,ints, "digits/ore-mezzanotte",lang);
04289 } else if (tm.tm_hour == 1) {
04290 res = wait_file(chan,ints, "digits/ore-una",lang);
04291 } else {
04292 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char *) NULL);
04293 }
04294 break;
04295 case 'M':
04296
04297 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
04298 break;
04299 case 'P':
04300 case 'p':
04301
04302 if (tm.tm_hour > 11)
04303 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
04304 else
04305 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
04306 res = wait_file(chan,ints,nextmsg,lang);
04307 break;
04308 case 'Q':
04309
04310 {
04311 struct timeval now;
04312 struct tm tmnow;
04313 time_t beg_today;
04314
04315 gettimeofday(&now,NULL);
04316 ast_localtime(&now.tv_sec,&tmnow,timezone);
04317
04318
04319 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04320 if (beg_today < time) {
04321
04322 res = wait_file(chan,ints, "digits/today",lang);
04323 } else if (beg_today - 86400 < time) {
04324
04325 res = wait_file(chan,ints, "digits/yesterday",lang);
04326 } else {
04327 res = ast_say_date_with_format(chan, time, ints, lang, "AdB", timezone);
04328 }
04329 }
04330 break;
04331 case 'q':
04332
04333 {
04334 struct timeval now;
04335 struct tm tmnow;
04336 time_t beg_today;
04337
04338 gettimeofday(&now,NULL);
04339 ast_localtime(&now.tv_sec,&tmnow,timezone);
04340
04341
04342 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04343 if (beg_today < time) {
04344
04345 } else if ((beg_today - 86400) < time) {
04346
04347 res = wait_file(chan,ints, "digits/yesterday",lang);
04348 } else if (beg_today - 86400 * 6 < time) {
04349
04350 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
04351 } else {
04352 res = ast_say_date_with_format(chan, time, ints, lang, "AdB", timezone);
04353 }
04354 }
04355 break;
04356 case 'R':
04357 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
04358 break;
04359 case 'S':
04360
04361 if (tm.tm_sec == 0) {
04362 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04363 res = wait_file(chan,ints,nextmsg,lang);
04364 } else if (tm.tm_sec < 10) {
04365 res = wait_file(chan,ints, "digits/oh",lang);
04366 if (!res) {
04367 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04368 res = wait_file(chan,ints,nextmsg,lang);
04369 }
04370 } else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
04371 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04372 res = wait_file(chan,ints,nextmsg,lang);
04373 } else {
04374 int ten, one;
04375 ten = (tm.tm_sec / 10) * 10;
04376 one = (tm.tm_sec % 10);
04377 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten);
04378 res = wait_file(chan,ints,nextmsg,lang);
04379 if (!res) {
04380
04381 if (one != 0) {
04382 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
04383 res = wait_file(chan,ints,nextmsg,lang);
04384 }
04385 }
04386 }
04387 break;
04388 case 'T':
04389 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
04390 break;
04391 case ' ':
04392 case ' ':
04393
04394 break;
04395 default:
04396
04397 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
04398 }
04399
04400 if (res) {
04401 break;
04402 }
04403 }
04404 return res;
04405 }
04406
04407
04408 int ast_say_date_with_format_nl(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
04409 {
04410 struct tm tm;
04411 int res=0, offset, sndoffset;
04412 char sndfile[256], nextmsg[256];
04413
04414 ast_localtime(&time,&tm,timezone);
04415
04416 for (offset=0 ; format[offset] != '\0' ; offset++) {
04417 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
04418 switch (format[offset]) {
04419
04420 case '\'':
04421
04422 sndoffset=0;
04423 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
04424 sndfile[sndoffset] = format[offset];
04425 sndfile[sndoffset] = '\0';
04426 res = wait_file(chan,ints,sndfile,lang);
04427 break;
04428 case 'A':
04429 case 'a':
04430
04431 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
04432 res = wait_file(chan,ints,nextmsg,lang);
04433 break;
04434 case 'B':
04435 case 'b':
04436 case 'h':
04437
04438 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
04439 res = wait_file(chan,ints,nextmsg,lang);
04440 break;
04441 case 'm':
04442
04443 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
04444 res = wait_file(chan,ints,nextmsg,lang);
04445 break;
04446 case 'd':
04447 case 'e':
04448
04449 res = ast_say_number(chan, tm.tm_mday, ints, lang, NULL);
04450 break;
04451 case 'Y':
04452
04453 if (tm.tm_year > 99) {
04454 res = wait_file(chan,ints, "digits/2",lang);
04455 if (!res) {
04456 res = wait_file(chan,ints, "digits/thousand",lang);
04457 }
04458 if (tm.tm_year > 100) {
04459 if (!res) {
04460
04461 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year - 100);
04462 res = wait_file(chan,ints,nextmsg,lang);
04463 }
04464 }
04465 } else {
04466 if (tm.tm_year < 1) {
04467
04468
04469 } else {
04470 res = wait_file(chan,ints, "digits/19",lang);
04471 if (!res) {
04472 if (tm.tm_year <= 9) {
04473
04474 res = wait_file(chan,ints, "digits/oh",lang);
04475 if (!res) {
04476 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
04477 res = wait_file(chan,ints,nextmsg,lang);
04478 }
04479 } else if (tm.tm_year <= 20) {
04480
04481 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
04482 res = wait_file(chan,ints,nextmsg,lang);
04483 } else {
04484
04485 int ten, one;
04486 ten = tm.tm_year / 10;
04487 one = tm.tm_year % 10;
04488 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten * 10);
04489 res = wait_file(chan,ints,nextmsg,lang);
04490 if (!res) {
04491 if (one != 0) {
04492 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
04493 res = wait_file(chan,ints,nextmsg,lang);
04494 }
04495 }
04496 }
04497 }
04498 }
04499 }
04500 break;
04501 case 'I':
04502 case 'l':
04503
04504 if (tm.tm_hour == 0)
04505 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
04506 else if (tm.tm_hour > 12)
04507 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
04508 else
04509 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
04510 res = wait_file(chan,ints,nextmsg,lang);
04511 break;
04512 case 'H':
04513 case 'k':
04514
04515 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char *) NULL);
04516 if (!res) {
04517 res = wait_file(chan,ints, "digits/nl-uur",lang);
04518 }
04519 break;
04520 case 'M':
04521
04522 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
04523 break;
04524 case 'P':
04525 case 'p':
04526
04527 if (tm.tm_hour > 11)
04528 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
04529 else
04530 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
04531 res = wait_file(chan,ints,nextmsg,lang);
04532 break;
04533 case 'Q':
04534
04535 {
04536 struct timeval now;
04537 struct tm tmnow;
04538 time_t beg_today;
04539
04540 gettimeofday(&now,NULL);
04541 ast_localtime(&now.tv_sec,&tmnow,timezone);
04542
04543
04544 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04545 if (beg_today < time) {
04546
04547 res = wait_file(chan,ints, "digits/today",lang);
04548 } else if (beg_today - 86400 < time) {
04549
04550 res = wait_file(chan,ints, "digits/yesterday",lang);
04551 } else {
04552 res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
04553 }
04554 }
04555 break;
04556 case 'q':
04557
04558 {
04559 struct timeval now;
04560 struct tm tmnow;
04561 time_t beg_today;
04562
04563 gettimeofday(&now,NULL);
04564 ast_localtime(&now.tv_sec,&tmnow,timezone);
04565
04566
04567 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04568 if (beg_today < time) {
04569
04570 } else if ((beg_today - 86400) < time) {
04571
04572 res = wait_file(chan,ints, "digits/yesterday",lang);
04573 } else if (beg_today - 86400 * 6 < time) {
04574
04575 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
04576 } else {
04577 res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
04578 }
04579 }
04580 break;
04581 case 'R':
04582 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
04583 break;
04584 case 'S':
04585
04586 if (tm.tm_sec == 0) {
04587 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04588 res = wait_file(chan,ints,nextmsg,lang);
04589 } else if (tm.tm_sec < 10) {
04590 res = wait_file(chan,ints, "digits/oh",lang);
04591 if (!res) {
04592 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04593 res = wait_file(chan,ints,nextmsg,lang);
04594 }
04595 } else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
04596 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04597 res = wait_file(chan,ints,nextmsg,lang);
04598 } else {
04599 int ten, one;
04600 ten = (tm.tm_sec / 10) * 10;
04601 one = (tm.tm_sec % 10);
04602 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten);
04603 res = wait_file(chan,ints,nextmsg,lang);
04604 if (!res) {
04605
04606 if (one != 0) {
04607 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
04608 res = wait_file(chan,ints,nextmsg,lang);
04609 }
04610 }
04611 }
04612 break;
04613 case 'T':
04614 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
04615 break;
04616 case ' ':
04617 case ' ':
04618
04619 break;
04620 default:
04621
04622 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
04623 }
04624
04625 if (res) {
04626 break;
04627 }
04628 }
04629 return res;
04630 }
04631
04632
04633 int ast_say_date_with_format_pt(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
04634 {
04635 struct tm tm;
04636 int res=0, offset, sndoffset;
04637 char sndfile[256], nextmsg[256];
04638
04639 ast_localtime(&time,&tm,timezone);
04640
04641 for (offset=0 ; format[offset] != '\0' ; offset++) {
04642 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
04643 switch (format[offset]) {
04644
04645 case '\'':
04646
04647 sndoffset=0;
04648 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
04649 sndfile[sndoffset] = format[offset];
04650 sndfile[sndoffset] = '\0';
04651 snprintf(nextmsg,sizeof(nextmsg), "%s", sndfile);
04652 res = wait_file(chan,ints,nextmsg,lang);
04653 break;
04654 case 'A':
04655 case 'a':
04656
04657 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
04658 res = wait_file(chan,ints,nextmsg,lang);
04659 break;
04660 case 'B':
04661 case 'b':
04662 case 'h':
04663
04664 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
04665 res = wait_file(chan,ints,nextmsg,lang);
04666 break;
04667 case 'm':
04668
04669 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
04670 res = wait_file(chan,ints,nextmsg,lang);
04671 break;
04672 case 'd':
04673 case 'e':
04674
04675 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
04676 break;
04677 case 'Y':
04678
04679 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
04680 break;
04681 case 'I':
04682 case 'l':
04683
04684 if (!strcasecmp(lang, "pt_BR")) {
04685 if (tm.tm_hour == 0) {
04686 if (format[offset] == 'I')
04687 res = wait_file(chan, ints, "digits/pt-a", lang);
04688 if (!res)
04689 res = wait_file(chan, ints, "digits/pt-meianoite", lang);
04690 } else if (tm.tm_hour == 12) {
04691 if (format[offset] == 'I')
04692 res = wait_file(chan, ints, "digits/pt-ao", lang);
04693 if (!res)
04694 res = wait_file(chan, ints, "digits/pt-meiodia", lang);
04695 } else {
04696 if (format[offset] == 'I') {
04697 if ((tm.tm_hour % 12) != 1)
04698 res = wait_file(chan, ints, "digits/pt-as", lang);
04699 else
04700 res = wait_file(chan, ints, "digits/pt-a", lang);
04701 }
04702 if (!res)
04703 res = ast_say_number(chan, (tm.tm_hour % 12), ints, lang, "f");
04704 if ((!res) && (format[offset] == 'I'))
04705 res = ast_say_date_with_format(chan, time, ints, lang, "P", timezone);
04706 }
04707 } else {
04708 if (tm.tm_hour == 0) {
04709 if (format[offset] == 'I')
04710 res = wait_file(chan, ints, "digits/pt-ah", lang);
04711 if (!res)
04712 res = wait_file(chan, ints, "digits/pt-meianoite", lang);
04713 }
04714 else if (tm.tm_hour == 12) {
04715 if (format[offset] == 'I')
04716 res = wait_file(chan, ints, "digits/pt-ao", lang);
04717 if (!res)
04718 res = wait_file(chan, ints, "digits/pt-meiodia", lang);
04719 }
04720 else {
04721 if (format[offset] == 'I') {
04722 res = wait_file(chan, ints, "digits/pt-ah", lang);
04723 if ((tm.tm_hour % 12) != 1)
04724 if (!res)
04725 res = wait_file(chan, ints, "digits/pt-sss", lang);
04726 }
04727 if (!res)
04728 res = ast_say_number(chan, (tm.tm_hour % 12), ints, lang, "f");
04729 }
04730 }
04731 break;
04732 case 'H':
04733 case 'k':
04734
04735 if (!strcasecmp(lang, "pt_BR")) {
04736 res = ast_say_number(chan, tm.tm_hour, ints, lang, "f");
04737 if ((!res) && (format[offset] == 'H')) {
04738 if (tm.tm_hour > 1) {
04739 res = wait_file(chan,ints,"digits/hours",lang);
04740 } else {
04741 res = wait_file(chan,ints,"digits/hour",lang);
04742 }
04743 }
04744 } else {
04745 res = ast_say_number(chan, -tm.tm_hour, ints, lang, NULL);
04746 if (!res) {
04747 if (tm.tm_hour != 0) {
04748 int remainder = tm.tm_hour;
04749 if (tm.tm_hour > 20) {
04750 res = wait_file(chan,ints, "digits/20",lang);
04751 remainder -= 20;
04752 }
04753 if (!res) {
04754 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", remainder);
04755 res = wait_file(chan,ints,nextmsg,lang);
04756 }
04757 }
04758 }
04759 }
04760 break;
04761 case 'M':
04762
04763 if (!strcasecmp(lang, "pt_BR")) {
04764 res = ast_say_number(chan, tm.tm_min, ints, lang, NULL);
04765 if (!res) {
04766 if (tm.tm_min > 1) {
04767 res = wait_file(chan,ints,"digits/minutes",lang);
04768 } else {
04769 res = wait_file(chan,ints,"digits/minute",lang);
04770 }
04771 }
04772 } else {
04773 if (tm.tm_min == 0) {
04774 res = wait_file(chan, ints, "digits/pt-hora", lang);
04775 if (tm.tm_hour != 1)
04776 if (!res)
04777 res = wait_file(chan, ints, "digits/pt-sss", lang); } else {
04778 res = wait_file(chan,ints,"digits/pt-e",lang);
04779 if (!res)
04780 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
04781 }
04782 }
04783 break;
04784 case 'P':
04785 case 'p':
04786
04787 if (!strcasecmp(lang, "pt_BR")) {
04788 if ((tm.tm_hour != 0) && (tm.tm_hour != 12)) {
04789 res = wait_file(chan, ints, "digits/pt-da", lang);
04790 if (!res) {
04791 if ((tm.tm_hour >= 0) && (tm.tm_hour < 12))
04792 res = wait_file(chan, ints, "digits/morning", lang);
04793 else if ((tm.tm_hour >= 12) && (tm.tm_hour < 18))
04794 res = wait_file(chan, ints, "digits/afternoon", lang);
04795 else res = wait_file(chan, ints, "digits/night", lang);
04796 }
04797 }
04798 } else {
04799 if (tm.tm_hour > 12)
04800 res = wait_file(chan, ints, "digits/p-m", lang);
04801 else if (tm.tm_hour && tm.tm_hour < 12)
04802 res = wait_file(chan, ints, "digits/a-m", lang);
04803 }
04804 break;
04805 case 'Q':
04806
04807 {
04808 struct timeval now;
04809 struct tm tmnow;
04810 time_t beg_today;
04811
04812 gettimeofday(&now,NULL);
04813 ast_localtime(&now.tv_sec,&tmnow,timezone);
04814
04815
04816 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04817 if (beg_today < time) {
04818
04819 res = wait_file(chan,ints, "digits/today",lang);
04820 } else if (beg_today - 86400 < time) {
04821
04822 res = wait_file(chan,ints, "digits/yesterday",lang);
04823 } else {
04824 res = ast_say_date_with_format(chan, time, ints, lang, "Ad 'digits/pt-de' B 'digits/pt-de' Y", timezone);
04825 }
04826 }
04827 break;
04828 case 'q':
04829
04830 {
04831 struct timeval now;
04832 struct tm tmnow;
04833 time_t beg_today;
04834
04835 gettimeofday(&now,NULL);
04836 ast_localtime(&now.tv_sec,&tmnow,timezone);
04837
04838
04839 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
04840 if (beg_today < time) {
04841
04842 } else if ((beg_today - 86400) < time) {
04843
04844 res = wait_file(chan,ints, "digits/yesterday",lang);
04845 } else if (beg_today - 86400 * 6 < time) {
04846
04847 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
04848 } else {
04849 res = ast_say_date_with_format(chan, time, ints, lang, "Ad 'digits/pt-de' B 'digits/pt-de' Y", timezone);
04850 }
04851 }
04852 break;
04853 case 'R':
04854 res = ast_say_date_with_format(chan, time, ints, lang, "H 'digits/pt-e' M", timezone);
04855 break;
04856 case 'S':
04857
04858 if (!strcasecmp(lang, "pt_BR")) {
04859 res = ast_say_number(chan, tm.tm_sec, ints, lang, NULL);
04860 if (!res) {
04861 if (tm.tm_sec > 1) {
04862 res = wait_file(chan,ints,"digits/seconds",lang);
04863 } else {
04864 res = wait_file(chan,ints,"digits/second",lang);
04865 }
04866 }
04867 } else {
04868 if (tm.tm_sec == 0) {
04869 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04870 res = wait_file(chan,ints,nextmsg,lang);
04871 } else if (tm.tm_sec < 10) {
04872 res = wait_file(chan,ints, "digits/oh",lang);
04873 if (!res) {
04874 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04875 res = wait_file(chan,ints,nextmsg,lang);
04876 }
04877 } else if ((tm.tm_sec < 21) || (tm.tm_sec % 10 == 0)) {
04878 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
04879 res = wait_file(chan,ints,nextmsg,lang);
04880 } else {
04881 int ten, one;
04882 ten = (tm.tm_sec / 10) * 10;
04883 one = (tm.tm_sec % 10);
04884 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", ten);
04885 res = wait_file(chan,ints,nextmsg,lang);
04886 if (!res) {
04887
04888 if (one != 0) {
04889 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", one);
04890 res = wait_file(chan,ints,nextmsg,lang);
04891 }
04892 }
04893 }
04894 }
04895 break;
04896 case 'T':
04897 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
04898 break;
04899 case ' ':
04900 case ' ':
04901
04902 break;
04903 default:
04904
04905 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
04906 }
04907
04908 if (res) {
04909 break;
04910 }
04911 }
04912 return res;
04913 }
04914
04915
04916 int ast_say_date_with_format_tw(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
04917 {
04918 struct tm tm;
04919 int res=0, offset, sndoffset;
04920 char sndfile[256], nextmsg[256];
04921
04922 ast_localtime(&time,&tm,timezone);
04923
04924 for (offset=0 ; format[offset] != '\0' ; offset++) {
04925 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
04926 switch (format[offset]) {
04927
04928 case '\'':
04929
04930 sndoffset=0;
04931 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
04932 sndfile[sndoffset] = format[offset];
04933 sndfile[sndoffset] = '\0';
04934 res = wait_file(chan,ints,sndfile,lang);
04935 break;
04936 case 'A':
04937 case 'a':
04938
04939 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
04940 res = wait_file(chan,ints,nextmsg,lang);
04941 break;
04942 case 'B':
04943 case 'b':
04944 case 'h':
04945
04946 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
04947 res = wait_file(chan,ints,nextmsg,lang);
04948 break;
04949 case 'm':
04950
04951 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mon +1);
04952 res = wait_file(chan,ints,nextmsg,lang);
04953 break;
04954 case 'd':
04955 case 'e':
04956
04957 if (!(tm.tm_mday % 10) || (tm.tm_mday < 10)) {
04958 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mday);
04959 res = wait_file(chan,ints,nextmsg,lang);
04960 } else {
04961 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%dh", tm.tm_mday - (tm.tm_mday % 10));
04962 res = wait_file(chan,ints,nextmsg,lang);
04963 if(!res) {
04964 snprintf(nextmsg,sizeof(nextmsg), "digits/h-%d", tm.tm_mday % 10);
04965 res = wait_file(chan,ints,nextmsg,lang);
04966 }
04967 }
04968 break;
04969 case 'Y':
04970
04971 if (tm.tm_year > 99) {
04972 res = wait_file(chan,ints, "digits/2",lang);
04973 if (!res) {
04974 res = wait_file(chan,ints, "digits/thousand",lang);
04975 }
04976 if (tm.tm_year > 100) {
04977 if (!res) {
04978 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", (tm.tm_year - 100) / 10);
04979 res = wait_file(chan,ints,nextmsg,lang);
04980 if (!res) {
04981 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", (tm.tm_year - 100) % 10);
04982 res = wait_file(chan,ints,nextmsg,lang);
04983 }
04984 }
04985 }
04986 if (!res) {
04987 res = wait_file(chan,ints, "digits/year",lang);
04988 }
04989 } else {
04990 if (tm.tm_year < 1) {
04991
04992
04993 } else {
04994 res = wait_file(chan,ints, "digits/1",lang);
04995 if (!res) {
04996 res = wait_file(chan,ints, "digits/9",lang);
04997 }
04998 if (!res) {
04999 if (tm.tm_year <= 9) {
05000
05001 res = wait_file(chan,ints, "digits/0",lang);
05002 if (!res) {
05003 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year);
05004 res = wait_file(chan,ints,nextmsg,lang);
05005 }
05006 } else {
05007
05008 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year / 10);
05009 res = wait_file(chan,ints,nextmsg,lang);
05010 if (!res) {
05011 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_year % 10);
05012 res = wait_file(chan,ints,nextmsg,lang);
05013 }
05014 }
05015 }
05016 }
05017 if (!res) {
05018 res = wait_file(chan,ints, "digits/year",lang);
05019 }
05020 }
05021 break;
05022 case 'I':
05023 case 'l':
05024
05025 if (tm.tm_hour == 0)
05026 snprintf(nextmsg,sizeof(nextmsg), "digits/12");
05027 else if (tm.tm_hour > 12)
05028 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - 12);
05029 else
05030 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
05031 res = wait_file(chan,ints,nextmsg,lang);
05032 if (!res) {
05033 res = wait_file(chan,ints, "digits/oclock",lang);
05034 }
05035 break;
05036 case 'H':
05037 case 'k':
05038
05039 if (!(tm.tm_hour % 10) || tm.tm_hour < 10) {
05040 if (tm.tm_hour < 10) {
05041 res = wait_file(chan, ints, "digits/0", lang);
05042 }
05043 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour);
05044 res = wait_file(chan,ints,nextmsg,lang);
05045 } else {
05046 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour - (tm.tm_hour % 10));
05047 res = wait_file(chan,ints,nextmsg,lang);
05048 if (!res) {
05049 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_hour % 10);
05050 res = wait_file(chan,ints,nextmsg,lang);
05051 }
05052 }
05053 if (!res) {
05054 res = wait_file(chan,ints, "digits/oclock",lang);
05055 }
05056 break;
05057 case 'M':
05058
05059 if (!(tm.tm_min % 10) || tm.tm_min < 10) {
05060 if (tm.tm_min < 10) {
05061 res = wait_file(chan, ints, "digits/0", lang);
05062 }
05063 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_min);
05064 res = wait_file(chan,ints,nextmsg,lang);
05065 } else {
05066 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_min - (tm.tm_min % 10));
05067 res = wait_file(chan,ints,nextmsg,lang);
05068 if (!res) {
05069 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_min % 10);
05070 res = wait_file(chan,ints,nextmsg,lang);
05071 }
05072 }
05073 if (!res) {
05074 res = wait_file(chan,ints, "digits/minute",lang);
05075 }
05076 break;
05077 case 'P':
05078 case 'p':
05079
05080 if (tm.tm_hour > 11)
05081 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
05082 else
05083 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
05084 res = wait_file(chan,ints,nextmsg,lang);
05085 break;
05086 case 'Q':
05087
05088 {
05089 struct timeval now;
05090 struct tm tmnow;
05091 time_t beg_today;
05092
05093 gettimeofday(&now,NULL);
05094 ast_localtime(&now.tv_sec,&tmnow,timezone);
05095
05096
05097 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
05098 if (beg_today < time) {
05099
05100 res = wait_file(chan,ints, "digits/today",lang);
05101 } else if (beg_today - 86400 < time) {
05102
05103 res = wait_file(chan,ints, "digits/yesterday",lang);
05104 } else {
05105 res = ast_say_date_with_format(chan, time, ints, lang, "YBdA", timezone);
05106 }
05107 }
05108 break;
05109 case 'q':
05110
05111 {
05112 struct timeval now;
05113 struct tm tmnow;
05114 time_t beg_today;
05115
05116 gettimeofday(&now,NULL);
05117 ast_localtime(&now.tv_sec,&tmnow,timezone);
05118
05119
05120 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
05121 if (beg_today < time) {
05122
05123 } else if ((beg_today - 86400) < time) {
05124
05125 res = wait_file(chan,ints, "digits/yesterday",lang);
05126 } else if (beg_today - 86400 * 6 < time) {
05127
05128 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
05129 } else {
05130 res = ast_say_date_with_format(chan, time, ints, lang, "YBdA", timezone);
05131 }
05132 }
05133 break;
05134 case 'R':
05135 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
05136 break;
05137 case 'S':
05138
05139 if (!(tm.tm_sec % 10) || tm.tm_sec < 10) {
05140 if (tm.tm_sec < 10) {
05141 res = wait_file(chan, ints, "digits/0", lang);
05142 }
05143 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec);
05144 res = wait_file(chan,ints,nextmsg,lang);
05145 } else {
05146 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec - (tm.tm_sec % 10));
05147 res = wait_file(chan,ints,nextmsg,lang);
05148 if (!res) {
05149 snprintf(nextmsg,sizeof(nextmsg), "digits/%d", tm.tm_sec % 10);
05150 res = wait_file(chan,ints,nextmsg,lang);
05151 }
05152 }
05153 if (!res) {
05154 res = wait_file(chan,ints, "digits/second",lang);
05155 }
05156 break;
05157 case 'T':
05158 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
05159 break;
05160 case ' ':
05161 case ' ':
05162
05163 break;
05164 default:
05165
05166 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
05167 }
05168
05169 if (res) {
05170 break;
05171 }
05172 }
05173 return res;
05174 }
05175
05176 int ast_say_time(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05177 {
05178 if (!strcasecmp(lang, "en") ) {
05179 return(ast_say_time_en(chan, t, ints, lang));
05180 } else if (!strcasecmp(lang, "de") ) {
05181 return(ast_say_time_de(chan, t, ints, lang));
05182 } else if (!strcasecmp(lang, "fr") ) {
05183 return(ast_say_time_fr(chan, t, ints, lang));
05184 } else if (!strcasecmp(lang, "nl") ) {
05185 return(ast_say_time_nl(chan, t, ints, lang));
05186 } else if (!strcasecmp(lang, "pt") ) {
05187 return(ast_say_time_pt(chan, t, ints, lang));
05188 } else if (!strcasecmp(lang, "pt_BR") ) {
05189 return(ast_say_time_pt_BR(chan, t, ints, lang));
05190 } else if (!strcasecmp(lang, "tw") ) {
05191 return(ast_say_time_tw(chan, t, ints, lang));
05192 } else if (!strcasecmp(lang, "gr") ) {
05193 return(ast_say_time_gr(chan, t, ints, lang));
05194 }
05195
05196
05197 return(ast_say_time_en(chan, t, ints, lang));
05198 }
05199
05200
05201 int ast_say_time_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05202 {
05203 struct tm tm;
05204 int res = 0;
05205 int hour, pm=0;
05206 localtime_r(&t,&tm);
05207 hour = tm.tm_hour;
05208 if (!hour)
05209 hour = 12;
05210 else if (hour == 12)
05211 pm = 1;
05212 else if (hour > 12) {
05213 hour -= 12;
05214 pm = 1;
05215 }
05216 if (!res)
05217 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05218
05219 if (tm.tm_min > 9) {
05220 if (!res)
05221 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05222 } else if (tm.tm_min) {
05223 if (!res)
05224 res = ast_streamfile(chan, "digits/oh", lang);
05225 if (!res)
05226 res = ast_waitstream(chan, ints);
05227 if (!res)
05228 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05229 } else {
05230 if (!res)
05231 res = ast_streamfile(chan, "digits/oclock", lang);
05232 if (!res)
05233 res = ast_waitstream(chan, ints);
05234 }
05235 if (pm) {
05236 if (!res)
05237 res = ast_streamfile(chan, "digits/p-m", lang);
05238 } else {
05239 if (!res)
05240 res = ast_streamfile(chan, "digits/a-m", lang);
05241 }
05242 if (!res)
05243 res = ast_waitstream(chan, ints);
05244 return res;
05245 }
05246
05247
05248 int ast_say_time_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05249 {
05250 struct tm tm;
05251 int res = 0;
05252 localtime_r(&t,&tm);
05253 if (!res)
05254 res = ast_say_number(chan, tm.tm_hour, ints, lang, "n");
05255 if (!res)
05256 res = ast_streamfile(chan, "digits/oclock", lang);
05257 if (!res)
05258 res = ast_waitstream(chan, ints);
05259 if (!res)
05260 if (tm.tm_min > 0)
05261 res = ast_say_number(chan, tm.tm_min, ints, lang, "f");
05262 return res;
05263 }
05264
05265
05266 int ast_say_time_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05267 {
05268 struct tm tm;
05269 int res = 0;
05270 localtime_r(&t,&tm);
05271
05272 res = ast_say_number(chan, tm.tm_hour, ints, lang, "f");
05273 if (!res)
05274 res = ast_streamfile(chan, "digits/oclock", lang);
05275 if (tm.tm_min) {
05276 if (!res)
05277 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05278 }
05279 return res;
05280 }
05281
05282
05283 int ast_say_time_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05284 {
05285 struct tm tm;
05286 int res = 0;
05287 localtime_r(&t,&tm);
05288 if (!res)
05289 res = ast_say_number(chan, tm.tm_hour, ints, lang, (char *) NULL);
05290 if (!res)
05291 res = ast_streamfile(chan, "digits/nl-uur", lang);
05292 if (!res)
05293 res = ast_waitstream(chan, ints);
05294 if (!res)
05295 if (tm.tm_min > 0)
05296 res = ast_say_number(chan, tm.tm_min, ints, lang, NULL);
05297 return res;
05298 }
05299
05300
05301 int ast_say_time_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05302 {
05303 struct tm tm;
05304 int res = 0;
05305 int hour;
05306 localtime_r(&t,&tm);
05307 hour = tm.tm_hour;
05308 if (!res)
05309 res = ast_say_number(chan, hour, ints, lang, "f");
05310 if (tm.tm_min) {
05311 if (!res)
05312 res = wait_file(chan, ints, "digits/pt-e", lang);
05313 if (!res)
05314 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05315 } else {
05316 if (!res)
05317 res = wait_file(chan, ints, "digits/pt-hora", lang);
05318 if (tm.tm_hour != 1)
05319 if (!res)
05320 res = wait_file(chan, ints, "digits/pt-sss", lang);
05321 }
05322 if (!res)
05323 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05324 return res;
05325 }
05326
05327
05328 int ast_say_time_pt_BR(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05329 {
05330 struct tm tm;
05331 int res = 0;
05332 localtime_r(&t,&tm);
05333
05334 res = ast_say_number(chan, tm.tm_hour, ints, lang, "f");
05335 if (!res) {
05336 if (tm.tm_hour > 1)
05337 res = wait_file(chan, ints, "digits/hours", lang);
05338 else
05339 res = wait_file(chan, ints, "digits/hour", lang);
05340 }
05341 if ((!res) && (tm.tm_min)) {
05342 res = wait_file(chan, ints, "digits/pt-e", lang);
05343 if (!res)
05344 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05345 if (!res) {
05346 if (tm.tm_min > 1)
05347 res = wait_file(chan, ints, "digits/minutes", lang);
05348 else
05349 res = wait_file(chan, ints, "digits/minute", lang);
05350 }
05351 }
05352 return res;
05353 }
05354
05355
05356 int ast_say_time_tw(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05357 {
05358 struct tm tm;
05359 int res = 0;
05360 int hour, pm=0;
05361 localtime_r(&t,&tm);
05362 hour = tm.tm_hour;
05363 if (!hour)
05364 hour = 12;
05365 else if (hour == 12)
05366 pm = 1;
05367 else if (hour > 12) {
05368 hour -= 12;
05369 pm = 1;
05370 }
05371 if (pm) {
05372 if (!res)
05373 res = ast_streamfile(chan, "digits/p-m", lang);
05374 } else {
05375 if (!res)
05376 res = ast_streamfile(chan, "digits/a-m", lang);
05377 }
05378 if (!res)
05379 res = ast_waitstream(chan, ints);
05380 if (!res)
05381 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05382 if (!res)
05383 res = ast_streamfile(chan, "digits/oclock", lang);
05384 if (!res)
05385 res = ast_waitstream(chan, ints);
05386 if (!res)
05387 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05388 if (!res)
05389 res = ast_streamfile(chan, "digits/minute", lang);
05390 if (!res)
05391 res = ast_waitstream(chan, ints);
05392 return res;
05393 }
05394
05395 int ast_say_datetime(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05396 {
05397 if (!strcasecmp(lang, "en") ) {
05398 return(ast_say_datetime_en(chan, t, ints, lang));
05399 } else if (!strcasecmp(lang, "de") ) {
05400 return(ast_say_datetime_de(chan, t, ints, lang));
05401 } else if (!strcasecmp(lang, "fr") ) {
05402 return(ast_say_datetime_fr(chan, t, ints, lang));
05403 } else if (!strcasecmp(lang, "nl") ) {
05404 return(ast_say_datetime_nl(chan, t, ints, lang));
05405 } else if (!strcasecmp(lang, "pt") ) {
05406 return(ast_say_datetime_pt(chan, t, ints, lang));
05407 } else if (!strcasecmp(lang, "pt_BR") ) {
05408 return(ast_say_datetime_pt_BR(chan, t, ints, lang));
05409 } else if (!strcasecmp(lang, "tw") ) {
05410 return(ast_say_datetime_tw(chan, t, ints, lang));
05411 } else if (!strcasecmp(lang, "gr") ) {
05412 return(ast_say_datetime_gr(chan, t, ints, lang));
05413 }
05414
05415
05416 return(ast_say_datetime_en(chan, t, ints, lang));
05417 }
05418
05419
05420 int ast_say_datetime_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05421 {
05422 struct tm tm;
05423 char fn[256];
05424 int res = 0;
05425 int hour, pm=0;
05426 localtime_r(&t,&tm);
05427 if (!res) {
05428 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05429 res = ast_streamfile(chan, fn, lang);
05430 if (!res)
05431 res = ast_waitstream(chan, ints);
05432 }
05433 if (!res) {
05434 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05435 res = ast_streamfile(chan, fn, lang);
05436 if (!res)
05437 res = ast_waitstream(chan, ints);
05438 }
05439 if (!res)
05440 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05441
05442 hour = tm.tm_hour;
05443 if (!hour)
05444 hour = 12;
05445 else if (hour == 12)
05446 pm = 1;
05447 else if (hour > 12) {
05448 hour -= 12;
05449 pm = 1;
05450 }
05451 if (!res)
05452 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05453
05454 if (tm.tm_min > 9) {
05455 if (!res)
05456 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05457 } else if (tm.tm_min) {
05458 if (!res)
05459 res = ast_streamfile(chan, "digits/oh", lang);
05460 if (!res)
05461 res = ast_waitstream(chan, ints);
05462 if (!res)
05463 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05464 } else {
05465 if (!res)
05466 res = ast_streamfile(chan, "digits/oclock", lang);
05467 if (!res)
05468 res = ast_waitstream(chan, ints);
05469 }
05470 if (pm) {
05471 if (!res)
05472 res = ast_streamfile(chan, "digits/p-m", lang);
05473 } else {
05474 if (!res)
05475 res = ast_streamfile(chan, "digits/a-m", lang);
05476 }
05477 if (!res)
05478 res = ast_waitstream(chan, ints);
05479 if (!res)
05480 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
05481 return res;
05482 }
05483
05484
05485 int ast_say_datetime_de(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05486 {
05487 struct tm tm;
05488 int res = 0;
05489 localtime_r(&t,&tm);
05490 res = ast_say_date(chan, t, ints, lang);
05491 if (!res)
05492 ast_say_time(chan, t, ints, lang);
05493 return res;
05494
05495 }
05496
05497
05498 int ast_say_datetime_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05499 {
05500 struct tm tm;
05501 char fn[256];
05502 int res = 0;
05503 localtime_r(&t,&tm);
05504
05505 if (!res)
05506 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05507
05508 if (!res) {
05509 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05510 res = ast_streamfile(chan, fn, lang);
05511 if (!res)
05512 res = ast_waitstream(chan, ints);
05513 }
05514 if (!res) {
05515 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05516 res = ast_streamfile(chan, fn, lang);
05517 if (!res)
05518 res = ast_waitstream(chan, ints);
05519 }
05520
05521 if (!res)
05522 res = ast_say_number(chan, tm.tm_hour, ints, lang, "f");
05523 if (!res)
05524 res = ast_streamfile(chan, "digits/oclock", lang);
05525 if (tm.tm_min > 0) {
05526 if (!res)
05527 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05528 }
05529 if (!res)
05530 res = ast_waitstream(chan, ints);
05531 if (!res)
05532 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
05533 return res;
05534 }
05535
05536
05537 int ast_say_datetime_nl(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05538 {
05539 struct tm tm;
05540 int res = 0;
05541 localtime_r(&t,&tm);
05542 res = ast_say_date(chan, t, ints, lang);
05543 if (!res) {
05544 res = ast_streamfile(chan, "digits/nl-om", lang);
05545 if (!res)
05546 res = ast_waitstream(chan, ints);
05547 }
05548 if (!res)
05549 ast_say_time(chan, t, ints, lang);
05550 return res;
05551 }
05552
05553
05554 int ast_say_datetime_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05555 {
05556 struct tm tm;
05557 char fn[256];
05558 int res = 0;
05559 int hour, pm=0;
05560 localtime_r(&t,&tm);
05561 if (!res) {
05562 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05563 res = ast_streamfile(chan, fn, lang);
05564 if (!res)
05565 res = ast_waitstream(chan, ints);
05566 }
05567 if (!res) {
05568 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05569 res = ast_streamfile(chan, fn, lang);
05570 if (!res)
05571 res = ast_waitstream(chan, ints);
05572 }
05573 if (!res)
05574 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05575
05576 hour = tm.tm_hour;
05577 if (!hour)
05578 hour = 12;
05579 else if (hour == 12)
05580 pm = 1;
05581 else if (hour > 12) {
05582 hour -= 12;
05583 pm = 1;
05584 }
05585 if (!res)
05586 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05587
05588 if (tm.tm_min > 9) {
05589 if (!res)
05590 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05591 } else if (tm.tm_min) {
05592 if (!res)
05593 res = ast_streamfile(chan, "digits/oh", lang);
05594 if (!res)
05595 res = ast_waitstream(chan, ints);
05596 if (!res)
05597 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05598 } else {
05599 if (!res)
05600 res = ast_streamfile(chan, "digits/oclock", lang);
05601 if (!res)
05602 res = ast_waitstream(chan, ints);
05603 }
05604 if (pm) {
05605 if (!res)
05606 res = ast_streamfile(chan, "digits/p-m", lang);
05607 } else {
05608 if (!res)
05609 res = ast_streamfile(chan, "digits/a-m", lang);
05610 }
05611 if (!res)
05612 res = ast_waitstream(chan, ints);
05613 if (!res)
05614 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
05615 return res;
05616 }
05617
05618
05619 int ast_say_datetime_pt_BR(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05620 {
05621 struct tm tm;
05622 int res = 0;
05623 localtime_r(&t,&tm);
05624 res = ast_say_date(chan, t, ints, lang);
05625 if (!res)
05626 res = ast_say_time(chan, t, ints, lang);
05627 return res;
05628 }
05629
05630
05631 int ast_say_datetime_tw(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05632 {
05633 struct tm tm;
05634 char fn[256];
05635 int res = 0;
05636 int hour, pm=0;
05637 localtime_r(&t,&tm);
05638 if (!res)
05639 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
05640 if (!res) {
05641 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05642 res = ast_streamfile(chan, fn, lang);
05643 if (!res)
05644 res = ast_waitstream(chan, ints);
05645 }
05646 if (!res)
05647 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05648 if (!res) {
05649 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05650 res = ast_streamfile(chan, fn, lang);
05651 if (!res)
05652 res = ast_waitstream(chan, ints);
05653 }
05654
05655 hour = tm.tm_hour;
05656 if (!hour)
05657 hour = 12;
05658 else if (hour == 12)
05659 pm = 1;
05660 else if (hour > 12) {
05661 hour -= 12;
05662 pm = 1;
05663 }
05664 if (pm) {
05665 if (!res)
05666 res = ast_streamfile(chan, "digits/p-m", lang);
05667 } else {
05668 if (!res)
05669 res = ast_streamfile(chan, "digits/a-m", lang);
05670 }
05671 if (!res)
05672 res = ast_waitstream(chan, ints);
05673 if (!res)
05674 res = ast_say_number(chan, hour, ints, lang, (char *) NULL);
05675 if (!res)
05676 res = ast_streamfile(chan, "digits/oclock", lang);
05677 if (!res)
05678 res = ast_waitstream(chan, ints);
05679 if (!res)
05680 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
05681 if (!res)
05682 res = ast_streamfile(chan, "digits/minute", lang);
05683 if (!res)
05684 res = ast_waitstream(chan, ints);
05685 return res;
05686 }
05687
05688 int ast_say_datetime_from_now(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05689 {
05690 if (!strcasecmp(lang, "en") ) {
05691 return(ast_say_datetime_from_now_en(chan, t, ints, lang));
05692 } else if (!strcasecmp(lang, "fr") ) {
05693 return(ast_say_datetime_from_now_fr(chan, t, ints, lang));
05694 } else if (!strcasecmp(lang, "pt") || !strcasecmp(lang, "pt_BR")) {
05695 return(ast_say_datetime_from_now_pt(chan, t, ints, lang));
05696 }
05697
05698
05699 return(ast_say_datetime_from_now_en(chan, t, ints, lang));
05700 }
05701
05702
05703 int ast_say_datetime_from_now_en(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05704 {
05705 int res=0;
05706 time_t nowt;
05707 int daydiff;
05708 struct tm tm;
05709 struct tm now;
05710 char fn[256];
05711
05712 time(&nowt);
05713
05714 localtime_r(&t,&tm);
05715 localtime_r(&nowt,&now);
05716 daydiff = now.tm_yday - tm.tm_yday;
05717 if ((daydiff < 0) || (daydiff > 6)) {
05718
05719 if (!res) {
05720 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05721 res = ast_streamfile(chan, fn, lang);
05722 if (!res)
05723 res = ast_waitstream(chan, ints);
05724 }
05725 if (!res)
05726 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05727
05728 } else if (daydiff) {
05729
05730 if (!res) {
05731 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05732 res = ast_streamfile(chan, fn, lang);
05733 if (!res)
05734 res = ast_waitstream(chan, ints);
05735 }
05736 }
05737 if (!res)
05738 res = ast_say_time(chan, t, ints, lang);
05739 return res;
05740 }
05741
05742
05743 int ast_say_datetime_from_now_fr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05744 {
05745 int res=0;
05746 time_t nowt;
05747 int daydiff;
05748 struct tm tm;
05749 struct tm now;
05750 char fn[256];
05751
05752 time(&nowt);
05753
05754 localtime_r(&t,&tm);
05755 localtime_r(&nowt,&now);
05756 daydiff = now.tm_yday - tm.tm_yday;
05757 if ((daydiff < 0) || (daydiff > 6)) {
05758
05759 if (!res) {
05760 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05761 res = ast_streamfile(chan, fn, lang);
05762 if (!res)
05763 res = ast_waitstream(chan, ints);
05764 }
05765 if (!res)
05766 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05767
05768 } else if (daydiff) {
05769
05770 if (!res) {
05771 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05772 res = ast_streamfile(chan, fn, lang);
05773 if (!res)
05774 res = ast_waitstream(chan, ints);
05775 }
05776 }
05777 if (!res)
05778 res = ast_say_time(chan, t, ints, lang);
05779 return res;
05780 }
05781
05782
05783 int ast_say_datetime_from_now_pt(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05784 {
05785 int res=0;
05786 time_t nowt;
05787 int daydiff;
05788 struct tm tm;
05789 struct tm now;
05790 char fn[256];
05791
05792 time(&nowt);
05793
05794 localtime_r(&t,&tm);
05795 localtime_r(&nowt,&now);
05796 daydiff = now.tm_yday - tm.tm_yday;
05797 if ((daydiff < 0) || (daydiff > 6)) {
05798
05799 if (!res)
05800 res = ast_say_number(chan, tm.tm_mday, ints, lang, (char *) NULL);
05801 if (!res)
05802 res = wait_file(chan, ints, "digits/pt-de", lang);
05803 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05804 if (!res)
05805 res = wait_file(chan, ints, fn, lang);
05806
05807 } else if (daydiff) {
05808
05809 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05810 if (!res)
05811 res = wait_file(chan, ints, fn, lang);
05812 }
05813 if (!strcasecmp(lang, "pt_BR")) {
05814 if (tm.tm_hour > 1) {
05815 snprintf(fn, sizeof(fn), "digits/pt-as");
05816 } else {
05817 snprintf(fn, sizeof(fn), "digits/pt-a");
05818 }
05819 if (!res)
05820 res = wait_file(chan, ints, fn, lang);
05821 } else {
05822 snprintf(fn, sizeof(fn), "digits/pt-ah");
05823 if (!res)
05824 res = wait_file(chan, ints, fn, lang);
05825 if (tm.tm_hour != 1)
05826 if (!res)
05827 res = wait_file(chan, ints, "digits/pt-sss", lang);
05828 if (!res)
05829 res = ast_say_time(chan, t, ints, lang);
05830 }
05831 return res;
05832 }
05833
05834
05835
05836
05837
05838
05839
05840
05841 static int gr_say_number_female(int num, struct ast_channel *chan, const char *ints, const char *lang){
05842 int tmp;
05843 int left;
05844 int res;
05845 char fn[256] = "";
05846
05847
05848 if (num < 5) {
05849 snprintf(fn, sizeof(fn), "digits/female-%d", num);
05850 res = wait_file(chan, ints, fn, lang);
05851 } else if (num < 13) {
05852 res = ast_say_number(chan, num, ints, lang, (char *) NULL);
05853 } else if (num <100 ) {
05854 tmp = (num/10) * 10;
05855 left = num - tmp;
05856 snprintf(fn, sizeof(fn), "digits/%d", tmp);
05857 res = ast_streamfile(chan, fn, lang);
05858 if (!res)
05859 res = ast_waitstream(chan, ints);
05860 if (left)
05861 gr_say_number_female(left, chan, ints, lang);
05862
05863 } else {
05864 return -1;
05865 }
05866 return res;
05867 }
05868
05869
05870
05871
05872
05873
05874
05875
05876
05877
05878
05879
05880
05881
05882
05883
05884
05885
05886
05887 static int ast_say_number_full_gr(struct ast_channel *chan, int num, const char *ints, const char *language,int audiofd, int ctrlfd)
05888 {
05889 int res = 0;
05890 char fn[256] = "";
05891 int i=0;
05892
05893
05894 if (!num) {
05895 snprintf(fn, sizeof(fn), "digits/0");
05896 res = ast_streamfile(chan, fn, chan->language);
05897 if (!res)
05898 return ast_waitstream(chan, ints);
05899 }
05900
05901 while(!res && num ) {
05902 i++;
05903 if (num < 13) {
05904 snprintf(fn, sizeof(fn), "digits/%d", num);
05905 num = 0;
05906 } else if (num <= 100) {
05907
05908 snprintf(fn, sizeof(fn), "digits/%d", (num /10) * 10);
05909 num -= ((num / 10) * 10);
05910 } else if (num < 200) {
05911
05912 snprintf(fn, sizeof(fn), "digits/hundred-100");
05913 num -= ((num / 100) * 100);
05914 }else if (num < 1000) {
05915
05916 snprintf(fn, sizeof(fn), "digits/hundred-%d", (num/100)*100);
05917 num -= ((num / 100) * 100);
05918 }else if (num < 2000){
05919 snprintf(fn, sizeof(fn), "digits/xilia");
05920 num -= ((num / 1000) * 1000);
05921 }
05922 else {
05923
05924 if (num < 1000000) {
05925 res = ast_say_number_full_gr(chan, (num / 1000), ints, chan->language, audiofd, ctrlfd);
05926 if (res)
05927 return res;
05928 num = num % 1000;
05929 snprintf(fn, sizeof(fn), "digits/thousands");
05930 } else {
05931 if (num < 1000000000) {
05932 res = ast_say_number_full_gr(chan, (num / 1000000), ints, chan->language ,audiofd, ctrlfd);
05933 if (res)
05934 return res;
05935 num = num % 1000000;
05936 snprintf(fn, sizeof(fn), "digits/millions");
05937 } else {
05938 ast_log(LOG_DEBUG, "Number '%d' is too big for me\n", num);
05939 res = -1;
05940 }
05941 }
05942 }
05943 if (!res) {
05944 if(!ast_streamfile(chan, fn, language)) {
05945 if ((audiofd > -1) && (ctrlfd > -1))
05946 res = ast_waitstream_full(chan, ints, audiofd, ctrlfd);
05947 else
05948 res = ast_waitstream(chan, ints);
05949 }
05950 ast_stopstream(chan);
05951 }
05952 }
05953 return res;
05954 }
05955
05956
05957
05958
05959
05960
05961
05962
05963
05964
05965
05966
05967
05968 static int ast_say_date_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
05969 {
05970 struct tm tm;
05971
05972 char fn[256];
05973 int res = 0;
05974
05975
05976 ast_localtime(&t,&tm,NULL);
05977
05978 if (!res) {
05979 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
05980 res = ast_streamfile(chan, fn, lang);
05981 if (!res)
05982 res = ast_waitstream(chan, ints);
05983 }
05984
05985 if (!res) {
05986 gr_say_number_female(tm.tm_mday, chan, ints, lang);
05987 }
05988
05989 if (!res) {
05990 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
05991 res = ast_streamfile(chan, fn, lang);
05992 if (!res)
05993 res = ast_waitstream(chan, ints);
05994 }
05995
05996 if (!res)
05997 res = ast_say_number(chan, tm.tm_year + 1900, ints, lang, (char *) NULL);
05998 return res;
05999 }
06000
06001
06002
06003
06004
06005
06006
06007
06008
06009
06010
06011 static int ast_say_time_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
06012 {
06013
06014 struct tm tm;
06015 int res = 0;
06016 int hour, pm=0;
06017
06018 localtime_r(&t,&tm);
06019 hour = tm.tm_hour;
06020
06021 if (!hour)
06022 hour = 12;
06023 else if (hour == 12)
06024 pm = 1;
06025 else if (hour > 12) {
06026 hour -= 12;
06027 pm = 1;
06028 }
06029
06030 res = gr_say_number_female(hour, chan, ints, lang);
06031 if (tm.tm_min) {
06032 if (!res)
06033 res = ast_streamfile(chan, "digits/kai", lang);
06034 if (!res)
06035 res = ast_waitstream(chan, ints);
06036 if (!res)
06037 res = ast_say_number(chan, tm.tm_min, ints, lang, (char *) NULL);
06038 } else {
06039 if (!res)
06040 res = ast_streamfile(chan, "digits/hwra", lang);
06041 if (!res)
06042 res = ast_waitstream(chan, ints);
06043 }
06044 if (pm) {
06045 if (!res)
06046 res = ast_streamfile(chan, "digits/p-m", lang);
06047 } else {
06048 if (!res)
06049 res = ast_streamfile(chan, "digits/a-m", lang);
06050 }
06051 if (!res)
06052 res = ast_waitstream(chan, ints);
06053 return res;
06054 }
06055
06056
06057
06058 static int ast_say_datetime_gr(struct ast_channel *chan, time_t t, const char *ints, const char *lang)
06059 {
06060 struct tm tm;
06061 char fn[256];
06062 int res = 0;
06063 localtime_r(&t,&tm);
06064
06065
06066
06067 if (!res) {
06068 snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
06069 res = ast_streamfile(chan, fn, lang);
06070 if (!res)
06071 res = ast_waitstream(chan, ints);
06072 }
06073
06074 if (!res) {
06075 gr_say_number_female(tm.tm_mday, chan, ints, lang);
06076 }
06077
06078 if (!res) {
06079 snprintf(fn, sizeof(fn), "digits/mon-%d", tm.tm_mon);
06080 res = ast_streamfile(chan, fn, lang);
06081 if (!res)
06082 res = ast_waitstream(chan, ints);
06083 }
06084
06085 res = ast_say_time_gr(chan, t, ints, lang);
06086 return res;
06087 }
06088
06089 static int ast_say_date_with_format_gr(struct ast_channel *chan, time_t time, const char *ints, const char *lang, const char *format, const char *timezone)
06090 {
06091
06092 struct tm tm;
06093 int res=0, offset, sndoffset;
06094 char sndfile[256], nextmsg[256];
06095
06096 ast_localtime(&time,&tm,timezone);
06097
06098 for (offset=0 ; format[offset] != '\0' ; offset++) {
06099 ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
06100 switch (format[offset]) {
06101
06102 case '\'':
06103
06104 sndoffset=0;
06105 for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
06106 sndfile[sndoffset] = format[offset];
06107 sndfile[sndoffset] = '\0';
06108 res = wait_file(chan,ints,sndfile,lang);
06109 break;
06110 case 'A':
06111 case 'a':
06112
06113 snprintf(nextmsg,sizeof(nextmsg), "digits/day-%d", tm.tm_wday);
06114 res = wait_file(chan,ints,nextmsg,lang);
06115 break;
06116 case 'B':
06117 case 'b':
06118 case 'h':
06119
06120 snprintf(nextmsg,sizeof(nextmsg), "digits/mon-%d", tm.tm_mon);
06121 res = wait_file(chan,ints,nextmsg,lang);
06122 break;
06123 case 'd':
06124 case 'e':
06125
06126 gr_say_number_female(tm.tm_mday, chan, ints, lang);
06127 break;
06128 case 'Y':
06129
06130
06131 ast_say_number_full_gr(chan, 1900+tm.tm_year, ints, chan->language, -1, -1);
06132 break;
06133 case 'I':
06134 case 'l':
06135
06136 if (tm.tm_hour == 0)
06137 gr_say_number_female(12, chan, ints, lang);
06138 else if (tm.tm_hour > 12)
06139 gr_say_number_female(tm.tm_hour - 12, chan, ints, lang);
06140 else
06141 gr_say_number_female(tm.tm_hour, chan, ints, lang);
06142 break;
06143 case 'H':
06144 case 'k':
06145
06146 gr_say_number_female(tm.tm_hour, chan, ints, lang);
06147 break;
06148 case 'M':
06149
06150 if (tm.tm_min) {
06151 if (!res)
06152 res = ast_streamfile(chan, "digits/kai", lang);
06153 if (!res)
06154 res = ast_waitstream(chan, ints);
06155 if (!res)
06156 res = ast_say_number_full_gr(chan, tm.tm_min, ints, lang, -1, -1);
06157 } else {
06158 if (!res)
06159 res = ast_streamfile(chan, "digits/oclock", lang);
06160 if (!res)
06161 res = ast_waitstream(chan, ints);
06162 }
06163 break;
06164 case 'P':
06165 case 'p':
06166
06167 if (tm.tm_hour > 11)
06168 snprintf(nextmsg,sizeof(nextmsg), "digits/p-m");
06169 else
06170 snprintf(nextmsg,sizeof(nextmsg), "digits/a-m");
06171 res = wait_file(chan,ints,nextmsg,lang);
06172 break;
06173 case 'Q':
06174
06175 {
06176 struct timeval now;
06177 struct tm tmnow;
06178 time_t beg_today;
06179
06180 gettimeofday(&now,NULL);
06181 ast_localtime(&now.tv_sec,&tmnow,timezone);
06182
06183
06184 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
06185 if (beg_today < time) {
06186
06187 res = wait_file(chan,ints, "digits/today",lang);
06188 } else if (beg_today - 86400 < time) {
06189
06190 res = wait_file(chan,ints, "digits/yesterday",lang);
06191 } else {
06192 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
06193 }
06194 }
06195 break;
06196 case 'q':
06197
06198 {
06199 struct timeval now;
06200 struct tm tmnow;
06201 time_t beg_today;
06202
06203 gettimeofday(&now,NULL);
06204 ast_localtime(&now.tv_sec,&tmnow,timezone);
06205
06206
06207 beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
06208 if (beg_today < time) {
06209
06210 } else if ((beg_today - 86400) < time) {
06211
06212 res = wait_file(chan,ints, "digits/yesterday",lang);
06213 } else if (beg_today - 86400 * 6 < time) {
06214
06215 res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
06216 } else {
06217 res = ast_say_date_with_format(chan, time, ints, lang, "AdBY", timezone);
06218 }
06219 }
06220 break;
06221 case 'R':
06222 res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
06223 break;
06224 case 'S':
06225
06226 snprintf(nextmsg,sizeof(nextmsg), "digits/kai");
06227 res = wait_file(chan,ints,nextmsg,lang);
06228 if (!res)
06229 res = ast_say_number_full_gr(chan, tm.tm_sec, ints, lang, -1, -1);
06230 if (!res)
06231 snprintf(nextmsg,sizeof(nextmsg), "digits/seconds");
06232 res = wait_file(chan,ints,nextmsg,lang);
06233 break;
06234 case 'T':
06235 res = ast_say_date_with_format(chan, time, ints, lang, "HMS", timezone);
06236 break;
06237 case ' ':
06238 case ' ':
06239
06240 break;
06241 default:
06242
06243 ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
06244 }
06245
06246 if (res) {
06247 break;
06248 }
06249 }
06250 return res;
06251 }