Browse code

app_python: completed the handling of KEMI functions with 4 parameters

Daniel-Constantin Mierla authored on 16/05/2019 09:29:22
Showing 1 changed files
... ...
@@ -338,52 +338,243 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self,
338 338
 				&& ket->ptypes[2]==SR_KEMIP_STR
339 339
 				&& ket->ptypes[3]==SR_KEMIP_STR) {
340 340
 			if(!PyArg_ParseTuple(args, "ssss:kemi-param-ssss",
341
-						&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
342
-				LM_ERR("unable to retrieve str-str-str-str params %d\n", i);
341
+					&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
342
+				LM_ERR("unable to retrieve ssss params %d\n", i);
343 343
 				return sr_kemi_apy_return_false();
344 344
 			}
345 345
 			vps[0].s.len = strlen(vps[0].s.s);
346 346
 			vps[1].s.len = strlen(vps[1].s.s);
347 347
 			vps[2].s.len = strlen(vps[2].s.s);
348 348
 			vps[3].s.len = strlen(vps[3].s.s);
349
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
350
-					" [%.*s] [%.*s]\n", i,
351
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
352
-				vps[1].s.len, vps[1].s.s, vps[2].s.len, vps[2].s.s,
353
-				vps[3].s.len, vps[3].s.s);
349
+
350
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%s] [%s]\n",
351
+					i, fname.len, fname.s,
352
+					vps[0].s.s, vps[1].s.s, vps[2].s.s, vps[3].s.s);
354 353
 		} else if(ket->ptypes[0]==SR_KEMIP_STR
355 354
 				&& ket->ptypes[1]==SR_KEMIP_STR
356 355
 				&& ket->ptypes[2]==SR_KEMIP_STR
357 356
 				&& ket->ptypes[3]==SR_KEMIP_INT) {
358
-			if(!PyArg_ParseTuple(args, "sssi:kemi-param-sssn",
359
-						&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].n)) {
360
-				LM_ERR("unable to retrieve str-str-int-int params %d\n", i);
357
+			if(!PyArg_ParseTuple(args, "sssn:kemi-param-sssn",
358
+					&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, vps[3].n)) {
359
+				LM_ERR("unable to retrieve sssn params %d\n", i);
361 360
 				return sr_kemi_apy_return_false();
362 361
 			}
363 362
 			vps[0].s.len = strlen(vps[0].s.s);
364 363
 			vps[1].s.len = strlen(vps[1].s.s);
365 364
 			vps[2].s.len = strlen(vps[2].s.s);
366
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
367
-					" [%.*s] [%d]\n", i,
368
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
369
-				vps[1].s.len, vps[1].s.s, vps[2].s.len, vps[2].s.s, vps[3].n);
365
+
366
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%s] [%d]\n",
367
+					i, fname.len, fname.s,
368
+					vps[0].s.s, vps[1].s.s, vps[2].s.s, vps[3].n);
369
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
370
+				&& ket->ptypes[1]==SR_KEMIP_STR
371
+				&& ket->ptypes[2]==SR_KEMIP_INT
372
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
373
+			if(!PyArg_ParseTuple(args, "ssns:kemi-param-ssns",
374
+					&vps[0].s.s, &vps[1].s.s, &vps[2].n, &vps[3].s.s)) {
375
+				LM_ERR("unable to retrieve ssns params %d\n", i);
376
+				return sr_kemi_apy_return_false();
377
+			}
378
+			vps[0].s.len = strlen(vps[0].s.s);
379
+			vps[1].s.len = strlen(vps[1].s.s);
380
+			vps[3].s.len = strlen(vps[3].s.s);
381
+
382
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%d] [%s]\n",
383
+					i, fname.len, fname.s,
384
+					vps[0].s.s, vps[1].s.s, vps[2].n, vps[3].s.s);
370 385
 		} else if(ket->ptypes[0]==SR_KEMIP_STR
371 386
 				&& ket->ptypes[1]==SR_KEMIP_STR
372 387
 				&& ket->ptypes[2]==SR_KEMIP_INT
373 388
 				&& ket->ptypes[3]==SR_KEMIP_INT) {
374
-			if(!PyArg_ParseTuple(args, "ssii:kemi-param-ssnn",
375
-						&vps[0].s.s, &vps[1].s.s, &vps[2].n, &vps[3].n)) {
376
-				LM_ERR("unable to retrieve str-str-int-int params %d\n", i);
389
+			if(!PyArg_ParseTuple(args, "ssnn:kemi-param-ssnn",
390
+					&vps[0].s.s, &vps[1].s.s, &vps[2].n, vps[3].n)) {
391
+				LM_ERR("unable to retrieve ssnn params %d\n", i);
377 392
 				return sr_kemi_apy_return_false();
378 393
 			}
379 394
 			vps[0].s.len = strlen(vps[0].s.s);
380 395
 			vps[1].s.len = strlen(vps[1].s.s);
381
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
382
-					" [%d] [%d]\n", i,
383
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
384
-				vps[1].s.len, vps[1].s.s, vps[2].n, vps[3].n);
396
+
397
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%d] [%d]\n",
398
+					i, fname.len, fname.s,
399
+					vps[0].s.s, vps[1].s.s, vps[2].n, vps[3].n);
400
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
401
+				&& ket->ptypes[1]==SR_KEMIP_INT
402
+				&& ket->ptypes[2]==SR_KEMIP_STR
403
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
404
+			if(!PyArg_ParseTuple(args, "snss:kemi-param-snss",
405
+					&vps[0].s.s, &vps[1].n, &vps[2].s.s, &vps[3].s.s)) {
406
+				LM_ERR("unable to retrieve snss params %d\n", i);
407
+				return sr_kemi_apy_return_false();
408
+			}
409
+			vps[0].s.len = strlen(vps[0].s.s);
410
+			vps[2].s.len = strlen(vps[2].s.s);
411
+			vps[3].s.len = strlen(vps[3].s.s);
412
+
413
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%s] [%s]\n",
414
+					i, fname.len, fname.s,
415
+					vps[0].s.s, vps[1].n, vps[2].s.s, vps[3].s.s);
416
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
417
+				&& ket->ptypes[1]==SR_KEMIP_INT
418
+				&& ket->ptypes[2]==SR_KEMIP_STR
419
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
420
+			if(!PyArg_ParseTuple(args, "snsn:kemi-param-snsn",
421
+					&vps[0].s.s, &vps[1].n, &vps[2].s.s, vps[3].n)) {
422
+				LM_ERR("unable to retrieve snsn params %d\n", i);
423
+				return sr_kemi_apy_return_false();
424
+			}
425
+			vps[0].s.len = strlen(vps[0].s.s);
426
+			vps[2].s.len = strlen(vps[2].s.s);
427
+
428
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%s] [%d]\n",
429
+					i, fname.len, fname.s,
430
+					vps[0].s.s, vps[1].n, vps[2].s.s, vps[3].n);
431
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
432
+				&& ket->ptypes[1]==SR_KEMIP_INT
433
+				&& ket->ptypes[2]==SR_KEMIP_INT
434
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
435
+			if(!PyArg_ParseTuple(args, "snns:kemi-param-snns",
436
+					&vps[0].s.s, &vps[1].n, &vps[2].n, &vps[3].s.s)) {
437
+				LM_ERR("unable to retrieve snns params %d\n", i);
438
+				return sr_kemi_apy_return_false();
439
+			}
440
+			vps[0].s.len = strlen(vps[0].s.s);
441
+			vps[3].s.len = strlen(vps[3].s.s);
442
+
443
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%d] [%s]\n",
444
+					i, fname.len, fname.s,
445
+					vps[0].s.s, vps[1].n, vps[2].n, vps[3].s.s);
446
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
447
+				&& ket->ptypes[1]==SR_KEMIP_INT
448
+				&& ket->ptypes[2]==SR_KEMIP_INT
449
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
450
+			if(!PyArg_ParseTuple(args, "snnn:kemi-param-snnn",
451
+					&vps[0].s.s, &vps[1].n, &vps[2].n, vps[3].n)) {
452
+				LM_ERR("unable to retrieve snnn params %d\n", i);
453
+				return sr_kemi_apy_return_false();
454
+			}
455
+			vps[0].s.len = strlen(vps[0].s.s);
456
+
457
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%d] [%d]\n",
458
+					i, fname.len, fname.s,
459
+					vps[0].s.s, vps[1].n, vps[2].n, vps[3].n);
460
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
461
+				&& ket->ptypes[1]==SR_KEMIP_STR
462
+				&& ket->ptypes[2]==SR_KEMIP_STR
463
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
464
+			if(!PyArg_ParseTuple(args, "nsss:kemi-param-nsss",
465
+					&vps[0].n, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
466
+				LM_ERR("unable to retrieve nsss params %d\n", i);
467
+				return sr_kemi_apy_return_false();
468
+			}
469
+			vps[1].s.len = strlen(vps[1].s.s);
470
+			vps[2].s.len = strlen(vps[2].s.s);
471
+			vps[3].s.len = strlen(vps[3].s.s);
472
+
473
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%s] [%s]\n",
474
+					i, fname.len, fname.s,
475
+					vps[0].n, vps[1].s.s, vps[2].s.s, vps[3].s.s);
476
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
477
+				&& ket->ptypes[1]==SR_KEMIP_STR
478
+				&& ket->ptypes[2]==SR_KEMIP_STR
479
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
480
+			if(!PyArg_ParseTuple(args, "nssn:kemi-param-nssn",
481
+					&vps[0].n, &vps[1].s.s, &vps[2].s.s, vps[3].n)) {
482
+				LM_ERR("unable to retrieve nssn params %d\n", i);
483
+				return sr_kemi_apy_return_false();
484
+			}
485
+			vps[1].s.len = strlen(vps[1].s.s);
486
+			vps[2].s.len = strlen(vps[2].s.s);
487
+
488
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%s] [%d]\n",
489
+					i, fname.len, fname.s,
490
+					vps[0].n, vps[1].s.s, vps[2].s.s, vps[3].n);
491
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
492
+				&& ket->ptypes[1]==SR_KEMIP_STR
493
+				&& ket->ptypes[2]==SR_KEMIP_INT
494
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
495
+			if(!PyArg_ParseTuple(args, "nsns:kemi-param-nsns",
496
+					&vps[0].n, &vps[1].s.s, &vps[2].n, &vps[3].s.s)) {
497
+				LM_ERR("unable to retrieve nsns params %d\n", i);
498
+				return sr_kemi_apy_return_false();
499
+			}
500
+			vps[1].s.len = strlen(vps[1].s.s);
501
+			vps[3].s.len = strlen(vps[3].s.s);
502
+
503
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%d] [%s]\n",
504
+					i, fname.len, fname.s,
505
+					vps[0].n, vps[1].s.s, vps[2].n, vps[3].s.s);
506
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
507
+				&& ket->ptypes[1]==SR_KEMIP_STR
508
+				&& ket->ptypes[2]==SR_KEMIP_INT
509
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
510
+			if(!PyArg_ParseTuple(args, "nsnn:kemi-param-nsnn",
511
+					&vps[0].n, &vps[1].s.s, &vps[2].n, vps[3].n)) {
512
+				LM_ERR("unable to retrieve nsnn params %d\n", i);
513
+				return sr_kemi_apy_return_false();
514
+			}
515
+			vps[1].s.len = strlen(vps[1].s.s);
516
+
517
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%d] [%d]\n",
518
+					i, fname.len, fname.s,
519
+					vps[0].n, vps[1].s.s, vps[2].n, vps[3].n);
520
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
521
+				&& ket->ptypes[1]==SR_KEMIP_INT
522
+				&& ket->ptypes[2]==SR_KEMIP_STR
523
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
524
+			if(!PyArg_ParseTuple(args, "nnss:kemi-param-nnss",
525
+					&vps[0].n, &vps[1].n, &vps[2].s.s, &vps[3].s.s)) {
526
+				LM_ERR("unable to retrieve nnss params %d\n", i);
527
+				return sr_kemi_apy_return_false();
528
+			}
529
+			vps[2].s.len = strlen(vps[2].s.s);
530
+			vps[3].s.len = strlen(vps[3].s.s);
531
+
532
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%s] [%s]\n",
533
+					i, fname.len, fname.s,
534
+					vps[0].n, vps[1].n, vps[2].s.s, vps[3].s.s);
535
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
536
+				&& ket->ptypes[1]==SR_KEMIP_INT
537
+				&& ket->ptypes[2]==SR_KEMIP_STR
538
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
539
+			if(!PyArg_ParseTuple(args, "nnsn:kemi-param-nnsn",
540
+					&vps[0].n, &vps[1].n, &vps[2].s.s, vps[3].n)) {
541
+				LM_ERR("unable to retrieve nnsn params %d\n", i);
542
+				return sr_kemi_apy_return_false();
543
+			}
544
+			vps[2].s.len = strlen(vps[2].s.s);
545
+
546
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%s] [%d]\n",
547
+					i, fname.len, fname.s,
548
+					vps[0].n, vps[1].n, vps[2].s.s, vps[3].n);
549
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
550
+				&& ket->ptypes[1]==SR_KEMIP_INT
551
+				&& ket->ptypes[2]==SR_KEMIP_INT
552
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
553
+			if(!PyArg_ParseTuple(args, "nnns:kemi-param-nnns",
554
+					&vps[0].n, &vps[1].n, &vps[2].n, &vps[3].s.s)) {
555
+				LM_ERR("unable to retrieve nnns params %d\n", i);
556
+				return sr_kemi_apy_return_false();
557
+			}
558
+			vps[3].s.len = strlen(vps[3].s.s);
559
+
560
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%d] [%s]\n",
561
+					i, fname.len, fname.s,
562
+					vps[0].n, vps[1].n, vps[2].n, vps[3].s.s);
563
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
564
+				&& ket->ptypes[1]==SR_KEMIP_INT
565
+				&& ket->ptypes[2]==SR_KEMIP_INT
566
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
567
+			if(!PyArg_ParseTuple(args, "nnnn:kemi-param-nnnn",
568
+					&vps[0].n, &vps[1].n, &vps[2].n, vps[3].n)) {
569
+				LM_ERR("unable to retrieve nnnn params %d\n", i);
570
+				return sr_kemi_apy_return_false();
571
+			}
572
+
573
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%d] [%d]\n",
574
+					i, fname.len, fname.s,
575
+					vps[0].n, vps[1].n, vps[2].n, vps[3].n);
385 576
 		} else {
386
-			LM_ERR("not implemented yet\n");
577
+			LM_ERR("invalid parameters for: %.*s\n", fname.len, fname.s);
387 578
 			return sr_kemi_apy_return_false();
388 579
 		}
389 580
 	} else if(ket->ptypes[5]==SR_KEMIP_NONE) {
... ...
@@ -597,7 +788,6 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self,
597 597
 					&& ket->ptypes[1]==SR_KEMIP_STR
598 598
 					&& ket->ptypes[2]==SR_KEMIP_STR
599 599
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
600
-				/* ssss */
601 600
 				ret = ((sr_kemi_fmssss_f)(ket->func))(lmsg,
602 601
 						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s);
603 602
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -605,23 +795,48 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self,
605 605
 					&& ket->ptypes[1]==SR_KEMIP_STR
606 606
 					&& ket->ptypes[2]==SR_KEMIP_STR
607 607
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
608
-				/* ssnn */
609 608
 				ret = ((sr_kemi_fmsssn_f)(ket->func))(lmsg,
610 609
 						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n);
611 610
 				return sr_kemi_apy_return_int(ket, ret);
612 611
 			} else if(ket->ptypes[0]==SR_KEMIP_STR
613 612
 					&& ket->ptypes[1]==SR_KEMIP_STR
614 613
 					&& ket->ptypes[2]==SR_KEMIP_INT
614
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
615
+				ret = ((sr_kemi_fmssns_f)(ket->func))(lmsg,
616
+						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s);
617
+				return sr_kemi_apy_return_int(ket, ret);
618
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
619
+					&& ket->ptypes[1]==SR_KEMIP_STR
620
+					&& ket->ptypes[2]==SR_KEMIP_INT
615 621
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
616
-				/* ssnn */
617 622
 				ret = ((sr_kemi_fmssnn_f)(ket->func))(lmsg,
618 623
 						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n);
619 624
 				return sr_kemi_apy_return_int(ket, ret);
620 625
 			} else if(ket->ptypes[0]==SR_KEMIP_STR
621 626
 					&& ket->ptypes[1]==SR_KEMIP_INT
627
+					&& ket->ptypes[2]==SR_KEMIP_STR
628
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
629
+				ret = ((sr_kemi_fmsnss_f)(ket->func))(lmsg,
630
+						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s);
631
+				return sr_kemi_apy_return_int(ket, ret);
632
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
633
+					&& ket->ptypes[1]==SR_KEMIP_INT
634
+					&& ket->ptypes[2]==SR_KEMIP_STR
635
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
636
+				ret = ((sr_kemi_fmsnsn_f)(ket->func))(lmsg,
637
+						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n);
638
+				return sr_kemi_apy_return_int(ket, ret);
639
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
640
+					&& ket->ptypes[1]==SR_KEMIP_INT
641
+					&& ket->ptypes[2]==SR_KEMIP_INT
642
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
643
+				ret = ((sr_kemi_fmsnns_f)(ket->func))(lmsg,
644
+						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s);
645
+				return sr_kemi_apy_return_int(ket, ret);
646
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
647
+					&& ket->ptypes[1]==SR_KEMIP_INT
622 648
 					&& ket->ptypes[2]==SR_KEMIP_INT
623 649
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
624
-				/* snnn */
625 650
 				ret = ((sr_kemi_fmsnnn_f)(ket->func))(lmsg,
626 651
 						&vps[0].s, vps[1].n, vps[2].n, vps[3].n);
627 652
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -629,23 +844,48 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self,
629 629
 					&& ket->ptypes[1]==SR_KEMIP_STR
630 630
 					&& ket->ptypes[2]==SR_KEMIP_STR
631 631
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
632
-				/* nsss */
633 632
 				ret = ((sr_kemi_fmnsss_f)(ket->func))(lmsg,
634 633
 						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s);
635 634
 				return sr_kemi_apy_return_int(ket, ret);
636 635
 			} else if(ket->ptypes[0]==SR_KEMIP_INT
636
+					&& ket->ptypes[1]==SR_KEMIP_STR
637
+					&& ket->ptypes[2]==SR_KEMIP_STR
638
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
639
+				ret = ((sr_kemi_fmnssn_f)(ket->func))(lmsg,
640
+						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n);
641
+				return sr_kemi_apy_return_int(ket, ret);
642
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
643
+					&& ket->ptypes[1]==SR_KEMIP_STR
644
+					&& ket->ptypes[2]==SR_KEMIP_INT
645
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
646
+				ret = ((sr_kemi_fmnsns_f)(ket->func))(lmsg,
647
+						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s);
648
+				return sr_kemi_apy_return_int(ket, ret);
649
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
650
+					&& ket->ptypes[1]==SR_KEMIP_STR
651
+					&& ket->ptypes[2]==SR_KEMIP_INT
652
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
653
+				ret = ((sr_kemi_fmnsnn_f)(ket->func))(lmsg,
654
+						vps[0].n, &vps[1].s, vps[2].n, vps[3].n);
655
+				return sr_kemi_apy_return_int(ket, ret);
656
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
637 657
 					&& ket->ptypes[1]==SR_KEMIP_INT
638 658
 					&& ket->ptypes[2]==SR_KEMIP_STR
639 659
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
640
-				/* nnss */
641 660
 				ret = ((sr_kemi_fmnnss_f)(ket->func))(lmsg,
642 661
 						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s);
643 662
 				return sr_kemi_apy_return_int(ket, ret);
644 663
 			} else if(ket->ptypes[0]==SR_KEMIP_INT
645 664
 					&& ket->ptypes[1]==SR_KEMIP_INT
665
+					&& ket->ptypes[2]==SR_KEMIP_STR
666
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
667
+				ret = ((sr_kemi_fmnnsn_f)(ket->func))(lmsg,
668
+						vps[0].n, vps[1].n, &vps[2].s, vps[3].n);
669
+				return sr_kemi_apy_return_int(ket, ret);
670
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
671
+					&& ket->ptypes[1]==SR_KEMIP_INT
646 672
 					&& ket->ptypes[2]==SR_KEMIP_INT
647 673
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
648
-				/* nnns */
649 674
 				ret = ((sr_kemi_fmnnns_f)(ket->func))(lmsg,
650 675
 						vps[0].n, vps[1].n, vps[2].n, &vps[3].s);
651 676
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -653,13 +893,11 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self,
653 653
 					&& ket->ptypes[1]==SR_KEMIP_INT
654 654
 					&& ket->ptypes[2]==SR_KEMIP_INT
655 655
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
656
-				/* nnnn */
657 656
 				ret = ((sr_kemi_fmnnnn_f)(ket->func))(lmsg,
658 657
 						vps[0].n, vps[1].n, vps[2].n, vps[3].n);
659 658
 				return sr_kemi_apy_return_int(ket, ret);
660 659
 			} else {
661
-				LM_ERR("invalid parameters for: %.*s\n",
662
-						fname.len, fname.s);
660
+				LM_ERR("invalid parameters for: %.*s\n", fname.len, fname.s);
663 661
 				return sr_kemi_apy_return_false();
664 662
 			}
665 663
 		break;