- So, progress...

SVN r2707 (scripting)

src/zscript/zcc-parse.lemon

@@ -64,6 +64,10 @@
 %left DOT LPAREN LBRACKET.
 %left SCOPE.
 
+%type declarator {ZCC_Declarator *}
+%type declarator_no_fun {ZCC_Declarator *}
+%type opt_func_body {ZCC_CompoundStmt *}
+%type function_body {ZCC_CompoundStmt *}
 
 main ::= translation_unit. { stat->sc.ScriptMessage("Parse complete\n"); }
 
@@ -180,7 +184,7 @@ class_member ::= default_def.
 class_member ::= const_def.
 
 /*----- Struct Definition -----*/
-/* Structs can define variables, enums<s>, and structs</s>. */
+/* Structs can define variables and enums. */
 
 %type struct_body{ZCC_TreeNode *}
 %type struct_member{ZCC_TreeNode *}
@@ -205,7 +209,7 @@ struct_member(X) ::= enum_def(A).						{ X = A; }
 /*----- Enum Definition -----*/
 /* Enumerators are lists of named integers. */
 
-%type enum_type {EZCCIntType}
+%type enum_type {EZCCBuiltinType}
 %type enum_list {ZCC_EnumNode *}
 %type enumerator {ZCC_EnumNode *}
 
@@ -362,33 +366,67 @@ state_call(X) ::= IDENTIFIER(A) func_expr_list(B).
 default_def ::= DEFAULT compound_statement.
 
 /* Type names */
-%type int_type {EZCCIntType}
+%type int_type {EZCCBuiltinType}
-%type type_name {PType *}
+%type type_name {ZCC_BasicType *}
+%type type_name1 {EZCCBuiltinType}
+%type vector_size {EZCCBuiltinType}
 
-int_type(X) ::= SBYTE.						{ X = ZCCINT_SInt8; }
+int_type(X) ::= SBYTE.						{ X = ZCC_SInt8; }
-int_type(X) ::= BYTE.						{ X = ZCCINT_UInt8; }
+int_type(X) ::= BYTE.						{ X = ZCC_UInt8; }
-int_type(X) ::= SHORT.						{ X = ZCCINT_SInt16; }
+int_type(X) ::= SHORT.						{ X = ZCC_SInt16; }
-int_type(X) ::= USHORT.						{ X = ZCCINT_UInt16; }
+int_type(X) ::= USHORT.						{ X = ZCC_UInt16; }
-int_type(X) ::= INT.						{ X = ZCCINT_SInt32; }
+int_type(X) ::= INT.						{ X = ZCC_SInt32; }
-int_type(X) ::= UINT.						{ X = ZCCINT_UInt32; }
+int_type(X) ::= UINT.						{ X = ZCC_UInt32; }
 
-type_name(X) ::= BOOL.						{ /*FIXME*/ X = TypeBool; }
+type_name1(X) ::= BOOL.						{ X = ZCC_Bool; }
-type_name(X) ::= int_type(A).				{ X = A; }
+type_name1(X) ::= int_type(A).				{ X = A; }
-type_name(X) ::= FLOAT.						{ X = TypeFloat32; }
+type_name1(X) ::= FLOAT.					{ X = ZCC_FloatAuto; }
-type_name(X) ::= DOUBLE.					{ X = TypeFloat64; }
+type_name1(X) ::= DOUBLE.					{ X = ZCC_Float64; }
-type_name(X) ::= STRING.					{ X = TypeString; }
+type_name1(X) ::= STRING.					{ X = ZCC_String; }
-type_name(X) ::= VECTOR vector_size(A).		{ X = NewVector(A); }
+type_name1(X) ::= VECTOR vector_size(A).	{ X = A; }
-type_name(X) ::= NAME.						{ X = TypeName; }
+type_name1(X) ::= NAME.						{ X = ZCC_Name; }
-type_name(X) ::= IDENTIFIER.	/* User-defined type (struct, enum, or class) */
+
+type_name(X) ::= type_name1(A).
 {
-	// FIXME
+	NEW_AST_NODE(BasicType, type);
-	X = NULL;
+	type->Type = A;
+	type->UserType = NULL;
+	X = type;
+}
+type_name(X) ::= IDENTIFIER(A).			/* User-defined type (struct, enum, or class) */
+{
+	NEW_AST_NODE(BasicType, type);
+	NEW_AST_NODE(ZCC_Identifier, id);
+	type->Type = ZCC_UserType;
+	type->UserType = id;
+	id->Id = A;
+	X = type;
+}
+type_name(X) ::= LBRACKET dottable_id(A) RBRACKET.
+{
+	NEW_AST_NODE(BasicType, type);
+	type->Type = ZCC_UserType;
+	type->UserType = A;
+	X = type;
 }
 
-%type vector_size {unsigned int}
+/* Vectors can be 2, 3, or 4 entries long. Default is a 3D vector.
-
+ * (Well, actually, I'm not sure if 4D ones are going to happen
-vector_size ::= .
+ * straight away.)
-vector_size(X) ::= LT INTCONST(A) GT.	{ X = A.Int; }
+ */
+vector_size(X) ::= .						{ X = ZCC_Vector3; }
+vector_size(X) ::= LT INTCONST(A) GT.
+{
+	if (A.Int >= 2 && A.Int <= 4)
+	{
+		X = ZCC_Vector2 + A.Int - 2;
+	}
+	else
+	{
+		X = ZCC_Vector3;
+		stat->sc.ScriptMessage("Invalid vector size %d\n", A.Int);
+	}
+}
 
 /* Type names can also be used as identifiers in contexts where type names
  * are not normally allowed. */
@@ -401,15 +439,32 @@ vector_size(X) ::= LT INTCONST(A) GT.	{ X = A.Int; }
 %type type_list {ZCC_Type *}
 %type type_list_or_void {ZCC_Type *}
 %type type_or_array {ZCC_Type *}
-%type class_restrictor {PClass *}
+%type class_restrictor {ZCC_Identifier *}
 %type array_size{ZCC_Expression *}
 
-aggregate_type ::= MAP LT type_or_array COMMA type_or_array GT.		/* Hash table */
+aggregate_type(X) ::= MAP LT type_or_array(A) COMMA type_or_array(B) GT.	/* Hash table */
-aggregate_type ::= ARRAY LT type_or_array GT.					/* TArray<type> */
+{
-aggregate_type ::= CLASS class_restrictor.					/* class<type> */
+	NEW_AST_NODE(ZCC_MapType,map);
+	map->KeyType = A;
+	map->ValueType = B;
+	X = map;
+}
 
-class_restrictor ::= .
+aggregate_type(X) ::= ARRAY LT type_or_array(A) GT.							/* TArray<type> */
-class_restrictor ::= LT IDENTIFIER GT.
+{
+	NEW_AST_NODE(ZCC_DynArrayType,arr);
+	map->ElementType = A;
+	X = map;
+}
+
+aggregate_type(X) ::= CLASS class_restrictor(A).							/* class<type> */
+{
+	NEW_AST_NODE(ZCC_ClassType,cls);
+	cls->Restriction = A;
+	X = cls;
+}
+class_restrictor(X) ::= .						{ X = NULL; }
+class_restrictor(X) ::= LT dottable_id(A) GT.	{ X = A; }
 
 type(X) ::= type_name(A).					{ X = A; A->ArraySize = NULL; }
 type(X) ::= aggregate_type(A).				{ X = A; A->ArraySize = NULL; }
@@ -451,17 +506,99 @@ array_size(X) ::= array_size(A) LBRACKET opt_expr(B) RBRACKET.
 	X = A;
 }
 
-declarator ::= decl_flags type_list_or_void variables_or_function.	/* Multiple type names are only valid for functions. */
+%include
-declarator_no_fun ::= decl_flags type variable_list.
+{
+	struct VarOrFun
+	{
+		ZCC_VarName *VarNames;
+		ZCC_FuncParamDecl *FuncParams;
+		ENamedName FuncName;
+		int FuncFlags;
+	};
+}
+%type variables_or_function {VarOrFun}
 
-variables_or_function ::= IDENTIFIER LPAREN func_params RPAREN func_const opt_func_body.	/* Function */
+/* Multiple type names are only valid for functions. */
-variables_or_function ::= variable_list SEMICOLON.
+declarator(X) ::= decl_flags(A) type_list_or_void(B) variables_or_function(C).
+{
+	if (C.FuncParams == NULL && C.VarNames == NULL)
+	{ // An error. A message was already printed.
+		X = NULL;
+	}
+	else if (C.FuncParams != NULL)
+	{ // A function
+		NEW_AST_NODE(FuncDeclarator, decl);
+		decl->Type = B;
+		decl->Params = C.FuncParams;
+		decl->Name = C.FuncName;
+		decl->Flags = A | C.FuncFlags;
+		X = decl;
+	}
+	else if (B != NULL && B->Sibling == NULL)
+	{ // A variable
+		NEW_AST_NODE(VarDeclarator, decl);
+		decl->Type = B;
+		decl->Names = C.VarNames;
+		decl->Flags = A;
+		X = decl;
+	}
+	else
+	{ // An invalid
+		if (B == NULL)
+		{
+			sc.ScriptMessage("Variables may not be of type void.\n");
+		}
+		else
+		{
+			sc.ScriptMessage("Variables may be of only one type.\n");
+		}
+		X = NULL;
+	}
+}
+declarator_no_fun(X) ::= decl_flags(A) type(B) variable_list(C).
+{
+	NEW_AST_NODE(VarDeclarator, decl);
+	decl->Type = B;
+	decl->Names = C;
+	decl->Flags = A;
+	X = decl;
+}
+
+// Need to split it up like this to avoid parsing conflicts.
+variables_or_function(X) ::= IDENTIFIER(A) LPAREN func_params(B) RPAREN func_const(C) opt_func_body(D).	/* Function */
+{
+	VarOrFun fun;
+
+	fun.VarNames = NULL;
+	fun.FuncParams = B;
+	fun.FuncFlags = C;
+	fun.FuncName = A.Name();
+	fun.FuncBody = D;
+	X = fun;
+}
+variables_or_function(X) ::= variable_list(A) SEMICOLON.
+{
+	VarOrFun var;
+
+	var.VarNames = A;
+	var.FuncParams = NULL;
+	var.FuncFlags = 0;
+	var.FuncName = NAME_None;
+	var.FuncBody = NULL;
+	X = var;
+}
 variables_or_function ::= error SEMICOLON.
+{
+	VarOrFun bad;
+	bad.VarNames = NULL;
+	bad.FuncParams = NULL;
+	bad.FuncFlags = 0;
+	bad.FuncName = NAME_None;
+	bad.Func_Body = NULL;
+	X = bad;
+}
 
 /*----- Variable Names -----*/
-// They get the array size, because that makes it look more like C.
-// I might still change my mind and stick array sizes with the rest
-// of the type like C#.
 
 %type variable_name{ZCC_VarName *}
 %type variable_list{ZCC_VarName *}
@@ -499,8 +636,8 @@ decl_flags(X) ::= decl_flags(A) DEPRECATED.	{ X = A | ZCC_Deprecated; }
 func_const ::= .
 func_const ::= CONST.
 
-opt_func_body ::= SEMICOLON.
+opt_func_body(X) ::= SEMICOLON.				{ X = NULL; }
-opt_func_body ::= function_body.
+opt_func_body(X) ::= function_body(A).		{ X = A; }
 
 %type func_params {ZCC_FuncParamDecl *}
 %type func_param_list {ZCC_FuncParamDecl *}

src/zscript/zcc_parser.h

@@ -93,15 +93,26 @@ enum EZCCTreeNodeType
 	AST_ConstantDef,
 };
 
-enum EZCCIntType
+enum EZCCBuiltinType
 {
-	ZCCINT_SInt8,
+	ZCC_SInt8,
-	ZCCINT_UInt8,
+	ZCC_UInt8,
-	ZCCINT_SInt16,
+	ZCC_SInt16,
-	ZCCINT_UInt16,
+	ZCC_UInt16,
-	ZCCINT_SInt32,
+	ZCC_SInt32,
-	ZCCINT_UInt32,
+	ZCC_UInt32,
-	ZCCINT_Auto,	// for enums, autoselect appropriately sized int
+	ZCC_IntAuto,	// for enums, autoselect appropriately sized int
+
+	ZCC_Bool,
+	ZCC_Float32,
+	ZCC_Float64,
+	ZCC_FloatAuto,	// 32-bit in structs/classes, 64-bit everywhere else
+	ZCC_String,
+	ZCC_Vector2,
+	ZCC_Vector3,
+	ZCC_Vector4,
+	ZCC_Name,
+	ZCC_UserType,
 };
 
 enum EZCCExprType
@@ -293,8 +304,8 @@ struct ZCC_Type : ZCC_TreeNode
 
 struct ZCC_BasicType : ZCC_Type
 {
-	PType *Type;
+	EZCCBuiltinType	Type;
-	ENamedName TypeName;
+	ZCC_Identifier *UserType;
 };
 
 struct ZCC_MapType : ZCC_Type
@@ -310,7 +321,24 @@ struct ZCC_DynArrayType : ZCC_Type
 
 struct ZCC_ClassType : ZCC_Type
 {
-	ENamedName Restriction;
+	ZCC_Identifier *Restriction;
+};
+
+// A variable in a class or struct.
+struct ZCC_VarDeclarator : ZCC_TreeNode
+{
+	ZCC_Type *Type;
+	ZCC_VarName *Names;
+	int Flags;
+};
+
+// A function in a class.
+struct ZCC_FuncDeclarator : ZCC_TreeNode
+{
+	ZCC_Type *Type;
+	ZCC_FuncParamDecl *Params;
+	ENamedName Name;
+	int Flags;
 };
 
 struct ZCC_ExprID : ZCC_Expression