vim: src/vim9class.c comparison

comparison src/vim9class.c @ 33506:f61713271934 v9.0.2002

patch 9.0.2002: Vim9: need cleanup of class related interface code Commit: https://github.com/vim/vim/commit/b852305dbf42f1206ecc6ae414fc200235fe2963 Author: Yegappan Lakshmanan <yegappan@yahoo.com> Date: Sun Oct 8 19:07:39 2023 +0200 patch 9.0.2002: Vim9: need cleanup of class related interface code Problem: Vim9: need cleanup of class related interface code Solution: Remove the unused class variable and class method related code for interfaces. Remove unused class variable and class method related code for interfaces. Refactor the code. Optimize the object/class member double lookup in compile_lhs(). Change unused global functions to static functions. closes: #13302 Signed-off-by: Christian Brabandt <cb@256bit.org> Co-authored-by: Yegappan Lakshmanan <yegappan@yahoo.com>

author	Christian Brabandt <cb@256bit.org>
date	Sun, 08 Oct 2023 19:15:06 +0200
parents	bff8ac203a22
children	c8bd88bdb630

comparison

equal deleted inserted replaced

-:398e729a5cd9
+:f61713271934
 */
 static int
 intf_variable_present(
 char_u	*intf_class_name,
 ocmember_T *if_var,
-int		is_class_var,
 ocmember_T *cl_mt,
 int		cl_member_count,
 class_T	*extends_cl)
 {
 int		variable_present  = FALSE;
 	break;
 }
 if (!variable_present && extends_cl != NULL)
 {
-	int ext_cl_count = is_class_var
+	int ext_cl_count = extends_cl->class_obj_member_count;
-				? extends_cl->class_class_member_count
+	ocmember_T *ext_cl_mt = extends_cl->class_obj_members;
-				: extends_cl->class_obj_member_count;
-	ocmember_T *ext_cl_mt = is_class_var
-				? extends_cl->class_class_members
-				: extends_cl->class_obj_members;
 	return intf_variable_present(intf_class_name, if_var,
-					is_class_var, ext_cl_mt,
+					ext_cl_mt, ext_cl_count,
-					ext_cl_count,
 					extends_cl->class_extends);
 }
 return variable_present;
 }
 /*
-* Check the variables of the interface class "ifcl" match the class variables
+* Check the variables of the interface class "ifcl" match object variables
-* ("classmembers_gap") and object variables ("objmembers_gap") of a class.
+* ("objmembers_gap") of a class.
-* Returns TRUE if the class and object variables names are valid.
+* Returns TRUE if the object variables names are valid.
 */
 static int
 validate_interface_variables(
 char_u	*intf_class_name,
 class_T	*ifcl,
-garray_T	*classmembers_gap,
 garray_T	*objmembers_gap,
 class_T	*extends_cl)
 {
-for (int loop = 1; loop <= 2; ++loop)
+int if_count = ifcl->class_obj_member_count;
-{
+if (if_count == 0)
-	// loop == 1: check class variables
+	return TRUE;
-	// loop == 2: check object variables
-	int is_class_var = (loop == 1);
+ocmember_T *if_ms = ifcl->class_obj_members;
-	int if_count = is_class_var ? ifcl->class_class_member_count
+ocmember_T *cl_ms = (ocmember_T *)(objmembers_gap->ga_data);
-						: ifcl->class_obj_member_count;
+int cl_count = objmembers_gap->ga_len;
-	if (if_count == 0)
+for (int if_i = 0; if_i < if_count; ++if_i)
-	    continue;
+{
-	ocmember_T *if_ms = is_class_var ? ifcl->class_class_members
+	if (!intf_variable_present(intf_class_name, &if_ms[if_i], cl_ms,
-						: ifcl->class_obj_members;
+							cl_count, extends_cl))
-	ocmember_T *cl_ms = (ocmember_T *)(is_class_var
+	{
-						? classmembers_gap->ga_data
+	    semsg(_(e_variable_str_of_interface_str_not_implemented),
-						: objmembers_gap->ga_data);
+		    if_ms[if_i].ocm_name, intf_class_name);
-	int cl_count = is_class_var ? classmembers_gap->ga_len
+	    return FALSE;
-						: objmembers_gap->ga_len;
-	for (int if_i = 0; if_i < if_count; ++if_i)
-	{
-	    if (!intf_variable_present(intf_class_name, &if_ms[if_i],
-				is_class_var, cl_ms, cl_count, extends_cl))
-	    {
-		semsg(_(e_variable_str_of_interface_str_not_implemented),
-			if_ms[if_i].ocm_name, intf_class_name);
-		return FALSE;
-	    }
 	}
 }
 return TRUE;
 }
 * in "extends_cl".  For a class method, 'is_class_method' is TRUE.
 */
 static int
 intf_method_present(
 ufunc_T *if_ufunc,
-int	    is_class_method,
 ufunc_T **cl_fp,
 int	    cl_count,
 class_T *extends_cl)
 {
 int		method_present  = FALSE;
 	}
 }
 if (!method_present && extends_cl != NULL)
 {
-	ufunc_T **ext_cl_fp = (ufunc_T **)(is_class_method
+	ufunc_T **ext_cl_fp = (ufunc_T **)(extends_cl->class_obj_methods);
-					? extends_cl->class_class_functions
+	int	ext_cl_count = extends_cl->class_obj_method_count;
-					: extends_cl->class_obj_methods);
+	return intf_method_present(if_ufunc, ext_cl_fp, ext_cl_count,
-	int	ext_cl_count = is_class_method
+						extends_cl->class_extends);
-				? extends_cl->class_class_function_count
-				: extends_cl->class_obj_method_count;
-	return intf_method_present(if_ufunc, is_class_method, ext_cl_fp,
-					ext_cl_count,
-					extends_cl->class_extends);
 }
 return method_present;
 }
 */
 static int
 validate_interface_methods(
 char_u	*intf_class_name,
 class_T	*ifcl,
-garray_T	*classfunctions_gap,
 garray_T	*objmethods_gap,
 class_T	*extends_cl)
 {
-for (int loop = 1; loop <= 2; ++loop)
+int if_count = ifcl->class_obj_method_count;
-{
+if (if_count == 0)
-	// loop == 1: check class methods
+	return TRUE;
-	// loop == 2: check object methods
-	int is_class_method = (loop == 1);
+ufunc_T **if_fp = ifcl->class_obj_methods;
-	int if_count = is_class_method ? ifcl->class_class_function_count
+ufunc_T **cl_fp = (ufunc_T **)(objmethods_gap->ga_data);
-					: ifcl->class_obj_method_count;
+int cl_count = objmethods_gap->ga_len;
-	if (if_count == 0)
+for (int if_i = 0; if_i < if_count; ++if_i)
-	    continue;
+{
-	ufunc_T **if_fp = is_class_method ? ifcl->class_class_functions
+	char_u	*if_name = if_fp[if_i]->uf_name;
-						: ifcl->class_obj_methods;
-	ufunc_T **cl_fp = (ufunc_T **)(is_class_method
+	if (!intf_method_present(if_fp[if_i], cl_fp, cl_count, extends_cl))
-						? classfunctions_gap->ga_data
+	{
-						: objmethods_gap->ga_data);
+	    semsg(_(e_method_str_of_interface_str_not_implemented),
-	int cl_count = is_class_method ? classfunctions_gap->ga_len
+		    if_name, intf_class_name);
-						: objmethods_gap->ga_len;
+	    return FALSE;
-	for (int if_i = 0; if_i < if_count; ++if_i)
-	{
-	    char_u	*if_name = if_fp[if_i]->uf_name;
-	    if (!intf_method_present(if_fp[if_i], is_class_method, cl_fp,
-							cl_count, extends_cl))
-	    {
-		semsg(_(e_method_str_of_interface_str_not_implemented),
-			if_name, intf_class_name);
-		return FALSE;
-	    }
 	}
 }
 return TRUE;
 }
 */
 static int
 validate_implements_classes(
 garray_T	*impl_gap,
 class_T	**intf_classes,
-garray_T	*classfunctions_gap,
-garray_T	*classmembers_gap,
 garray_T	*objmethods_gap,
 garray_T	*objmembers_gap,
 class_T	*extends_cl)
 {
 int		success = TRUE;
 	class_T *ifcl = tv.vval.v_class;
 	intf_classes[i] = ifcl;
 	++ifcl->class_refcount;
 	// check the variables of the interface match the members of the class
-	success = validate_interface_variables(impl, ifcl, classmembers_gap,
+	success = validate_interface_variables(impl, ifcl, objmembers_gap,
-						objmembers_gap, extends_cl);
+								extends_cl);
 	// check the functions/methods of the interface match the
 	// functions/methods of the class
 	if (success)
-	    success = validate_interface_methods(impl, ifcl,
+	    success = validate_interface_methods(impl, ifcl, objmethods_gap,
-					classfunctions_gap, objmethods_gap,
+								extends_cl);
-					extends_cl);
 	clear_tv(&tv);
 }
 return success;
 }
 if (success && ga_impl.ga_len > 0)
 {
 	intf_classes = ALLOC_CLEAR_MULT(class_T *, ga_impl.ga_len);
 	success = validate_implements_classes(&ga_impl, intf_classes,
-					&classfunctions, &classmembers,
+					&objmethods, &objmembers, extends_cl);
-					&objmethods, &objmembers,
-					extends_cl);
 }
 // Check no function argument name is used as a class member.
 if (success)
 	success = check_func_arg_names(&classfunctions, &objmethods,
 	emsg_var_cl_define(e_cannot_access_private_variable_str,
 							m->ocm_name, 0, cl);
 	return FAIL;
 }
-// The object only contains a pointer to the class, the member
-// values array follows right after that.
-object_T *obj = rettv->vval.v_object;
 if (is_object)
 {
+	// The object only contains a pointer to the class, the member values
+	// array follows right after that.
+	object_T *obj = rettv->vval.v_object;
 	typval_T *tv = (typval_T *)(obj + 1) + m_idx;
 	copy_tv(tv, rettv);
+	object_unref(obj);
 }
 else
+{
 	copy_tv(&cl->class_members_tv[m_idx], rettv);
+	class_unref(cl);
-object_unref(obj);
+}
+return OK;
+}
+/*
+* Call an object or class method "name" in class "cl".  The method return
+* value is returned in "rettv".
+*/
+static int
+call_oc_method(
+class_T	*cl,
+char_u	*name,
+size_t	len,
+char_u	*name_end,
+evalarg_T	*evalarg,
+char_u	**arg,
+typval_T	*rettv)
+{
+ufunc_T	*fp;
+typval_T	argvars[MAX_FUNC_ARGS + 1];
+int		argcount = 0;
+fp = method_lookup(cl, rettv->v_type, name, len, NULL);
+if (fp == NULL)
+{
+	method_not_found_msg(cl, rettv->v_type, name, len);
+	return FAIL;
+}
+if (*fp->uf_name == '_')
+{
+	// Cannot access a private method outside of a class
+	semsg(_(e_cannot_access_private_method_str), fp->uf_name);
+	return FAIL;
+}
+char_u *argp = name_end;
+int ret = get_func_arguments(&argp, evalarg, 0, argvars, &argcount);
+if (ret == FAIL)
+	return FAIL;
+funcexe_T funcexe;
+CLEAR_FIELD(funcexe);
+funcexe.fe_evaluate = TRUE;
+if (rettv->v_type == VAR_OBJECT)
+{
+	funcexe.fe_object = rettv->vval.v_object;
+	++funcexe.fe_object->obj_refcount;
+}
+// Clear the class or object after calling the function, in
+// case the refcount is one.
+typval_T tv_tofree = *rettv;
+rettv->v_type = VAR_UNKNOWN;
+// Call the user function.  Result goes into rettv;
+int error = call_user_func_check(fp, argcount, argvars, rettv, &funcexe,
+								NULL);
+// Clear the previous rettv and the arguments.
+clear_tv(&tv_tofree);
+for (int idx = 0; idx < argcount; ++idx)
+	clear_tv(&argvars[idx]);
+if (error != FCERR_NONE)
+{
+	user_func_error(error, printable_func_name(fp), funcexe.fe_found_var);
+	return FAIL;
+}
+*arg = argp;
 return OK;
 }
 /*
 	emsg(_(e_incomplete_type));
 	return FAIL;
 }
 if (*name_end == '(')
-{
+	// Invoke the class or object method
-	ufunc_T *fp;
+	return call_oc_method(cl, name, len, name_end, evalarg, arg, rettv);
-	fp = method_lookup(cl, rettv->v_type, name, len, NULL);
+else if (rettv->v_type == VAR_OBJECT || rettv->v_type == VAR_CLASS)
-	if (fp == NULL)
-	{
-	    method_not_found_msg(cl, rettv->v_type, name, len);
-	    return FAIL;
-	}
-	typval_T	argvars[MAX_FUNC_ARGS + 1];
-	int		argcount = 0;
-	if (*fp->uf_name == '_')
-	{
-	    // Cannot access a private method outside of a class
-	    semsg(_(e_cannot_access_private_method_str), name);
-	    return FAIL;
-	}
-	char_u *argp = name_end;
-	int ret = get_func_arguments(&argp, evalarg, 0,
-		argvars, &argcount);
-	if (ret == FAIL)
-	    return FAIL;
-	funcexe_T funcexe;
-	CLEAR_FIELD(funcexe);
-	funcexe.fe_evaluate = TRUE;
-	if (rettv->v_type == VAR_OBJECT)
-	{
-	    funcexe.fe_object = rettv->vval.v_object;
-	    ++funcexe.fe_object->obj_refcount;
-	}
-	// Clear the class or object after calling the function, in
-	// case the refcount is one.
-	typval_T tv_tofree = *rettv;
-	rettv->v_type = VAR_UNKNOWN;
-	// Call the user function.  Result goes into rettv;
-	int error = call_user_func_check(fp, argcount, argvars,
-		rettv, &funcexe, NULL);
-	// Clear the previous rettv and the arguments.
-	clear_tv(&tv_tofree);
-	for (int idx = 0; idx < argcount; ++idx)
-	    clear_tv(&argvars[idx]);
-	if (error != FCERR_NONE)
-	{
-	    user_func_error(error, printable_func_name(fp),
-		    funcexe.fe_found_var);
-	    return FAIL;
-	}
-	*arg = argp;
-	return OK;
-}
-else if (rettv->v_type == VAR_OBJECT)
 {
 	// Search in the object member variable table and the class member
 	// variable table.
-	if (get_member_tv(cl, TRUE, name, len, rettv) == OK)
+	int is_object = rettv->v_type == VAR_OBJECT;
+	if (get_member_tv(cl, is_object, name, len, rettv) == OK)
 	{
 	    *arg = name_end;
 	    return OK;
 	}
 	if (did_emsg == did_emsg_save)
-	    member_not_found_msg(cl, VAR_OBJECT, name, len);
+	    member_not_found_msg(cl, is_object, name, len);
-}
-else if (rettv->v_type == VAR_CLASS)
-{
-	int	    m_idx;
-	// class member
-	ocmember_T *m = class_member_lookup(cl, name, len, &m_idx);
-	if (m == NULL)
-	{
-	    member_not_found_msg(cl, VAR_CLASS, name, len);
-	    return FAIL;
-	}
-	if (*name == '_')
-	{
-	    emsg_var_cl_define(e_cannot_access_private_variable_str,
-							m->ocm_name, 0, cl);
-	    return FAIL;
-	}
-	typval_T *tv = &cl->class_members_tv[m_idx];
-	copy_tv(tv, rettv);
-	class_unref(cl);
-	*arg = name_end;
-	return OK;
 }
 return FAIL;
 }
 	*idx = ret_idx;
 return ret_m;
 }
 /*
+* Returns a pointer to the class method "name" in class "cl".
+* Returns NULL if the method is not found.
+* The method index is set in "idx".
+*/
+static ufunc_T *
+class_method_lookup(class_T *cl, char_u *name, size_t namelen, int *idx)
+{
+ufunc_T	*ret_fp = NULL;
+int		ret_idx = -1;
+for (int i = 0; i < cl->class_class_function_count; ++i)
+{
+	ufunc_T *fp = cl->class_class_functions[i];
+	char_u *ufname = (char_u *)fp->uf_name;
+	if (STRNCMP(name, ufname, namelen) == 0 && ufname[namelen] == NUL)
+	{
+	    ret_fp = fp;
+	    ret_idx = i;
+	    break;
+	}
+}
+if (idx != NULL)
+	*idx = ret_idx;
+return ret_fp;
+}
+/*
 * Returns the index of class method "name" in the class "cl".
 * Returns -1, if the method is not found.
 */
 int
 class_method_idx(class_T *cl, char_u *name, size_t namelen)
 class_method_lookup(cl, name, namelen, &idx);
 return idx;
 }
 /*
-* Returns a pointer to the class method "name" in class "cl".
-* Returns NULL if the method is not found.
-* The method index is set in "idx".
-*/
-ufunc_T *
-class_method_lookup(class_T *cl, char_u *name, size_t namelen, int *idx)
-{
-ufunc_T	*ret_fp = NULL;
-int		ret_idx = -1;
-for (int i = 0; i < cl->class_class_function_count; ++i)
-{
-	ufunc_T *fp = cl->class_class_functions[i];
-	char_u *ufname = (char_u *)fp->uf_name;
-	if (STRNCMP(name, ufname, namelen) == 0 && ufname[namelen] == NUL)
-	{
-	    ret_fp = fp;
-	    ret_idx = i;
-	    break;
-	}
-}
-if (idx != NULL)
-	*idx = ret_idx;
-return ret_fp;
-}
-/*
 * Returns the index of object member variable "name" in the class "cl".
 * Returns -1, if the variable is not found.
 * If "namelen" is zero, then it is assumed that "name" is NUL terminated.
 */
-int
+static int
 object_member_idx(class_T *cl, char_u *name, size_t namelen)
 {
 int idx;
 object_member_lookup(cl, name, namelen, &idx);
 return idx;
 	*idx = ret_idx;
 return ret_m;
 }
 /*
-* Returns the index of object method "name" in the class "cl".
-* Returns -1, if the method is not found.
-*/
-int
-object_method_idx(class_T *cl, char_u *name, size_t namelen)
-{
-int idx;
-object_method_lookup(cl, name, namelen, &idx);
-return idx;
-}
-/*
 * Returns a pointer to the object method "name" in class "cl".
 * Returns NULL if the method is not found.
 * The object method index is set in "idx".
 */
-ufunc_T *
+static ufunc_T *
 object_method_lookup(class_T *cl, char_u *name, size_t namelen, int *idx)
 {
 ufunc_T	*ret_fp = NULL;
 int		ret_idx = -1;
 for (int i = 0; i < cl->class_obj_method_count; ++i)
 	}
 }
 if (idx != NULL)
 	*idx = ret_idx;
 return ret_fp;
+}
+/*
+* Returns the index of object method "name" in the class "cl".
+* Returns -1, if the method is not found.
+*/
+int
+object_method_idx(class_T *cl, char_u *name, size_t namelen)
+{
+int idx;
+object_method_lookup(cl, name, namelen, &idx);
+return idx;
 }
 /*
 * Lookup a class or object member variable by name.  If v_type is VAR_CLASS,
 * then lookup a class member variable and if it is VAR_OBJECT, then lookup a
 	++to->vval.v_object->obj_refcount;
 }
 }
 /*
-* Free an object.
-*/
-static void
-object_clear(object_T *obj)
-{
-// Avoid a recursive call, it can happen if "obj" has a circular reference.
-obj->obj_refcount = INT_MAX;
-class_T *cl = obj->obj_class;
-if (!cl)
-	return;
-// the member values are just after the object structure
-typval_T *tv = (typval_T *)(obj + 1);
-for (int i = 0; i < cl->class_obj_member_count; ++i)
-	clear_tv(tv + i);
-// Remove from the list headed by "first_object".
-object_cleared(obj);
-vim_free(obj);
-class_unref(cl);
-}
-/*
-* Unreference an object.
-*/
-void
-object_unref(object_T *obj)
-{
-if (obj != NULL && --obj->obj_refcount <= 0)
-	object_clear(obj);
-}
-/*
 * Make a copy of a class.
 */
 void
 copy_class(typval_T *from, typval_T *to)
 {
 /*
 * Call this function when an object has been cleared and is about to be freed.
 * It is removed from the list headed by "first_object".
 */
-void
+static void
 object_cleared(object_T *obj)
 {
 if (obj->obj_next_used != NULL)
 	obj->obj_next_used->obj_prev_used = obj->obj_prev_used;
 if (obj->obj_prev_used != NULL)
 if (obj == next_nonref_obj)
 	next_nonref_obj = obj->obj_next_used;
 }
 /*
+* Free an object.
+*/
+static void
+object_clear(object_T *obj)
+{
+// Avoid a recursive call, it can happen if "obj" has a circular reference.
+obj->obj_refcount = INT_MAX;
+class_T *cl = obj->obj_class;
+if (!cl)
+	return;
+// the member values are just after the object structure
+typval_T *tv = (typval_T *)(obj + 1);
+for (int i = 0; i < cl->class_obj_member_count; ++i)
+	clear_tv(tv + i);
+// Remove from the list headed by "first_object".
+object_cleared(obj);
+vim_free(obj);
+class_unref(cl);
+}
+/*
+* Unreference an object.
+*/
+void
+object_unref(object_T *obj)
+{
+if (obj != NULL && --obj->obj_refcount <= 0)
+	object_clear(obj);
+}
+/*
 * Go through the list of all objects and free items without "copyID".
 */
 int
 object_free_nonref(int copyID)
 {

Mercurial > vim

comparison src/vim9class.c @ 33506:f61713271934 v9.0.2002