[agd-cvs] server/src dfparse.y,1.9,1.10

[Peep P. <so...@us...>]

Update of /cvsroot/agd/server/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv14296

Modified Files:
	dfparse.y 
Log Message:
Removed argument variants.

Index: dfparse.y
===================================================================
RCS file: /cvsroot/agd/server/src/dfparse.y,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- dfparse.y	7 Jun 2004 15:40:03 -0000	1.9
+++ dfparse.y	8 Jun 2004 20:36:41 -0000	1.10
@@ -1,7 +1,14 @@
 /*
-	parser for dfdecl
+	parser for dfdecl.in
+
+	NOTE: Maybe we could put the prototypes in dfuns.h or in dfuns.c?
 
 	Changelog:
+	0.09:
+		* Not using argument variants any more.
+		* Prints out return type as a string.
+		* General cleanup, less memory use and less grammar rules.
+		* Doesn't cast function pointers. Saves space.
 	0.08:
 		* Not using array_{push,concat} etc anymore. No changes in output.
 	0.07:
@@ -33,29 +40,35 @@
 #include "sys.h" /* xmalloc */
 #include "lpc.h"
 
-#define DFVERSION "0.08"
+#define DFVERSION "0.09"
 #define DFDECL_T "typedef struct {\n\tint ret;\n\tchar *name;\n\tvoid (*fun)(void);\n\t"\
-		 "int arglen;\n\tint args[%d];\n} dfdecl_t;\n"
+		 "int num_arg;\n\tint args[%d];\n} dfdecl_t;\n"
+
 typedef struct {
 	int ret;
 	char *name;
-	int arglen;
+	int num_arg;
 	int *args;
 } dfdecl_t;
 dfdecl_t *dfdecl;
+
 static int numdecl, failed;
-static int maxarglen;
+static int greatest_num_arg;
 
 extern FILE *yyin;
 
+typedef struct arr arr_t;
 %}
 
+/* Force yacc to define yylloc. */
+%locations
+
 %union {
 	char *s;
 	int i;
-	struct arr_t {
-		int length;
-		long int *data;
+	struct arr {
+		int len;
+		int *data;
 	} a;
 }
 
@@ -63,9 +76,7 @@
 %token <i> L_DATA_TYPE
 
 %type <i> type
-%type <a> arguments argument
-%type <a> another_argument another_type
-%type <a> argument_and_another type_and_another
+%type <a> arguments argument_and_another
 
 %%
 
@@ -77,15 +88,22 @@
 dfdecl:
 	type L_IDENTIFIER '(' arguments ')'
 	{
-		int i, j, index;
+/*		int i, j, index;*/
 		dfdecl_t decl;
 
-		int find_linear_len(struct arr_t *a);
+/*		int find_linear_len(struct arr_t *a);*/
 		
-		@1; /* To force bison to define yylloc. */
-
 		decl.ret = $1;
 		decl.name = $2;
+		decl.num_arg = $4.len;
+		if(decl.num_arg > greatest_num_arg)
+			greatest_num_arg = decl.num_arg;
+		if(decl.num_arg)
+			decl.args = $4.data;
+		
+		dfdecl = xrealloc(dfdecl, sizeof(dfdecl_t) * ++numdecl);
+		dfdecl[numdecl-1] = decl;
+/*
 		decl.arglen = find_linear_len(&$4);
 		if(decl.arglen > maxarglen)
 			maxarglen = decl.arglen;
@@ -93,33 +111,40 @@
 			decl.args = xmalloc(sizeof(int) * decl.arglen);
 		for(index=i=0;i<$4.length;i++) {
 			struct arr_t *var = (struct arr_t *) $4.data[i];
-			foo();
 			decl.args[index++] = var->length;
 			for(j=0;j<var->length;j++)
 				decl.args[index++] = (int) var->data[j];
 		}
 		dfdecl = xrealloc(dfdecl, sizeof(dfdecl_t) * ++numdecl);
 		dfdecl[numdecl-1] = decl;
+*/
+
 	}
 	;
 
-type: L_DATA_TYPE /* optional_star */;
-
+type:
+	L_DATA_TYPE /* optional_star */
+	;
+	
 arguments:
-	/* empty */ { $$.length = 0; }
+	/* empty */ { $$.len = 0; }
 	| argument_and_another
 	;
 
-argument: type_and_another;
-
-another_argument:
-	/* empty */ { $$.length = 0; }
-	| ',' argument_and_another { $$ = $2; }
-	;
-
 argument_and_another:
-	argument another_argument
+	type
+	{
+		$$.len = 1;
+		$$.data = xmalloc(sizeof(arr_t));
+		$$.data[0] = $1;
+	}
+	| argument_and_another ',' type
 	{
+		$$ = $1;
+		$$.len++;
+		$$.data = xrealloc($$.data, $$.len * sizeof(arr_t));
+		$$.data[$$.len-1] = $3;
+/*		
 		int i, foo;
 		
 		foo = $1.length ? 1 : 0;
@@ -135,30 +160,7 @@
 		for(i=foo;i<$$.length;i++) {
 			$$.data[i] = $2.data[i-foo];
 		}
-	}
-	;
-	
-another_type:
-	/* empty */	{ $$.length = 0; }
-	| '|' type_and_another { $$ = $2; }
-	;
-	
-type_and_another:
-	type another_type
-	{
-		int i, foo;
-
-		foo = $1 != T_VOID ? 1 : 0;
-		$$.length = $2.length + foo;
-		$$.data = xmalloc(sizeof(int) * $$.length);
-		
-		if($1 != T_VOID) {
-			$$.data[0] = $1;
-		}
-		
-		for(i=foo;i<$$.length;i++) {
-			$$.data[i] = $2.data[i-foo];
-		}
+*/
 	}
 	;
 	
@@ -172,6 +174,7 @@
 	return 0;
 }
 
+#if 0
 int find_linear_len(struct arr_t *a)
 {
 	int len;
@@ -182,18 +185,55 @@
 	}
 	return len;
 }
+#endif
+
+void write_type(int t)
+{
+	/* Just for readability. */
+	switch(t) {
+		case T_INT:
+			printf("T_INT");
+			break;
+		case T_STRING:
+			printf("T_STRING");
+			break;
+		case T_OBJECT:
+			printf("T_OBJECT");
+			break;
+		case T_VOID:
+			printf("T_VOID");
+			break;
+		default:
+			printf("%d", t);
+			break;
+	}
+}
 
 void print_declarations(void)
 {
-	int i, j, k;
+	int i, j/*, k*/;
 
 	printf("dfdecl_t decl[] = {\n");
 	for(i=0;i<numdecl;i++) {
-		printf("\t/* %d */ { %d, \"%s\", (void (*)(void))df_%s, ",
-			  i, dfdecl[i].ret, dfdecl[i].name, dfdecl[i].name);
+		printf("\t/* %d */ { ", i);
+		write_type(dfdecl[i].ret);
+		printf(", \"%s\", df_%s, ",
+					dfdecl[i].name, dfdecl[i].name);
 
-		printf("%d, {", dfdecl[i].arglen);
-		for(j=0;j<dfdecl[i].arglen;j++) {
+		printf("%d", dfdecl[i].num_arg);
+		if(dfdecl[i].num_arg)
+			printf(", {");
+		for(j=0;j<dfdecl[i].num_arg;j++) {
+			putchar(' ');
+			
+			write_type(dfdecl[i].args[j]);
+
+			if(j+1 < dfdecl[i].num_arg)
+				putchar(',');
+			else
+				putchar(' ');
+
+#if 0
 			int len = dfdecl[i].args[j];
 			printf(" %d,", len);
 			for(k=j+1;k-j<=len;k++) {
@@ -212,11 +252,14 @@
 					putchar(' ');
 			}
 			j += len;
+#endif
 		}
 
-		if(!j)
-			printf("0");
-		printf("} }");
+/*		if(!j)
+			printf("0");*/
+		if(j)
+			putchar('}');
+		printf(" }");
 		if(i+1 < numdecl)
 			putchar(',');
 		putchar('\n');
@@ -259,7 +302,8 @@
 	printf("/* dfdecl.h: dfun declarations\n   generated by dfparse %s on %s */\n",
 		DFVERSION, timestr);
 	printf("#define NUM_DF %d\n", numdecl);
-	printf(DFDECL_T, maxarglen);
+
+	printf(DFDECL_T, greatest_num_arg);
 
 	print_prototypes();
 	print_declarations();
@@ -267,5 +311,3 @@
 	return 0;
 }
 
-foo() {
-}