Make various functions variadic

Perform more complete checking of argument and result types


git-svn-id: https://svn.osgeo.org/grass/grass/trunk@33501 15284696-431f-4ddb-bdfa-cd5b030d7da7

raster/r.mapcalc/check.c

@@ -130,6 +130,22 @@ int c_cmpop(int argc, int *argt)
 
 int c_logop(int argc, int *argt)
 {
+    int i;
+
+    if (argc < 1)
+	return E_ARG_LO;
+
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
+    argt[0] = CELL_TYPE;
+
+    return 0;
+}
+
+int c_shiftop(int argc, int *argt)
+{
     if (argc < 2)
 	return E_ARG_LO;
     if (argc > 2)

raster/r.mapcalc/func_proto.h

@@ -28,10 +28,12 @@ extern func_t f_or2;
 extern func_t f_bitand;
 extern func_t f_bitor;
 extern func_t f_bitxor;
+extern args_t c_logop;
+
 extern func_t f_shiftl;
 extern func_t f_shiftr;
 extern func_t f_shiftru;
-extern args_t c_logop;
+extern args_t c_shiftop;
 
 extern func_t f_not;
 extern func_t f_bitnot;

raster/r.mapcalc/function.c

@@ -8,9 +8,9 @@
 #include "func_proto.h"
 
 func_desc func_descs[] = {
-    {"add", c_binop, f_add},
+    {"add", c_varop, f_add},
     {"sub", c_binop, f_sub},
-    {"mul", c_binop, f_mul},
+    {"mul", c_varop, f_mul},
     {"div", c_binop, f_div},
     {"mod", c_binop, f_mod},
     {"pow", c_binop, f_pow},
@@ -36,9 +36,10 @@ func_desc func_descs[] = {
     {"bitand", c_logop, f_bitand},
     {"bitor", c_logop, f_bitor},
     {"xor", c_logop, f_bitxor},
-    {"shiftl", c_logop, f_shiftl},
-    {"shiftr", c_logop, f_shiftr},
-    {"shiftru", c_logop, f_shiftru},
+
+    {"shiftl", c_shiftop, f_shiftl},
+    {"shiftr", c_shiftop, f_shiftr},
+    {"shiftru", c_shiftop, f_shiftru},
 
     {"bitnot", c_not, f_bitnot},
 

raster/r.mapcalc/xadd.c

@@ -5,61 +5,69 @@
 #include "func_proto.h"
 
 /****************************************************************
-add(a,b) = a + b
+add(a,b,c,...) = a + b + c + ...
 ****************************************************************/
 
 int f_add(int argc, const int *argt, void **args)
 {
-    int i;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
 
-    if (argt[1] != argt[0] || argt[2] != argt[0])
-	return E_ARG_TYPE;
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
 
     switch (argt[0]) {
     case CELL_TYPE:
 	{
 	    CELL *res = args[0];
-	    CELL *arg1 = args[1];
-	    CELL *arg2 = args[2];
+	    CELL **argz = (CELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-		    SET_NULL_C(&res[i]);
-		else
-		    res[i] = arg1[i] + arg2[i];
+		res[i] = 0;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_C(&argz[j][i])) {
+			SET_NULL_C(&res[i]);
+			break;
+		    }
+		    res[i] += argz[j][i];
+		}
 	    }
 	    return 0;
 	}
     case FCELL_TYPE:
 	{
 	    FCELL *res = args[0];
-	    FCELL *arg1 = args[1];
-	    FCELL *arg2 = args[2];
+	    FCELL **argz = (FCELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_F(&arg1[i]) || IS_NULL_F(&arg2[i]))
-		    SET_NULL_F(&res[i]);
-		else
-		    res[i] = arg1[i] + arg2[i];
+		res[i] = 0;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_F(&argz[j][i])) {
+			SET_NULL_F(&res[i]);
+			break;
+		    }
+		    res[i] += argz[j][i];
+		}
 	    }
 	    return 0;
 	}
     case DCELL_TYPE:
 	{
 	    DCELL *res = args[0];
-	    DCELL *arg1 = args[1];
-	    DCELL *arg2 = args[2];
+	    DCELL **argz = (DCELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_D(&arg1[i]) || IS_NULL_D(&arg2[i]))
-		    SET_NULL_D(&res[i]);
-		else
-		    res[i] = arg1[i] + arg2[i];
+		res[i] = 0;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_D(&argz[j][i])) {
+			SET_NULL_D(&res[i]);
+			break;
+		    }
+		    res[i] += argz[j][i];
+		}
 	    }
 	    return 0;
 	}

raster/r.mapcalc/xand.c

@@ -5,32 +5,35 @@
 #include "func_proto.h"
 
 /****************************************************************
-and(a,b) = a && b
+and(a,b,c,...) = a && b && c && ...
 ****************************************************************/
 
 int f_and(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    CELL **argz = (CELL **) args;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = arg1[i] && arg2[i];
+	res[i] = 1;
+	for (j = 1; j <= argc; j++) {
+	    if (IS_NULL_C(&argz[j][i])) {
+		SET_NULL_C(&res[i]);
+		break;
+	    }
+	    if (!argz[j][i])
+		res[i] = 0;
+	}
     }
 
     return 0;

raster/r.mapcalc/xand2.c

@@ -5,7 +5,7 @@
 #include "func_proto.h"
 
 /****************************************************************
-and2(a,b) = a && b
+and2(a,b,c,...) = a && b && c && ...
 
 Differs from and() in that the boolean axioms:
 
@@ -18,30 +18,29 @@ hold even when x is null.
 int f_and2(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    CELL **argz = (CELL **) args;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (!IS_NULL_C(&arg1[i]) && !arg1[i])
-	    res[i] = 0;
-	else if (!IS_NULL_C(&arg2[i]) && !arg2[i])
-	    res[i] = 0;
-	else if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = 1;
+	res[i] = 1;
+	for (j = 1; j <= argc; j++) {
+	    if (!IS_NULL_C(&argz[j][i]) && !argz[j][i]) {
+		res[i] = 0;
+		break;
+	    }
+	    if (IS_NULL_C(&argz[j][i]))
+		SET_NULL_C(&res[i]);
+	}
     }
 
     return 0;

raster/r.mapcalc/xbitand.c

@@ -5,32 +5,34 @@
 #include "func_proto.h"
 
 /****************************************************************
-bitand(a,b) = a & b
+bitand(a,b,c,...) = a & b & c & ...
 ****************************************************************/
 
 int f_bitand(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    CELL **argz = (CELL **) args;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = arg1[i] & arg2[i];
+	res[i] = ~0;
+	for (j = 1; j <= argc; j++) {
+	    if (IS_NULL_C(&argz[j][i])) {
+		SET_NULL_C(&res[i]);
+		break;
+	    }
+	    res[i] &= argz[j][i];
+	}
     }
 
     return 0;

raster/r.mapcalc/xbitor.c

@@ -5,32 +5,34 @@
 #include "func_proto.h"
 
 /****************************************************************
-bitor(a,b) = a | b
+bitor(a,b,c,...) = a | b | c | ...
 ****************************************************************/
 
 int f_bitor(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    CELL **argz = (CELL **) args;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = arg1[i] | arg2[i];
+	res[i] = 0;
+	for (j = 1; j <= argc; j++) {
+	    if (IS_NULL_C(&argz[j][i])) {
+		SET_NULL_C(&res[i]);
+		break;
+	    }
+	    res[i] |= argz[j][i];
+	}
     }
 
     return 0;

raster/r.mapcalc/xbitxor.c

@@ -5,32 +5,34 @@
 #include "func_proto.h"
 
 /****************************************************************
-bitxor(a,b) = a ^ b
+bitxor(a,b,c,...) = a ^ b ^ c ^ ...
 ****************************************************************/
 
 int f_bitxor(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    CELL **argz = (CELL **) args;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != CELL_TYPE)
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = arg1[i] ^ arg2[i];
+	res[i] = 0;
+	for (j = 1; j <= argc; j++) {
+	    if (IS_NULL_C(&argz[j][i])) {
+		SET_NULL_C(&res[i]);
+		break;
+	    }
+	    res[i] ^= argz[j][i];
+	}
     }
 
     return 0;

raster/r.mapcalc/xeq.c

@@ -18,6 +18,13 @@ int f_eq(int argc, const int *argt, void **args)
     if (argc > 2)
 	return E_ARG_HI;
 
+    if (argt[0] != CELL_TYPE)
+	return E_RES_TYPE;
+
+    for (i = 2; i <= argc; i++)
+	if (argt[i] != argt[1])
+	    return E_ARG_TYPE;
+
     switch (argt[1]) {
     case CELL_TYPE:
 	{

raster/r.mapcalc/xmax.c

@@ -17,6 +17,10 @@ int f_max(int argc, const int *argt, void **args)
     if (argc < 1)
 	return E_ARG_LO;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     switch (argt[0]) {
     case CELL_TYPE:
 	{

raster/r.mapcalc/xmedian.c

@@ -50,16 +50,23 @@ int f_median(int argc, const int *argt, void **args)
     int size = argc * G_raster_size(argt[0]);
     int i, j;
 
+    if (argc < 1)
+	return E_ARG_LO;
+
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     if (size > alloc) {
 	alloc = size;
 	array = G_realloc(array, size);
     }
 
-    switch (argt[argc]) {
+    switch (argt[0]) {
     case CELL_TYPE:
 	{
 	    CELL *res = args[0];
-	    CELL **argv = (CELL **) & args[1];
+	    CELL **argv = (CELL **) &args[1];
 	    CELL *a = array;
 	    CELL *a1 = &a[(argc - 1) / 2];
 	    CELL *a2 = &a[argc / 2];
@@ -87,7 +94,7 @@ int f_median(int argc, const int *argt, void **args)
     case FCELL_TYPE:
 	{
 	    FCELL *res = args[0];
-	    FCELL **argv = (FCELL **) & args[1];
+	    FCELL **argv = (FCELL **) &args[1];
 	    FCELL *a = array;
 	    FCELL *a1 = &a[(argc - 1) / 2];
 	    FCELL *a2 = &a[argc / 2];
@@ -115,7 +122,7 @@ int f_median(int argc, const int *argt, void **args)
     case DCELL_TYPE:
 	{
 	    DCELL *res = args[0];
-	    DCELL **argv = (DCELL **) & args[1];
+	    DCELL **argv = (DCELL **) &args[1];
 	    DCELL *a = array;
 	    DCELL *a1 = &a[(argc - 1) / 2];
 	    DCELL *a2 = &a[argc / 2];

raster/r.mapcalc/xmin.c

@@ -17,6 +17,10 @@ int f_min(int argc, const int *argt, void **args)
     if (argc < 1)
 	return E_ARG_LO;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     switch (argt[0]) {
     case CELL_TYPE:
 	{

raster/r.mapcalc/xmode.c

@@ -58,6 +58,13 @@ int f_mode(int argc, const int *argt, void **args)
     int size = argc * sizeof(double);
     int i, j;
 
+    if (argc < 1)
+	return E_ARG_LO;
+
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     if (size > value_size) {
 	value_size = size;
 	value = G_realloc(value, value_size);

raster/r.mapcalc/xmul.c

@@ -10,56 +10,64 @@ mul(a,b) = a * b
 
 int f_mul(int argc, const int *argt, void **args)
 {
-    int i;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
 
-    if (argt[1] != argt[0] || argt[2] != argt[0])
-	return E_ARG_TYPE;
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
 
     switch (argt[0]) {
     case CELL_TYPE:
 	{
 	    CELL *res = args[0];
-	    CELL *arg1 = args[1];
-	    CELL *arg2 = args[2];
+	    CELL **argz = (CELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-		    SET_NULL_C(&res[i]);
-		else
-		    res[i] = arg1[i] * arg2[i];
+		res[i] = 1;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_C(&argz[j][i])) {
+			SET_NULL_C(&res[i]);
+			break;
+		    }
+		    res[i] *= argz[j][i];
+		}
 	    }
 	    return 0;
 	}
     case FCELL_TYPE:
 	{
 	    FCELL *res = args[0];
-	    FCELL *arg1 = args[1];
-	    FCELL *arg2 = args[2];
+	    FCELL **argz = (FCELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_F(&arg1[i]) || IS_NULL_F(&arg2[i]))
-		    SET_NULL_F(&res[i]);
-		else
-		    res[i] = arg1[i] * arg2[i];
+		res[i] = 1;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_F(&argz[j][i])) {
+			SET_NULL_F(&res[i]);
+			break;
+		    }
+		    res[i] *= argz[j][i];
+		}
 	    }
 	    return 0;
 	}
     case DCELL_TYPE:
 	{
 	    DCELL *res = args[0];
-	    DCELL *arg1 = args[1];
-	    DCELL *arg2 = args[2];
+	    DCELL **argz = (DCELL **) args;
 
 	    for (i = 0; i < columns; i++) {
-		if (IS_NULL_D(&arg1[i]) || IS_NULL_D(&arg2[i]))
-		    SET_NULL_D(&res[i]);
-		else
-		    res[i] = arg1[i] * arg2[i];
+		res[i] = 1;
+		for (j = 1; j <= argc; j++) {
+		    if (IS_NULL_D(&argz[j][i])) {
+			SET_NULL_D(&res[i]);
+			break;
+		    }
+		    res[i] *= argz[j][i];
+		}
 	    }
 	    return 0;
 	}

raster/r.mapcalc/xor.c

@@ -5,32 +5,35 @@
 #include "func_proto.h"
 
 /****************************************************************
-or(a,b) = a || b
+or(a,b,c,...) = a || b || c || ...
 ****************************************************************/
 
 int f_or(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = arg1[i] || arg2[i];
+	res[i] = 0;
+	for (j = 1; j <= argc; j++) {
+	    CELL *arg = args[j];
+	    if (IS_NULL_C(&arg[i])) {
+		SET_NULL_C(&res[i]);
+		break;
+	    }
+	    if (arg[i])
+		res[i] = 1;
+	}
     }
 
     return 0;

raster/r.mapcalc/xor2.c

@@ -5,7 +5,7 @@
 #include "func_proto.h"
 
 /****************************************************************
-or2(a,b) = a || b
+or2(a,b,c,...) = a || b || c || ...
 
 Differs from or() in that the boolean axioms:
 
@@ -18,30 +18,29 @@ hold even when x is null.
 int f_or2(int argc, const int *argt, void **args)
 {
     CELL *res = args[0];
-    CELL *arg1 = args[1];
-    CELL *arg2 = args[2];
-    int i;
+    int i, j;
 
-    if (argc < 2)
+    if (argc < 1)
 	return E_ARG_LO;
-    if (argc > 2)
-	return E_ARG_HI;
-
-    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
-	return E_ARG_TYPE;
 
     if (argt[0] != CELL_TYPE)
 	return E_RES_TYPE;
 
+    for (i = 1; i <= argc; i++)
+	if (argt[i] != argt[0])
+	    return E_ARG_TYPE;
+
     for (i = 0; i < columns; i++) {
-	if (!IS_NULL_C(&arg1[i]) && arg1[i])
-	    res[i] = 1;
-	else if (!IS_NULL_C(&arg2[i]) && arg2[i])
-	    res[i] = 1;
-	else if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
-	    SET_NULL_C(&res[i]);
-	else
-	    res[i] = 0;
+	res[i] = 0;
+	for (j = 1; j <= argc; j++) {
+	    CELL *arg = args[j];
+	    if (!IS_NULL_C(&arg[i]) && arg[i]) {
+		res[i] = 1;
+		break;
+	    }
+	    if (IS_NULL_C(&arg[i]))
+		SET_NULL_C(&res[i]);
+	}
     }
 
     return 0;