Browse code

app_python3: completed the handling of KEMI functions with 4 parameters

Daniel-Constantin Mierla authored on 16/05/2019 10:01:09
Showing 1 changed files
... ...
@@ -345,67 +345,243 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self, PyObject *arg
345 345
 				&& ket->ptypes[2]==SR_KEMIP_STR
346 346
 				&& ket->ptypes[3]==SR_KEMIP_STR) {
347 347
 			if(!PyArg_ParseTuple(args, "ssss:kemi-param-ssss",
348
-						&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
349
-				LM_ERR("unable to retrieve str-str-str-str params %d\n", i);
348
+					&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
349
+				LM_ERR("unable to retrieve ssss params %d\n", i);
350 350
 				return sr_kemi_apy_return_false();
351 351
 			}
352 352
 			vps[0].s.len = strlen(vps[0].s.s);
353 353
 			vps[1].s.len = strlen(vps[1].s.s);
354 354
 			vps[2].s.len = strlen(vps[2].s.s);
355 355
 			vps[3].s.len = strlen(vps[3].s.s);
356
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
357
-					" [%.*s] [%.*s]\n", i,
358
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
359
-				vps[1].s.len, vps[1].s.s, vps[2].s.len, vps[2].s.s,
360
-				vps[3].s.len, vps[3].s.s);
356
+
357
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%s] [%s]\n",
358
+					i, fname.len, fname.s,
359
+					vps[0].s.s, vps[1].s.s, vps[2].s.s, vps[3].s.s);
361 360
 		} else if(ket->ptypes[0]==SR_KEMIP_STR
362 361
 				&& ket->ptypes[1]==SR_KEMIP_STR
363 362
 				&& ket->ptypes[2]==SR_KEMIP_STR
364 363
 				&& ket->ptypes[3]==SR_KEMIP_INT) {
365
-			if(!PyArg_ParseTuple(args, "sssi:kemi-param-sssn",
366
-						&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].n)) {
367
-				LM_ERR("unable to retrieve str-str-str-int params %d\n", i);
364
+			if(!PyArg_ParseTuple(args, "sssn:kemi-param-sssn",
365
+					&vps[0].s.s, &vps[1].s.s, &vps[2].s.s, &vps[3].n)) {
366
+				LM_ERR("unable to retrieve sssn params %d\n", i);
368 367
 				return sr_kemi_apy_return_false();
369 368
 			}
370 369
 			vps[0].s.len = strlen(vps[0].s.s);
371 370
 			vps[1].s.len = strlen(vps[1].s.s);
372 371
 			vps[2].s.len = strlen(vps[2].s.s);
373
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
374
-					" [%.*s] [%d]\n", i,
375
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
376
-				vps[1].s.len, vps[1].s.s, vps[2].s.len, vps[2].s.s, vps[3].n);
372
+
373
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%s] [%d]\n",
374
+					i, fname.len, fname.s,
375
+					vps[0].s.s, vps[1].s.s, vps[2].s.s, vps[3].n);
376
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
377
+				&& ket->ptypes[1]==SR_KEMIP_STR
378
+				&& ket->ptypes[2]==SR_KEMIP_INT
379
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
380
+			if(!PyArg_ParseTuple(args, "ssns:kemi-param-ssns",
381
+					&vps[0].s.s, &vps[1].s.s, &vps[2].n, &vps[3].s.s)) {
382
+				LM_ERR("unable to retrieve ssns params %d\n", i);
383
+				return sr_kemi_apy_return_false();
384
+			}
385
+			vps[0].s.len = strlen(vps[0].s.s);
386
+			vps[1].s.len = strlen(vps[1].s.s);
387
+			vps[3].s.len = strlen(vps[3].s.s);
388
+
389
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%d] [%s]\n",
390
+					i, fname.len, fname.s,
391
+					vps[0].s.s, vps[1].s.s, vps[2].n, vps[3].s.s);
377 392
 		} else if(ket->ptypes[0]==SR_KEMIP_STR
378 393
 				&& ket->ptypes[1]==SR_KEMIP_STR
379 394
 				&& ket->ptypes[2]==SR_KEMIP_INT
380 395
 				&& ket->ptypes[3]==SR_KEMIP_INT) {
381
-			if(!PyArg_ParseTuple(args, "ssii:kemi-param-ssnn",
382
-						&vps[0].s.s, &vps[1].s.s, &vps[2].n, &vps[3].n)) {
383
-				LM_ERR("unable to retrieve str-str-int-int params %d\n", i);
396
+			if(!PyArg_ParseTuple(args, "ssnn:kemi-param-ssnn",
397
+					&vps[0].s.s, &vps[1].s.s, &vps[2].n, &vps[3].n)) {
398
+				LM_ERR("unable to retrieve ssnn params %d\n", i);
384 399
 				return sr_kemi_apy_return_false();
385 400
 			}
386 401
 			vps[0].s.len = strlen(vps[0].s.s);
387 402
 			vps[1].s.len = strlen(vps[1].s.s);
388
-			LM_DBG("params[%d] for: %.*s are str: [%.*s] [%.*s]"
389
-					" [%d] [%d]\n", i,
390
-				fname.len, fname.s, vps[0].s.len, vps[0].s.s,
391
-				vps[1].s.len, vps[1].s.s, vps[2].n, vps[3].n);
403
+
404
+			LM_DBG("params[%d] for: %.*s are: [%s] [%s] [%d] [%d]\n",
405
+					i, fname.len, fname.s,
406
+					vps[0].s.s, vps[1].s.s, vps[2].n, vps[3].n);
407
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
408
+				&& ket->ptypes[1]==SR_KEMIP_INT
409
+				&& ket->ptypes[2]==SR_KEMIP_STR
410
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
411
+			if(!PyArg_ParseTuple(args, "snss:kemi-param-snss",
412
+					&vps[0].s.s, &vps[1].n, &vps[2].s.s, &vps[3].s.s)) {
413
+				LM_ERR("unable to retrieve snss params %d\n", i);
414
+				return sr_kemi_apy_return_false();
415
+			}
416
+			vps[0].s.len = strlen(vps[0].s.s);
417
+			vps[2].s.len = strlen(vps[2].s.s);
418
+			vps[3].s.len = strlen(vps[3].s.s);
419
+
420
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%s] [%s]\n",
421
+					i, fname.len, fname.s,
422
+					vps[0].s.s, vps[1].n, vps[2].s.s, vps[3].s.s);
423
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
424
+				&& ket->ptypes[1]==SR_KEMIP_INT
425
+				&& ket->ptypes[2]==SR_KEMIP_STR
426
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
427
+			if(!PyArg_ParseTuple(args, "snsn:kemi-param-snsn",
428
+					&vps[0].s.s, &vps[1].n, &vps[2].s.s, &vps[3].n)) {
429
+				LM_ERR("unable to retrieve snsn params %d\n", i);
430
+				return sr_kemi_apy_return_false();
431
+			}
432
+			vps[0].s.len = strlen(vps[0].s.s);
433
+			vps[2].s.len = strlen(vps[2].s.s);
434
+
435
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%s] [%d]\n",
436
+					i, fname.len, fname.s,
437
+					vps[0].s.s, vps[1].n, vps[2].s.s, vps[3].n);
438
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
439
+				&& ket->ptypes[1]==SR_KEMIP_INT
440
+				&& ket->ptypes[2]==SR_KEMIP_INT
441
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
442
+			if(!PyArg_ParseTuple(args, "snns:kemi-param-snns",
443
+					&vps[0].s.s, &vps[1].n, &vps[2].n, &vps[3].s.s)) {
444
+				LM_ERR("unable to retrieve snns params %d\n", i);
445
+				return sr_kemi_apy_return_false();
446
+			}
447
+			vps[0].s.len = strlen(vps[0].s.s);
448
+			vps[3].s.len = strlen(vps[3].s.s);
449
+
450
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%d] [%s]\n",
451
+					i, fname.len, fname.s,
452
+					vps[0].s.s, vps[1].n, vps[2].n, vps[3].s.s);
453
+		} else if(ket->ptypes[0]==SR_KEMIP_STR
454
+				&& ket->ptypes[1]==SR_KEMIP_INT
455
+				&& ket->ptypes[2]==SR_KEMIP_INT
456
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
457
+			if(!PyArg_ParseTuple(args, "snnn:kemi-param-snnn",
458
+					&vps[0].s.s, &vps[1].n, &vps[2].n, &vps[3].n)) {
459
+				LM_ERR("unable to retrieve snnn params %d\n", i);
460
+				return sr_kemi_apy_return_false();
461
+			}
462
+			vps[0].s.len = strlen(vps[0].s.s);
463
+
464
+			LM_DBG("params[%d] for: %.*s are: [%s] [%d] [%d] [%d]\n",
465
+					i, fname.len, fname.s,
466
+					vps[0].s.s, vps[1].n, vps[2].n, vps[3].n);
392 467
 		} else if(ket->ptypes[0]==SR_KEMIP_INT
393 468
 				&& ket->ptypes[1]==SR_KEMIP_STR
394 469
 				&& ket->ptypes[2]==SR_KEMIP_STR
395 470
 				&& ket->ptypes[3]==SR_KEMIP_STR) {
396
-			if(!PyArg_ParseTuple(args, "isss:kemi-param-nsss",
397
-						&vps[0].n, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
398
-				LM_ERR("unable to retrieve int-str-str-str params %d\n", i);
471
+			if(!PyArg_ParseTuple(args, "nsss:kemi-param-nsss",
472
+					&vps[0].n, &vps[1].s.s, &vps[2].s.s, &vps[3].s.s)) {
473
+				LM_ERR("unable to retrieve nsss params %d\n", i);
474
+				return sr_kemi_apy_return_false();
475
+			}
476
+			vps[1].s.len = strlen(vps[1].s.s);
477
+			vps[2].s.len = strlen(vps[2].s.s);
478
+			vps[3].s.len = strlen(vps[3].s.s);
479
+
480
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%s] [%s]\n",
481
+					i, fname.len, fname.s,
482
+					vps[0].n, vps[1].s.s, vps[2].s.s, vps[3].s.s);
483
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
484
+				&& ket->ptypes[1]==SR_KEMIP_STR
485
+				&& ket->ptypes[2]==SR_KEMIP_STR
486
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
487
+			if(!PyArg_ParseTuple(args, "nssn:kemi-param-nssn",
488
+					&vps[0].n, &vps[1].s.s, &vps[2].s.s, &vps[3].n)) {
489
+				LM_ERR("unable to retrieve nssn params %d\n", i);
399 490
 				return sr_kemi_apy_return_false();
400 491
 			}
401 492
 			vps[1].s.len = strlen(vps[1].s.s);
402 493
 			vps[2].s.len = strlen(vps[2].s.s);
494
+
495
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%s] [%d]\n",
496
+					i, fname.len, fname.s,
497
+					vps[0].n, vps[1].s.s, vps[2].s.s, vps[3].n);
498
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
499
+				&& ket->ptypes[1]==SR_KEMIP_STR
500
+				&& ket->ptypes[2]==SR_KEMIP_INT
501
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
502
+			if(!PyArg_ParseTuple(args, "nsns:kemi-param-nsns",
503
+					&vps[0].n, &vps[1].s.s, &vps[2].n, &vps[3].s.s)) {
504
+				LM_ERR("unable to retrieve nsns params %d\n", i);
505
+				return sr_kemi_apy_return_false();
506
+			}
507
+			vps[1].s.len = strlen(vps[1].s.s);
403 508
 			vps[3].s.len = strlen(vps[3].s.s);
404
-			LM_DBG("params[%d] for: %.*s are str:  [%d] [%.*s] [%.*s] [%.*s]\n", i,
405
-				fname.len, fname.s, vps[0].n, vps[1].s.len, vps[1].s.s,
406
-				vps[2].s.len, vps[2].s.s, vps[3].s.len, vps[3].s.s);
509
+
510
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%d] [%s]\n",
511
+					i, fname.len, fname.s,
512
+					vps[0].n, vps[1].s.s, vps[2].n, vps[3].s.s);
513
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
514
+				&& ket->ptypes[1]==SR_KEMIP_STR
515
+				&& ket->ptypes[2]==SR_KEMIP_INT
516
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
517
+			if(!PyArg_ParseTuple(args, "nsnn:kemi-param-nsnn",
518
+					&vps[0].n, &vps[1].s.s, &vps[2].n, &vps[3].n)) {
519
+				LM_ERR("unable to retrieve nsnn params %d\n", i);
520
+				return sr_kemi_apy_return_false();
521
+			}
522
+			vps[1].s.len = strlen(vps[1].s.s);
523
+
524
+			LM_DBG("params[%d] for: %.*s are: [%d] [%s] [%d] [%d]\n",
525
+					i, fname.len, fname.s,
526
+					vps[0].n, vps[1].s.s, vps[2].n, vps[3].n);
527
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
528
+				&& ket->ptypes[1]==SR_KEMIP_INT
529
+				&& ket->ptypes[2]==SR_KEMIP_STR
530
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
531
+			if(!PyArg_ParseTuple(args, "nnss:kemi-param-nnss",
532
+					&vps[0].n, &vps[1].n, &vps[2].s.s, &vps[3].s.s)) {
533
+				LM_ERR("unable to retrieve nnss params %d\n", i);
534
+				return sr_kemi_apy_return_false();
535
+			}
536
+			vps[2].s.len = strlen(vps[2].s.s);
537
+			vps[3].s.len = strlen(vps[3].s.s);
538
+
539
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%s] [%s]\n",
540
+					i, fname.len, fname.s,
541
+					vps[0].n, vps[1].n, vps[2].s.s, vps[3].s.s);
542
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
543
+				&& ket->ptypes[1]==SR_KEMIP_INT
544
+				&& ket->ptypes[2]==SR_KEMIP_STR
545
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
546
+			if(!PyArg_ParseTuple(args, "nnsn:kemi-param-nnsn",
547
+					&vps[0].n, &vps[1].n, &vps[2].s.s, &vps[3].n)) {
548
+				LM_ERR("unable to retrieve nnsn params %d\n", i);
549
+				return sr_kemi_apy_return_false();
550
+			}
551
+			vps[2].s.len = strlen(vps[2].s.s);
552
+
553
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%s] [%d]\n",
554
+					i, fname.len, fname.s,
555
+					vps[0].n, vps[1].n, vps[2].s.s, vps[3].n);
556
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
557
+				&& ket->ptypes[1]==SR_KEMIP_INT
558
+				&& ket->ptypes[2]==SR_KEMIP_INT
559
+				&& ket->ptypes[3]==SR_KEMIP_STR) {
560
+			if(!PyArg_ParseTuple(args, "nnns:kemi-param-nnns",
561
+					&vps[0].n, &vps[1].n, &vps[2].n, &vps[3].s.s)) {
562
+				LM_ERR("unable to retrieve nnns params %d\n", i);
563
+				return sr_kemi_apy_return_false();
564
+			}
565
+			vps[3].s.len = strlen(vps[3].s.s);
566
+
567
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%d] [%s]\n",
568
+					i, fname.len, fname.s,
569
+					vps[0].n, vps[1].n, vps[2].n, vps[3].s.s);
570
+		} else if(ket->ptypes[0]==SR_KEMIP_INT
571
+				&& ket->ptypes[1]==SR_KEMIP_INT
572
+				&& ket->ptypes[2]==SR_KEMIP_INT
573
+				&& ket->ptypes[3]==SR_KEMIP_INT) {
574
+			if(!PyArg_ParseTuple(args, "nnnn:kemi-param-nnnn",
575
+					&vps[0].n, &vps[1].n, &vps[2].n, &vps[3].n)) {
576
+				LM_ERR("unable to retrieve nnnn params %d\n", i);
577
+				return sr_kemi_apy_return_false();
578
+			}
579
+
580
+			LM_DBG("params[%d] for: %.*s are: [%d] [%d] [%d] [%d]\n",
581
+					i, fname.len, fname.s,
582
+					vps[0].n, vps[1].n, vps[2].n, vps[3].n);
407 583
 		} else {
408
-			LM_ERR("not implemented yet\n");
584
+			LM_ERR("invalid parameters for: %.*s\n", fname.len, fname.s);
409 585
 			return sr_kemi_apy_return_false();
410 586
 		}
411 587
 	} else if(ket->ptypes[5]==SR_KEMIP_NONE) {
... ...
@@ -1107,7 +1283,6 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self, PyObject *arg
1107 1107
 					&& ket->ptypes[1]==SR_KEMIP_STR
1108 1108
 					&& ket->ptypes[2]==SR_KEMIP_STR
1109 1109
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
1110
-				/* ssss */
1111 1110
 				ret = ((sr_kemi_fmssss_f)(ket->func))(lmsg,
1112 1111
 						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s);
1113 1112
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -1115,23 +1290,48 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self, PyObject *arg
1115 1115
 					&& ket->ptypes[1]==SR_KEMIP_STR
1116 1116
 					&& ket->ptypes[2]==SR_KEMIP_STR
1117 1117
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
1118
-				/* sssn */
1119 1118
 				ret = ((sr_kemi_fmsssn_f)(ket->func))(lmsg,
1120 1119
 						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n);
1121 1120
 				return sr_kemi_apy_return_int(ket, ret);
1122 1121
 			} else if(ket->ptypes[0]==SR_KEMIP_STR
1123 1122
 					&& ket->ptypes[1]==SR_KEMIP_STR
1124 1123
 					&& ket->ptypes[2]==SR_KEMIP_INT
1124
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
1125
+				ret = ((sr_kemi_fmssns_f)(ket->func))(lmsg,
1126
+						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s);
1127
+				return sr_kemi_apy_return_int(ket, ret);
1128
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
1129
+					&& ket->ptypes[1]==SR_KEMIP_STR
1130
+					&& ket->ptypes[2]==SR_KEMIP_INT
1125 1131
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
1126
-				/* ssnn */
1127 1132
 				ret = ((sr_kemi_fmssnn_f)(ket->func))(lmsg,
1128 1133
 						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n);
1129 1134
 				return sr_kemi_apy_return_int(ket, ret);
1130 1135
 			} else if(ket->ptypes[0]==SR_KEMIP_STR
1131 1136
 					&& ket->ptypes[1]==SR_KEMIP_INT
1137
+					&& ket->ptypes[2]==SR_KEMIP_STR
1138
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
1139
+				ret = ((sr_kemi_fmsnss_f)(ket->func))(lmsg,
1140
+						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s);
1141
+				return sr_kemi_apy_return_int(ket, ret);
1142
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
1143
+					&& ket->ptypes[1]==SR_KEMIP_INT
1144
+					&& ket->ptypes[2]==SR_KEMIP_STR
1145
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
1146
+				ret = ((sr_kemi_fmsnsn_f)(ket->func))(lmsg,
1147
+						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n);
1148
+				return sr_kemi_apy_return_int(ket, ret);
1149
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
1150
+					&& ket->ptypes[1]==SR_KEMIP_INT
1151
+					&& ket->ptypes[2]==SR_KEMIP_INT
1152
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
1153
+				ret = ((sr_kemi_fmsnns_f)(ket->func))(lmsg,
1154
+						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s);
1155
+				return sr_kemi_apy_return_int(ket, ret);
1156
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
1157
+					&& ket->ptypes[1]==SR_KEMIP_INT
1132 1158
 					&& ket->ptypes[2]==SR_KEMIP_INT
1133 1159
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
1134
-				/* snnn */
1135 1160
 				ret = ((sr_kemi_fmsnnn_f)(ket->func))(lmsg,
1136 1161
 						&vps[0].s, vps[1].n, vps[2].n, vps[3].n);
1137 1162
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -1139,23 +1339,48 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self, PyObject *arg
1139 1139
 					&& ket->ptypes[1]==SR_KEMIP_STR
1140 1140
 					&& ket->ptypes[2]==SR_KEMIP_STR
1141 1141
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
1142
-				/* nsss */
1143 1142
 				ret = ((sr_kemi_fmnsss_f)(ket->func))(lmsg,
1144 1143
 						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s);
1145 1144
 				return sr_kemi_apy_return_int(ket, ret);
1146 1145
 			} else if(ket->ptypes[0]==SR_KEMIP_INT
1146
+					&& ket->ptypes[1]==SR_KEMIP_STR
1147
+					&& ket->ptypes[2]==SR_KEMIP_STR
1148
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
1149
+				ret = ((sr_kemi_fmnssn_f)(ket->func))(lmsg,
1150
+						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n);
1151
+				return sr_kemi_apy_return_int(ket, ret);
1152
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
1153
+					&& ket->ptypes[1]==SR_KEMIP_STR
1154
+					&& ket->ptypes[2]==SR_KEMIP_INT
1155
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
1156
+				ret = ((sr_kemi_fmnsns_f)(ket->func))(lmsg,
1157
+						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s);
1158
+				return sr_kemi_apy_return_int(ket, ret);
1159
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
1160
+					&& ket->ptypes[1]==SR_KEMIP_STR
1161
+					&& ket->ptypes[2]==SR_KEMIP_INT
1162
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
1163
+				ret = ((sr_kemi_fmnsnn_f)(ket->func))(lmsg,
1164
+						vps[0].n, &vps[1].s, vps[2].n, vps[3].n);
1165
+				return sr_kemi_apy_return_int(ket, ret);
1166
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
1147 1167
 					&& ket->ptypes[1]==SR_KEMIP_INT
1148 1168
 					&& ket->ptypes[2]==SR_KEMIP_STR
1149 1169
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
1150
-				/* nnss */
1151 1170
 				ret = ((sr_kemi_fmnnss_f)(ket->func))(lmsg,
1152 1171
 						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s);
1153 1172
 				return sr_kemi_apy_return_int(ket, ret);
1154 1173
 			} else if(ket->ptypes[0]==SR_KEMIP_INT
1155 1174
 					&& ket->ptypes[1]==SR_KEMIP_INT
1175
+					&& ket->ptypes[2]==SR_KEMIP_STR
1176
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
1177
+				ret = ((sr_kemi_fmnnsn_f)(ket->func))(lmsg,
1178
+						vps[0].n, vps[1].n, &vps[2].s, vps[3].n);
1179
+				return sr_kemi_apy_return_int(ket, ret);
1180
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
1181
+					&& ket->ptypes[1]==SR_KEMIP_INT
1156 1182
 					&& ket->ptypes[2]==SR_KEMIP_INT
1157 1183
 					&& ket->ptypes[3]==SR_KEMIP_STR) {
1158
-				/* nnns */
1159 1184
 				ret = ((sr_kemi_fmnnns_f)(ket->func))(lmsg,
1160 1185
 						vps[0].n, vps[1].n, vps[2].n, &vps[3].s);
1161 1186
 				return sr_kemi_apy_return_int(ket, ret);
... ...
@@ -1163,13 +1388,11 @@ PyObject *sr_apy_kemi_exec_func_ex(sr_kemi_t *ket, PyObject *self, PyObject *arg
1163 1163
 					&& ket->ptypes[1]==SR_KEMIP_INT
1164 1164
 					&& ket->ptypes[2]==SR_KEMIP_INT
1165 1165
 					&& ket->ptypes[3]==SR_KEMIP_INT) {
1166
-				/* nnnn */
1167 1166
 				ret = ((sr_kemi_fmnnnn_f)(ket->func))(lmsg,
1168 1167
 						vps[0].n, vps[1].n, vps[2].n, vps[3].n);
1169 1168
 				return sr_kemi_apy_return_int(ket, ret);
1170 1169
 			} else {
1171
-				LM_ERR("invalid parameters for: %.*s\n",
1172
-						fname.len, fname.s);
1170
+				LM_ERR("invalid parameters for: %.*s\n", fname.len, fname.s);
1173 1171
 				return sr_kemi_apy_return_false();
1174 1172
 			}
1175 1173
 		break;