NOISSUE change uvim folder name to mnv

Signed-off-by: Mehmet Samet Duman <yongdohyun@projecttick.org>

1 files changed, 4424 insertions, 0 deletions

diff --git a/mnv/src/mnv9class.c b/mnv/src/mnv9class.c
new file mode 100644
index 0000000000..ba636c101c
--- /dev/null
+++ b/mnv/src/mnv9class.c
@@ -0,0 +1,4424 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * MNV - MNV is not Vim	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in MNV to read copying and usage conditions.
+ * Do ":help credits" in MNV to see a list of people who contributed.
+ * See README.txt for an overview of the MNV source code.
+ */
+
+/*
+ * mnv9class.c: MNV9 script class support
+ */
+
+#define USING_FLOAT_STUFF
+#include "mnv.h"
+
+#if defined(FEAT_EVAL)
+
+static class_T *first_class = NULL;
+static class_T *next_nonref_class = NULL;
+
+/*
+ * Call this function when a class has been created.  It will be added to the
+ * list headed by "first_class".
+ */
+    static void
+class_created(class_T *cl)
+{
+    if (first_class != NULL)
+    {
+	cl->class_next_used = first_class;
+	first_class->class_prev_used = cl;
+    }
+    first_class = cl;
+}
+
+/*
+ * Call this function when a class has been cleared and is about to be freed.
+ * It is removed from the list headed by "first_class".
+ */
+    static void
+class_cleared(class_T *cl)
+{
+    if (cl->class_next_used != NULL)
+	cl->class_next_used->class_prev_used = cl->class_prev_used;
+    if (cl->class_prev_used != NULL)
+	cl->class_prev_used->class_next_used = cl->class_next_used;
+    else if (first_class == cl)
+	first_class = cl->class_next_used;
+
+    // update the next class to check if needed
+    if (cl == next_nonref_class)
+	next_nonref_class = cl->class_next_used;
+}
+
+/*
+ * Parse a member declaration, both object and class member.
+ * Returns OK or FAIL.  When OK then "varname_end" is set to just after the
+ * variable name and "type_ret" is set to the declared or detected type.
+ * "init_expr" is set to the initialisation expression (allocated), if there is
+ * one.  For an interface "init_expr" is NULL.
+ */
+    static int
+parse_member(
+    exarg_T	*eap,
+    char_u	*line,
+    char_u	*varname,
+    int		has_public,	    // TRUE if "public" seen before "varname"
+    char_u	**varname_end,
+    int		*has_type,
+    garray_T	*type_list,
+    type_T	**type_ret,
+    char_u	**init_expr)
+{
+    *varname_end = to_name_end(varname, FALSE);
+    if (*varname == '_' && has_public)
+    {
+	semsg(_(e_public_variable_name_cannot_start_with_underscore_str), line);
+	return FAIL;
+    }
+
+    char_u *colon = skipwhite(*varname_end);
+    char_u *type_arg = colon;
+    type_T *type = NULL;
+    *has_type = FALSE;
+    if (*colon == ':')
+    {
+	if (MNV_ISWHITE(**varname_end))
+	{
+	    semsg(_(e_no_white_space_allowed_before_colon_str), varname);
+	    return FAIL;
+	}
+	if (!MNV_ISWHITE(colon[1]))
+	{
+	    semsg(_(e_white_space_required_after_str_str), ":", varname);
+	    return FAIL;
+	}
+	type_arg = skipwhite(colon + 1);
+	type = parse_type(&type_arg, type_list, NULL, NULL, TRUE);
+	if (type == NULL || !valid_declaration_type(type))
+	    return FAIL;
+	*has_type = TRUE;
+    }
+
+    char_u *init_arg = skipwhite(type_arg);
+    if (type == NULL && *init_arg != '=')
+    {
+	emsg(_(e_type_or_initialization_required));
+	return FAIL;
+    }
+
+    if (init_expr == NULL && *init_arg == '=')
+    {
+	emsg(_(e_cannot_initialize_variable_in_interface));
+	return FAIL;
+    }
+
+    if (*init_arg == '=')
+    {
+	evalarg_T evalarg;
+	char_u *expr_start, *expr_end;
+
+	if (!MNV_ISWHITE(init_arg[-1]) || !MNV_ISWHITE(init_arg[1]))
+	{
+	    semsg(_(e_white_space_required_before_and_after_str_at_str),
+							"=", type_arg);
+	    return FAIL;
+	}
+	init_arg = skipwhite(init_arg + 1);
+
+	fill_evalarg_from_eap(&evalarg, eap, FALSE);
+	(void)skip_expr_concatenate(&init_arg, &expr_start, &expr_end, &evalarg);
+
+	init_arg = skipwhite(init_arg);
+	if (*init_arg != NUL && !mnv9_comment_start(init_arg))
+	{
+	    semsg(_(e_trailing_characters_str), init_arg);
+	    clear_evalarg(&evalarg, NULL);
+	    return FAIL;
+	}
+
+	// No type specified for the member.  Set it to "any" and the correct
+	// type will be set when the object is instantiated.
+	if (type == NULL)
+	    type = &t_any;
+
+	*init_expr = mnv_strnsave(expr_start, expr_end - expr_start);
+	// Free the memory pointed by expr_start.
+	clear_evalarg(&evalarg, NULL);
+    }
+    else if (!valid_declaration_type(type))
+	return FAIL;
+
+    *type_ret = type;
+    return OK;
+}
+
+/*
+ * Add a member to an object or a class.
+ * Returns OK when successful, "init_expr" will be consumed then.
+ * Returns OK on success and FAIL on memory allocation failure (caller might
+ * need to free "init_expr").
+ */
+    static int
+add_member(
+    garray_T	*gap,
+    char_u	*varname,
+    char_u	*varname_end,
+    int		has_public,
+    int		has_final,
+    int		has_const,
+    int		has_type,
+    type_T	*type,
+    char_u	*init_expr)
+{
+    if (ga_grow(gap, 1) == FAIL)
+	return FAIL;
+    ocmember_T *m = ((ocmember_T *)gap->ga_data) + gap->ga_len;
+    m->ocm_name.length = (size_t)(varname_end - varname);
+    m->ocm_name.string = mnv_strnsave(varname, m->ocm_name.length);
+    if (m->ocm_name.string == NULL)
+    {
+	m->ocm_name.length = 0;
+	return FAIL;
+    }
+    m->ocm_access = has_public ? MNV_ACCESS_ALL
+		      : *varname == '_' ? MNV_ACCESS_PRIVATE : MNV_ACCESS_READ;
+    if (has_final)
+	m->ocm_flags |= OCMFLAG_FINAL;
+    if (has_const)
+	m->ocm_flags |= OCMFLAG_CONST;
+    if (has_type)
+	m->ocm_flags |= OCMFLAG_HAS_TYPE;
+    m->ocm_type = type;
+    if (init_expr != NULL)
+    {
+	m->ocm_init = init_expr;
+	// Save the script context, we need it when evaluating or compiling the
+	// initializer expression.
+	m->ocm_init_sctx = current_sctx;
+	m->ocm_init_sctx.sc_lnum += SOURCING_LNUM;
+    }
+    ++gap->ga_len;
+    return OK;
+}
+
+/*
+ * Move the class or object members found while parsing a class into the class.
+ * "gap" contains the found members.
+ * "parent_members" points to the members in the parent class (if any)
+ * "parent_count" is the number of members in the parent class
+ * "members" will be set to the newly allocated array of members and
+ * "member_count" set to the number of members.
+ * Returns OK on success and FAIL on memory allocation failure.
+ */
+    static int
+add_members_to_class(
+    garray_T	*gap,
+    ocmember_T	*parent_members,
+    int		parent_count,
+    ocmember_T	**members,
+    int		*member_count)
+{
+    *member_count = parent_count + gap->ga_len;
+    *members = *member_count == 0 ? NULL
+				       : ALLOC_MULT(ocmember_T, *member_count);
+    if (*member_count > 0 && *members == NULL)
+	return FAIL;
+    for (int i = 0; i < parent_count; ++i)
+    {
+	// parent members need to be copied
+	ocmember_T	*m = *members + i;
+	*m = parent_members[i];
+	m->ocm_name.string = mnv_strnsave(m->ocm_name.string, m->ocm_name.length);
+	if (m->ocm_name.string == NULL)
+	{
+	    m->ocm_name.length = 0;
+	    return FAIL;
+	}
+	if (m->ocm_init != NULL)
+	    m->ocm_init = mnv_strsave(m->ocm_init);
+    }
+    if (gap->ga_len > 0)
+	// new members are moved
+	mch_memmove(*members + parent_count,
+			       gap->ga_data, sizeof(ocmember_T) * gap->ga_len);
+    MNV_CLEAR(gap->ga_data);
+    return OK;
+}
+
+/*
+ * Convert a member index "idx" of interface "itf" to the member index of class
+ * "cl" implementing that interface.
+ */
+    int
+object_index_from_itf_index(class_T *itf, int is_method, int idx, class_T *cl)
+{
+    if (idx >= (is_method ? itf->class_obj_method_count
+				   : itf->class_obj_member_count))
+    {
+	siemsg("index %d out of range for interface %s", idx, itf->class_name.string);
+	return 0;
+    }
+
+    // If "cl" is the interface or the class that is extended, then the method
+    // index can be used directly and there is no need to search for the method
+    // index in one of the child classes.
+    if (cl == itf)
+	return idx;
+
+    itf2class_T		*i2c = NULL;
+    int			searching = TRUE;
+    int			method_offset = 0;
+
+    for (class_T *super = cl; super != NULL && searching;
+						super = super->class_extends)
+    {
+	for (i2c = itf->class_itf2class; i2c != NULL; i2c = i2c->i2c_next)
+	{
+	    if (i2c->i2c_class == super && i2c->i2c_is_method == is_method)
+	    {
+		searching = FALSE;
+		break;
+	    }
+	}
+	if (searching && is_method)
+	    // The parent class methods are stored after the current class
+	    // methods.
+	    method_offset += super->class_obj_method_count_child;
+    }
+    if (i2c == NULL)
+    {
+	siemsg("class %s not found on interface %s",
+					      cl->class_name.string, itf->class_name.string);
+	return 0;
+    }
+
+    // A table follows the i2c for the class
+    int *table = (int *)(i2c + 1);
+    // "method_offset" is 0, if method is in the current class.  If method
+    // is in a parent class, then it is non-zero.
+    return table[idx] + method_offset;
+}
+
+/*
+ * Check whether a class named "extends_name" is present.  If the class is
+ * valid, then "extends_clp" is set with the class pointer.
+ * Returns TRUE if the class name "extends_names" is a valid class.
+ */
+    static int
+validate_extends_class(
+    class_T *cl,
+    char_u  *extends_name,
+    class_T **extends_clp,
+    int	    is_class)
+{
+    typval_T	tv;
+    int		success = FALSE;
+
+    if (STRCMP(cl->class_name.string, extends_name) == 0)
+    {
+	semsg(_(e_cannot_extend_str), extends_name);
+	return success;
+    }
+
+    tv.v_type = VAR_UNKNOWN;
+    if (eval_variable_import(extends_name, &tv) == FAIL)
+    {
+	semsg(_(e_class_name_not_found_str), extends_name);
+	return success;
+    }
+
+    if (tv.v_type != VAR_CLASS || tv.vval.v_class == NULL
+	    || (is_class && IS_INTERFACE(tv.vval.v_class))
+	    || (!is_class && !IS_INTERFACE(tv.vval.v_class))
+	    || (is_class && IS_ENUM(tv.vval.v_class)))
+    {
+	// a class cannot extend an interface
+	// an interface cannot extend a class
+	// a class cannot extend an enum.
+	semsg(_(e_cannot_extend_str), extends_name);
+    }
+    else
+    {
+	class_T *extends_cl = tv.vval.v_class;
+	++extends_cl->class_refcount;
+	*extends_clp = extends_cl;
+	success = TRUE;
+    }
+    clear_tv(&tv);
+
+    return success;
+}
+
+/*
+ * Check a generic method is extended by a generic method and the number of
+ * type variables match.
+ */
+    static int
+validate_extends_generic_method(
+    class_T *super_cl,
+    ufunc_T *super_fp,
+    ufunc_T *cl_fp)
+{
+    char	*msg = NULL;
+
+    if (cl_fp->uf_generic_argcount == super_fp->uf_generic_argcount)
+	return TRUE;
+
+    if (super_fp->uf_generic_argcount == 0)
+	msg = e_concrete_method_str_override_with_generic_method_in_class_str;
+    else if (cl_fp->uf_generic_argcount == 0)
+	msg = e_generic_method_str_override_with_concrete_method_in_class_str;
+    else
+	msg = e_generic_method_str_type_arguments_mismatch_in_class_str;
+
+    semsg(_(msg), cl_fp->uf_name, super_cl->class_name.string);
+    return FALSE;
+}
+
+/*
+ * Check method names in the parent class lineage to make sure the access is
+ * the same for overridden methods.
+ */
+    static int
+validate_extends_methods(
+    garray_T	*objmethods_gap,
+    class_T	*extends_cl)
+{
+    class_T	*super = extends_cl;
+    int		method_count = objmethods_gap->ga_len;
+    ufunc_T	**cl_fp = (ufunc_T **)(objmethods_gap->ga_data);
+
+    while (super != NULL)
+    {
+	int extends_method_count = super->class_obj_method_count_child;
+	if (extends_method_count == 0)
+	{
+	    super = super->class_extends;
+	    continue;
+	}
+
+	ufunc_T **extends_methods = super->class_obj_methods;
+
+	for (int i = 0; i < extends_method_count; i++)
+	{
+	    char_u  *pstr = extends_methods[i]->uf_name;
+	    int	    extends_private = (*pstr == '_');
+	    if (extends_private)
+		pstr++;
+
+	    // When comparing the method names, ignore the access type (public
+	    // and private methods are considered the same).
+	    for (int j = 0; j < method_count; j++)
+	    {
+		char_u  *qstr = cl_fp[j]->uf_name;
+		int	priv_method = (*qstr == '_');
+		if (priv_method)
+		    qstr++;
+		if (STRCMP(pstr, qstr) == 0)
+		{
+		    if (priv_method != extends_private)
+		    {
+			// Method access is different between the super class
+			// and the subclass
+			semsg(_(e_method_str_of_class_str_has_different_access),
+				cl_fp[j]->uf_name, super->class_name.string);
+			return FALSE;
+		    }
+
+		    if (!validate_extends_generic_method(super,
+						extends_methods[i], cl_fp[j]))
+			    return FALSE;
+		}
+	    }
+	}
+	super = super->class_extends;
+    }
+
+    return TRUE;
+}
+
+/*
+ * Check whether a object member variable in "objmembers_gap" is a duplicate of
+ * a member in any of the extended parent class lineage.  Returns TRUE if there
+ * are no duplicates.
+ */
+    static int
+extends_check_dup_members(
+    garray_T	*objmembers_gap,
+    class_T	*extends_cl)
+{
+    int member_count = objmembers_gap->ga_len;
+    if (member_count == 0)
+	return TRUE;
+
+    ocmember_T *members = (ocmember_T *)(objmembers_gap->ga_data);
+
+    // Validate each member variable
+    for (int c_i = 0; c_i < member_count; c_i++)
+    {
+	class_T	    *p_cl = extends_cl;
+	ocmember_T  *c_m = members + c_i;
+	char_u	    *pstr = (*c_m->ocm_name.string == '_')
+				    ? c_m->ocm_name.string + 1 : c_m->ocm_name.string;
+
+	// Check in all the parent classes in the lineage
+	while (p_cl != NULL)
+	{
+	    int p_member_count = p_cl->class_obj_member_count;
+	    if (p_member_count == 0)
+	    {
+		p_cl = p_cl->class_extends;
+		continue;
+	    }
+	    ocmember_T *p_members = p_cl->class_obj_members;
+
+	    // Compare against all the members in the parent class
+	    for (int p_i = 0; p_i < p_member_count; p_i++)
+	    {
+		ocmember_T	*p_m = p_members + p_i;
+		char_u	*qstr = (*p_m->ocm_name.string == '_')
+		    ? p_m->ocm_name.string + 1 : p_m->ocm_name.string;
+		if (STRCMP(pstr, qstr) == 0)
+		{
+		    semsg(_(e_duplicate_variable_str), c_m->ocm_name.string);
+		    return FALSE;
+		}
+	    }
+
+	    p_cl = p_cl->class_extends;
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * Compare the variable type of interface variables in "objmembers_gap" against
+ * the variable in any of the extended super interface lineage.  Used to
+ * compare the variable types when extending interfaces.  Returns TRUE if the
+ * variable types are the same.
+ */
+    static int
+extends_check_intf_var_type(
+    garray_T	*objmembers_gap,
+    class_T	*extends_cl)
+{
+    int member_count = objmembers_gap->ga_len;
+    if (member_count == 0)
+	return TRUE;
+
+    ocmember_T *members = (ocmember_T *)(objmembers_gap->ga_data);
+
+    // Validate each member variable
+    for (int c_i = 0; c_i < member_count; c_i++)
+    {
+	class_T	    *p_cl = extends_cl;
+	ocmember_T  *c_m = members + c_i;
+	int	    var_found = FALSE;
+
+	// Check in all the parent classes in the lineage
+	while (p_cl != NULL && !var_found)
+	{
+	    int p_member_count = p_cl->class_obj_member_count;
+	    if (p_member_count == 0)
+	    {
+		p_cl = p_cl->class_extends;
+		continue;
+	    }
+	    ocmember_T *p_members = p_cl->class_obj_members;
+
+	    // Compare against all the members in the parent class
+	    for (int p_i = 0; p_i < p_member_count; p_i++)
+	    {
+		where_T		where = WHERE_INIT;
+		ocmember_T	*p_m = p_members + p_i;
+
+		if (STRCMP(p_m->ocm_name.string, c_m->ocm_name.string) != 0)
+		    continue;
+
+		// Ensure the type is matching.
+		where.wt_func_name = (char *)c_m->ocm_name.string;
+		where.wt_kind = WT_MEMBER;
+
+		if (check_type(p_m->ocm_type, c_m->ocm_type, TRUE,
+								where) == FAIL)
+		    return FALSE;
+
+		var_found = TRUE;
+	    }
+
+	    p_cl = p_cl->class_extends;
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * When extending an abstract class, check whether all the abstract methods in
+ * the parent class are implemented.  Returns TRUE if all the methods are
+ * implemented.
+ */
+    static int
+validate_abstract_class_methods(
+    garray_T	*classmethods_gap,
+    garray_T	*objmethods_gap,
+    class_T	*extends_cl)
+{
+    for (int loop = 1; loop <= 2; ++loop)
+    {
+	// loop == 1: check class methods
+	// loop == 2: check object methods
+	int extends_method_count = loop == 1
+				? extends_cl->class_class_function_count
+				: extends_cl->class_obj_method_count;
+	if (extends_method_count == 0)
+	    continue;
+
+	ufunc_T **extends_methods = loop == 1
+				? extends_cl->class_class_functions
+				: extends_cl->class_obj_methods;
+
+	int method_count = loop == 1 ? classmethods_gap->ga_len
+						: objmethods_gap->ga_len;
+	ufunc_T **cl_fp = (ufunc_T **)(loop == 1
+						? classmethods_gap->ga_data
+						: objmethods_gap->ga_data);
+
+	for (int i = 0; i < extends_method_count; i++)
+	{
+	    ufunc_T *uf = extends_methods[i];
+	    if (!IS_ABSTRACT_METHOD(uf))
+		continue;
+
+	    int	concrete_method_found = FALSE;
+	    int	j = 0;
+
+	    // Check if the abstract method is already implemented in one of
+	    // the parent classes.
+	    for (j = 0; !concrete_method_found && j < i; j++)
+	    {
+		ufunc_T *uf2 = extends_methods[j];
+		if (!IS_ABSTRACT_METHOD(uf2) &&
+			STRCMP(uf->uf_name, uf2->uf_name) == 0)
+		    concrete_method_found = TRUE;
+	    }
+
+	    if (concrete_method_found)
+		continue;
+
+	    for (j = 0; j < method_count; j++)
+	    {
+		if (STRCMP(uf->uf_name, cl_fp[j]->uf_name) == 0)
+		{
+		    concrete_method_found = TRUE;
+		    break;
+		}
+	    }
+
+	    if (!concrete_method_found)
+	    {
+		semsg(_(e_abstract_method_str_not_implemented), uf->uf_name);
+		return FALSE;
+	    }
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if the interface variable "if_var" is present in the list of
+ * variables in "cl_mt" or in the parent lineage of one of the extended classes
+ * in "extends_cl".  For a class variable, 'is_class_var' is TRUE.
+ */
+    static int
+intf_variable_present(
+    char_u	*intf_class_name,
+    ocmember_T *if_var,
+    ocmember_T *cl_mt,
+    int		cl_member_count,
+    class_T	*extends_cl)
+{
+    int		variable_present  = FALSE;
+
+    for (int cl_i = 0; cl_i < cl_member_count; ++cl_i)
+    {
+	ocmember_T	*m = &cl_mt[cl_i];
+	where_T		where = WHERE_INIT;
+
+	if (STRCMP(if_var->ocm_name.string, m->ocm_name.string) != 0)
+	    continue;
+
+	// Ensure the access type is same
+	if (if_var->ocm_access != m->ocm_access)
+	{
+	    semsg(_(e_variable_str_of_interface_str_has_different_access),
+		    if_var->ocm_name.string, intf_class_name);
+	    return FALSE;
+	}
+
+	// Ensure the type is matching.
+	if (m->ocm_type == &t_any)
+	{
+	    // variable type is not specified.  Use the variable type in the
+	    // interface.
+	    m->ocm_type = if_var->ocm_type;
+	}
+	else
+	{
+	    where.wt_func_name = (char *)m->ocm_name.string;
+	    where.wt_kind = WT_MEMBER;
+	    if (check_type(if_var->ocm_type, m->ocm_type, TRUE,
+							    where) == FAIL)
+		return FALSE;
+	}
+
+	variable_present = TRUE;
+	break;
+    }
+
+    if (!variable_present && extends_cl != NULL)
+    {
+	int ext_cl_count = extends_cl->class_obj_member_count;
+	ocmember_T *ext_cl_mt = extends_cl->class_obj_members;
+	return intf_variable_present(intf_class_name, if_var,
+					ext_cl_mt, ext_cl_count,
+					extends_cl->class_extends);
+    }
+
+    return variable_present;
+}
+
+/*
+ * Check the variables of the interface class "ifcl" match object variables
+ * ("objmembers_gap") of a class.
+ * Returns TRUE if the object variables names are valid.
+ */
+    static int
+validate_interface_variables(
+    char_u	*intf_class_name,
+    class_T	*ifcl,
+    garray_T	*objmembers_gap,
+    class_T	*extends_cl)
+{
+    int if_count = ifcl->class_obj_member_count;
+    if (if_count == 0)
+	return TRUE;
+
+    ocmember_T *if_ms = ifcl->class_obj_members;
+    ocmember_T *cl_ms = (ocmember_T *)(objmembers_gap->ga_data);
+    int cl_count = 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], cl_ms,
+							cl_count, extends_cl))
+	{
+	    semsg(_(e_variable_str_of_interface_str_not_implemented),
+		    if_ms[if_i].ocm_name.string, intf_class_name);
+	    return FALSE;
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if the method signature of "if_method" and "cl_method" matches.
+ */
+    static int
+intf_method_type_matches(ufunc_T *if_method, ufunc_T *cl_method)
+{
+    where_T where = WHERE_INIT;
+
+    // Ensure the type is matching.
+    where.wt_func_name = (char *)if_method->uf_name;
+    where.wt_kind = WT_METHOD;
+    if (check_type(if_method->uf_func_type, cl_method->uf_func_type, TRUE,
+								where) == FAIL)
+	return FALSE;
+
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if the interface method "if_ufunc" is present in the list of
+ * methods in "cl_fp" or in the parent lineage of one of the extended classes
+ * in "extends_cl".  For a class method, 'is_class_method' is TRUE.
+ */
+    static int
+intf_method_present(
+    ufunc_T *if_ufunc,
+    ufunc_T **cl_fp,
+    int	    cl_count,
+    class_T *extends_cl)
+{
+    int		method_present  = FALSE;
+
+    for (int cl_i = 0; cl_i < cl_count; ++cl_i)
+    {
+	if (STRCMP(if_ufunc->uf_name, cl_fp[cl_i]->uf_name) == 0)
+	{
+	    // Ensure the type is matching.
+	    if (!intf_method_type_matches(if_ufunc, cl_fp[cl_i]))
+		return FALSE;
+	    method_present = TRUE;
+	    break;
+	}
+    }
+
+    if (!method_present && extends_cl != NULL)
+    {
+	ufunc_T **ext_cl_fp = (ufunc_T **)(extends_cl->class_obj_methods);
+	int	ext_cl_count = extends_cl->class_obj_method_count;
+	return intf_method_present(if_ufunc, ext_cl_fp, ext_cl_count,
+						extends_cl->class_extends);
+    }
+
+    return method_present;
+}
+
+/*
+ * Validate that a new class implements all the class/instance methods in the
+ * interface "ifcl".  The new class methods are in "classfunctions_gap" and the
+ * new object methods are in "objmemthods_gap".  Also validates the method
+ * types.
+ * Returns TRUE if all the interface class/object methods are implemented in
+ * the new class.
+ */
+    static int
+validate_interface_methods(
+    char_u	*intf_class_name,
+    class_T	*ifcl,
+    garray_T	*objmethods_gap,
+    class_T	*extends_cl)
+{
+    int if_count = ifcl->class_obj_method_count;
+    if (if_count == 0)
+	return TRUE;
+
+    ufunc_T **if_fp = ifcl->class_obj_methods;
+    ufunc_T **cl_fp = (ufunc_T **)(objmethods_gap->ga_data);
+    int cl_count = objmethods_gap->ga_len;
+    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], cl_fp, cl_count, extends_cl))
+	{
+	    semsg(_(e_method_str_of_interface_str_not_implemented),
+		    if_name, intf_class_name);
+	    return FALSE;
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * Validate all the "implements" classes when creating a new class.  The
+ * classes are returned in "intf_classes".  The class functions, class members,
+ * object methods and object members in the new class are in
+ * "classfunctions_gap", "classmembers_gap", "objmethods_gap", and
+ * "objmembers_gap" respectively.
+ */
+    static int
+validate_implements_classes(
+    garray_T	*impl_gap,
+    garray_T	*intf_classes_gap,
+    garray_T	*objmethods_gap,
+    garray_T	*objmembers_gap,
+    class_T	*extends_cl)
+{
+    int		success = TRUE;
+
+    for (int i = 0; i < impl_gap->ga_len && success; ++i)
+    {
+	char_u *impl = ((char_u **)impl_gap->ga_data)[i];
+	typval_T tv;
+	tv.v_type = VAR_UNKNOWN;
+	if (eval_variable_import(impl, &tv) == FAIL)
+	{
+	    semsg(_(e_interface_name_not_found_str), impl);
+	    success = FALSE;
+	    break;
+	}
+
+	if (tv.v_type != VAR_CLASS
+		|| tv.vval.v_class == NULL
+		|| !IS_INTERFACE(tv.vval.v_class))
+	{
+	    semsg(_(e_not_valid_interface_str), impl);
+	    success = FALSE;
+	    clear_tv(&tv);
+	    break;
+	}
+
+	class_T *ifcl = tv.vval.v_class;
+	if (ga_grow(intf_classes_gap, 1) == FAIL)
+	{
+	    success = FALSE;
+	    clear_tv(&tv);
+	    break;
+	}
+	((class_T **)intf_classes_gap->ga_data)[intf_classes_gap->ga_len]
+								= ifcl;
+	intf_classes_gap->ga_len++;
+	++ifcl->class_refcount;
+
+	// check the variables of the interface match the members of the class
+	success = validate_interface_variables(impl, ifcl, objmembers_gap,
+								extends_cl);
+
+	// check the functions/methods of the interface match the
+	// functions/methods of the class
+	if (success)
+	    success = validate_interface_methods(impl, ifcl, objmethods_gap,
+								extends_cl);
+	clear_tv(&tv);
+    }
+
+    return success;
+}
+
+/*
+ * Returns TRUE if the interface class "ifcl" is already present in the
+ * "intf_classes_gap" grow array.
+ */
+    static int
+is_interface_class_present(garray_T *intf_classes_gap, class_T *ifcl)
+{
+    for (int j = 0; j < intf_classes_gap->ga_len; j++)
+    {
+	if (((class_T **)intf_classes_gap)[j] == ifcl)
+	    return TRUE;
+    }
+
+    return FALSE;
+}
+
+/*
+ * Add interface "ifcl" from a super class to "intf_classes_gap" and the class
+ * name to "impl_gap".
+ */
+    static int
+add_interface_from_super_class(
+    class_T	*ifcl,
+    garray_T	*impl_gap,
+    garray_T	*intf_classes_gap)
+{
+    char_u	*intf_name;
+
+    // Add the interface name to "impl_gap"
+    intf_name = mnv_strnsave(ifcl->class_name.string, ifcl->class_name.length);
+    if (intf_name == NULL)
+	return FALSE;
+
+    if (ga_grow(impl_gap, 1) == FAIL)
+	goto fail;
+
+    char_u **intf_names = (char_u **)impl_gap->ga_data;
+    intf_names[impl_gap->ga_len] = intf_name;
+    impl_gap->ga_len++;
+
+    // Add the interface class to "intf_classes_gap"
+    if (ga_grow(intf_classes_gap, 1) == FAIL)
+    {
+	--impl_gap->ga_len;
+	goto fail;
+    }
+
+    class_T **intf_classes = (class_T **)intf_classes_gap->ga_data;
+    intf_classes[intf_classes_gap->ga_len] = ifcl;
+    intf_classes_gap->ga_len++;
+    ++ifcl->class_refcount;
+
+    return TRUE;
+fail:
+    mnv_free(intf_name);
+    return FALSE;
+}
+
+/*
+ * Add "super" class interfaces to "intf_classes_gap" (if not present already)
+ * Add the interface class names to "impl_gap".
+ */
+    static int
+add_super_class_interfaces(
+    class_T	*super,
+    garray_T	*impl_gap,
+    garray_T	*intf_classes_gap)
+{
+    // Iterate through all the interfaces implemented by "super"
+    for (int i = 0; i < super->class_interface_count; i++)
+    {
+	class_T	*ifcl = super->class_interfaces_cl[i];
+
+	if (!is_interface_class_present(intf_classes_gap, ifcl))
+	    add_interface_from_super_class(ifcl, impl_gap, intf_classes_gap);
+    }
+
+    return TRUE;
+}
+
+/*
+ * Check no function argument name is used as a class member.
+ * (Object members are always accessed with "this." prefix, so no need
+ * to check them.)
+ */
+    static int
+check_func_arg_names(
+    garray_T	*classfunctions_gap,
+    garray_T	*objmethods_gap,
+    garray_T	*classmembers_gap)
+{
+    // loop 1: class functions, loop 2: object methods
+    for (int loop = 1; loop <= 2; ++loop)
+    {
+	garray_T *gap = loop == 1 ? classfunctions_gap : objmethods_gap;
+
+	for (int fi = 0; fi < gap->ga_len; ++fi)
+	{
+	    ufunc_T *uf = ((ufunc_T **)gap->ga_data)[fi];
+
+	    for (int i = 0; i < uf->uf_args.ga_len; ++i)
+	    {
+		char_u *aname = ((char_u **)uf->uf_args.ga_data)[i];
+		garray_T *mgap = classmembers_gap;
+
+		// Check all the class member names
+		for (int mi = 0; mi < mgap->ga_len; ++mi)
+		{
+		    char_u *mname =
+				((ocmember_T *)mgap->ga_data + mi)->ocm_name.string;
+		    if (STRCMP(aname, mname) == 0)
+		    {
+			if (uf->uf_script_ctx.sc_sid > 0)
+			    SOURCING_LNUM = uf->uf_script_ctx.sc_lnum;
+
+			semsg(_(e_argument_already_declared_in_class_str),
+				aname);
+
+			return FALSE;
+		    }
+		}
+	    }
+	}
+    }
+
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if 'varname' is a reserved keyword name
+ */
+    static int
+is_reserved_varname(char_u *varname, char_u *varname_end)
+{
+    int reserved = FALSE;
+    char_u save_varname_end = *varname_end;
+    *varname_end = NUL;
+
+    reserved = check_reserved_name(varname, FALSE) == FAIL;
+
+    *varname_end = save_varname_end;
+
+    return reserved;
+}
+
+/*
+ * Returns TRUE if the variable "varname" is already defined either as a class
+ * variable or as an object variable.
+ */
+    static int
+is_duplicate_variable(
+    garray_T	*class_members,
+    garray_T	*obj_members,
+    char_u	*varname,
+    char_u	*varname_end)
+{
+    string_T	pstr = {varname, (size_t)(varname_end - varname)};  // Note: the .string field may
+								    // point to a string longer
+								    // than the .length field.
+								    // So we need to use STRNCMP()
+								    // to compare it.
+    int		dup = FALSE;
+
+    // Step over a leading '_'.
+    if (*pstr.string == '_')
+    {
+	pstr.string++;
+	pstr.length--;
+    }
+
+    // loop == 1: class variables, loop == 2: object variables
+    for (int loop = 1; loop <= 2; loop++)
+    {
+	garray_T    *vgap = (loop == 1) ? class_members : obj_members;
+	for (int i = 0; i < vgap->ga_len; ++i)
+	{
+	    ocmember_T *m = ((ocmember_T *)vgap->ga_data) + i;
+	    string_T	qstr = {m->ocm_name.string, m->ocm_name.length};
+
+	    // Step over a leading '_'.
+	    if (*qstr.string == '_')
+	    {
+		qstr.string++;
+		qstr.length--;
+	    }
+
+	    if (pstr.length == qstr.length
+		&& STRNCMP(pstr.string, qstr.string, pstr.length) == 0)
+	    {
+		char_u	save_c = *varname_end;
+
+		*varname_end = NUL;
+		semsg(_(e_duplicate_variable_str), varname);
+		*varname_end = save_c;
+		dup = TRUE;
+		break;
+	    }
+	}
+    }
+
+    return dup;
+}
+
+/*
+ * Returns TRUE if the method "name" is already defined.
+ */
+    static int
+is_duplicate_method(
+    garray_T	*classmethods_gap,
+    garray_T	*objmethods_gap,
+    char_u	*name)
+{
+    char_u *pstr = (*name == '_') ? name + 1 : name;
+
+    // loop 1: class methods, loop 2: object methods
+    for (int loop = 1; loop <= 2; loop++)
+    {
+	garray_T *fgap = (loop == 1) ? classmethods_gap : objmethods_gap;
+	for (int i = 0; i < fgap->ga_len; ++i)
+	{
+	    char_u	*n = ((ufunc_T **)fgap->ga_data)[i]->uf_name;
+	    char_u	*qstr = *n == '_' ? n + 1 : n;
+	    if (STRCMP(pstr, qstr) == 0)
+	    {
+		semsg(_(e_duplicate_function_str), name);
+		return TRUE;
+	    }
+	}
+    }
+
+    return FALSE;
+}
+
+/*
+ * Returns TRUE if the constructor is valid.
+ */
+    static int
+is_valid_constructor(ufunc_T *uf, int is_abstract, int has_static)
+{
+    // Constructors are not allowed in abstract classes.
+    if (is_abstract)
+    {
+	emsg(_(e_cannot_define_new_method_in_abstract_class));
+	return FALSE;
+    }
+    // A constructor is always static, no need to define it so.
+    if (has_static)
+    {
+	emsg(_(e_cannot_define_new_method_as_static));
+	return FALSE;
+    }
+    // A return type should not be specified for the new()
+    // constructor method.
+    if (uf->uf_ret_type->tt_type != VAR_VOID)
+    {
+	emsg(_(e_cannot_use_a_return_type_with_new_method));
+	return FALSE;
+    }
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if 'uf' is a supported builtin method and has the correct
+ * method signature.
+ */
+    static int
+object_check_builtin_method_sig(ufunc_T *uf)
+{
+    char_u  *name = uf->uf_name;
+    int	    valid = FALSE;
+    type_T  method_sig;
+    type_T  method_rt;
+    where_T where = WHERE_INIT;
+
+    // validate the method signature
+    CLEAR_FIELD(method_sig);
+    CLEAR_FIELD(method_rt);
+    method_sig.tt_type = VAR_FUNC;
+
+    if (STRCMP(name, "len") == 0)
+    {
+	// def __len(): number
+	method_rt.tt_type = VAR_NUMBER;
+	method_sig.tt_member = &method_rt;
+	valid = TRUE;
+    }
+    else if (STRCMP(name, "empty") == 0)
+    {
+	// def __empty(): bool
+	method_rt.tt_type = VAR_BOOL;
+	method_sig.tt_member = &method_rt;
+	valid = TRUE;
+    }
+    else if (STRCMP(name, "string") == 0)
+    {
+	// def __string(): string
+	method_rt.tt_type = VAR_STRING;
+	method_sig.tt_member = &method_rt;
+	valid = TRUE;
+    }
+    else
+	semsg(_(e_builtin_object_method_str_not_supported), uf->uf_name);
+
+    where.wt_func_name = (char *)uf->uf_name;
+    where.wt_kind = WT_METHOD;
+    if (valid && !check_type(&method_sig, uf->uf_func_type, TRUE, where))
+	valid = FALSE;
+
+    return valid;
+}
+
+/*
+ * Returns TRUE if "funcname" is a supported builtin object method name
+ */
+    int
+is_valid_builtin_obj_methodname(char_u *funcname)
+{
+    switch (funcname[0])
+    {
+	case 'e':
+	    return STRNCMP(funcname, "empty", 5) == 0;
+
+	case 'l':
+	    return STRNCMP(funcname, "len", 3) == 0;
+
+	case 'n':
+	    return STRNCMP(funcname, "new", 3) == 0;
+
+	case 's':
+	    return STRNCMP(funcname, "string", 6) == 0;
+    }
+
+    return FALSE;
+}
+
+
+/*
+ * Returns the builtin method "name" in object "obj".  Returns NULL if the
+ * method is not found.
+ */
+    ufunc_T *
+class_get_builtin_method(
+    class_T		*cl,
+    class_builtin_T	builtin_method,
+    int			*method_idx)
+{
+    *method_idx = -1;
+
+    if (cl == NULL)
+	return NULL;
+
+    *method_idx = cl->class_builtin_methods[builtin_method];
+    return *method_idx != -1 ? cl->class_obj_methods[*method_idx] : NULL;
+}
+
+/*
+ * Update the interface class lookup table for the member index on the
+ * interface to the member index in the class implementing the interface.
+ * And a lookup table for the object method index on the interface
+ * to the object method index in the class implementing the interface.
+ * This is also used for updating the lookup table for the extended class
+ * hierarchy.
+ */
+    static int
+update_member_method_lookup_table(
+    class_T	*ifcl,
+    class_T	*cl,
+    garray_T	*objmethods,
+    int		pobj_method_offset)
+{
+    if (ifcl == NULL)
+	return OK;
+
+    // Table for members.
+    itf2class_T *if2cl = alloc_clear(sizeof(itf2class_T)
+				+ ifcl->class_obj_member_count * sizeof(int));
+    if (if2cl == NULL)
+	return FAIL;
+    if2cl->i2c_next = ifcl->class_itf2class;
+    ifcl->class_itf2class = if2cl;
+    if2cl->i2c_class = cl;
+    if2cl->i2c_is_method = FALSE;
+
+    for (int if_i = 0; if_i < ifcl->class_obj_member_count; ++if_i)
+    {
+	char_u  *ocm_name = ifcl->class_obj_members[if_i].ocm_name.string;
+
+	for (int cl_i = 0; cl_i < cl->class_obj_member_count; ++cl_i)
+	{
+	    if (STRCMP(ocm_name, cl->class_obj_members[cl_i].ocm_name.string) == 0)
+	    {
+		int *table = (int *)(if2cl + 1);
+		table[if_i] = cl_i;
+		break;
+	    }
+	}
+    }
+
+    // Table for methods.
+    if2cl = alloc_clear(sizeof(itf2class_T)
+				+ ifcl->class_obj_method_count * sizeof(int));
+    if (if2cl == NULL)
+	return FAIL;
+    if2cl->i2c_next = ifcl->class_itf2class;
+    ifcl->class_itf2class = if2cl;
+    if2cl->i2c_class = cl;
+    if2cl->i2c_is_method = TRUE;
+
+    for (int if_i = 0; if_i < ifcl->class_obj_method_count; ++if_i)
+    {
+	int	done = FALSE;
+	char_u	*if_name = ifcl->class_obj_methods[if_i]->uf_name;
+
+	for (int cl_i = 0; cl_i < objmethods->ga_len; ++cl_i)
+	{
+	    if (STRCMP(if_name,
+			((ufunc_T **)objmethods->ga_data)[cl_i]->uf_name) == 0)
+	    {
+		int *table = (int *)(if2cl + 1);
+		table[if_i] = cl_i;
+		done = TRUE;
+		break;
+	    }
+	}
+
+	// extended class object method is not overridden by the child class.
+	// Keep the method declared in one of the parent classes in the
+	// lineage.
+	if (!done)
+	{
+	    // If "ifcl" is not the immediate parent of "cl", then search in
+	    // the intermediate parent classes.
+	    if (cl->class_extends != ifcl)
+	    {
+		class_T		*parent = cl->class_extends;
+		int		method_offset = objmethods->ga_len;
+
+		while (!done && parent != NULL && parent != ifcl)
+		{
+		    for (int cl_i = 0;
+			    cl_i < parent->class_obj_method_count_child; ++cl_i)
+		    {
+			if (STRCMP(if_name,
+				    parent->class_obj_methods[cl_i]->uf_name)
+				== 0)
+			{
+			    int *table = (int *)(if2cl + 1);
+			    table[if_i] = method_offset + cl_i;
+			    done = TRUE;
+			    break;
+			}
+		    }
+		    method_offset += parent->class_obj_method_count_child;
+		    parent = parent->class_extends;
+		}
+	    }
+
+	    if (!done)
+	    {
+		int *table = (int *)(if2cl + 1);
+		table[if_i] = pobj_method_offset + if_i;
+	    }
+	}
+    }
+
+    return OK;
+}
+
+/*
+ * Update the member and object method lookup tables for a new class in the
+ * interface class.
+ * For each interface add a lookup table for the member index on the interface
+ * to the member index in the new class.  And a lookup table for the object
+ * method index on the interface to the object method index in the new class.
+ */
+    static int
+add_lookup_tables(class_T *cl, class_T *extends_cl, garray_T *objmethods_gap)
+{
+    // update the lookup table for all the implemented interfaces
+    for (int i = 0; i < cl->class_interface_count; ++i)
+    {
+	class_T *ifcl = cl->class_interfaces_cl[i];
+
+	// update the lookup table for this interface and all its super
+	// interfaces.
+	while (ifcl != NULL)
+	{
+	    if (update_member_method_lookup_table(ifcl, cl, objmethods_gap,
+								0) == FAIL)
+		return FAIL;
+	    ifcl = ifcl->class_extends;
+	}
+    }
+
+    // Update the lookup table for the extended class, if any
+    if (extends_cl != NULL)
+    {
+	class_T		*pclass = extends_cl;
+	int		pobj_method_offset = objmethods_gap->ga_len;
+
+	// Update the entire lineage of extended classes.
+	while (pclass != NULL)
+	{
+	    if (update_member_method_lookup_table(pclass, cl,
+			objmethods_gap, pobj_method_offset) == FAIL)
+		return FAIL;
+
+	    pobj_method_offset += pclass->class_obj_method_count_child;
+	    pclass = pclass->class_extends;
+	}
+    }
+
+    return OK;
+}
+
+/*
+ * Add class members to a new class.  Allocate a typval for each class member
+ * and initialize it.
+ */
+    static int
+add_class_members(class_T *cl, exarg_T *eap, garray_T *type_list_gap)
+{
+    // Allocate a typval for each class member and initialize it.
+    cl->class_members_tv = ALLOC_CLEAR_MULT(typval_T,
+					    cl->class_class_member_count);
+    if (cl->class_members_tv == NULL)
+	return FAIL;
+
+    for (int i = 0; i < cl->class_class_member_count; ++i)
+    {
+	ocmember_T	*m = &cl->class_class_members[i];
+	typval_T	*tv = &cl->class_members_tv[i];
+	if (m->ocm_init != NULL)
+	{
+	    sctx_T	save_current_sctx = current_sctx;
+
+	    current_sctx = m->ocm_init_sctx;
+	    typval_T *etv = eval_expr(m->ocm_init, eap);
+	    current_sctx = save_current_sctx;
+	    if (etv == NULL)
+		return FAIL;
+
+	    if (m->ocm_type->tt_type == VAR_ANY
+		    && !(m->ocm_flags & OCMFLAG_HAS_TYPE)
+		    && etv->v_type != VAR_SPECIAL)
+		// If the member variable type is not yet set, then use
+		// the initialization expression type.
+		m->ocm_type = typval2type(etv, get_copyID(),
+			type_list_gap,
+			TVTT_DO_MEMBER|TVTT_MORE_SPECIFIC);
+	    *tv = *etv;
+	    mnv_free(etv);
+	}
+	else
+	{
+	    // TODO: proper default value
+	    tv->v_type = m->ocm_type->tt_type;
+	    tv->vval.v_string = NULL;
+	}
+	set_tv_type(tv, m->ocm_type);
+	if (m->ocm_flags & OCMFLAG_CONST)
+	    item_lock(tv, DICT_MAXNEST, TRUE, TRUE);
+    }
+
+    return OK;
+}
+
+/*
+ * Add a default constructor method (new()) to the class "cl".
+ */
+    static void
+add_default_constructor(
+    class_T	*cl,
+    garray_T	*classfunctions_gap,
+    garray_T	*type_list_gap)
+{
+    garray_T	fga;
+    int		is_enum = IS_ENUM(cl);
+
+    ga_init2(&fga, 1, 1000);
+    GA_CONCAT_LITERAL(&fga, "new(");
+    for (int i = 0; i < cl->class_obj_member_count; ++i)
+    {
+	if (i < 2 && is_enum)
+	    // The first two object variables in an enum are the enum value
+	    // name and ordinal.  Don't initialize these object variables in
+	    // the default constructor as they are already initialized right
+	    // after creating the object.
+	    continue;
+
+	if (i > (is_enum ? 2 : 0))
+	    GA_CONCAT_LITERAL(&fga, ", ");
+	GA_CONCAT_LITERAL(&fga, "this.");
+	ocmember_T *m = cl->class_obj_members + i;
+	ga_concat_len(&fga, (char_u *)m->ocm_name.string, m->ocm_name.length);
+	GA_CONCAT_LITERAL(&fga, " = v:none");
+    }
+    GA_CONCAT_LITERAL(&fga, ")\nenddef\n");
+    ga_append(&fga, NUL);
+
+    exarg_T fea;
+    CLEAR_FIELD(fea);
+    fea.cmdidx = CMD_def;
+    fea.cmd = fea.arg = fga.ga_data;
+
+    garray_T lines_to_free;
+    ga_init2(&lines_to_free, sizeof(char_u *), 50);
+
+    ufunc_T *nf = define_function(&fea, NULL, &lines_to_free, CF_CLASS,
+			    cl->class_obj_members, cl->class_obj_member_count,
+			    NULL);
+
+    ga_clear_strings(&lines_to_free);
+    mnv_free(fga.ga_data);
+
+    if (nf != NULL && ga_grow(classfunctions_gap, 1) == OK)
+    {
+	((ufunc_T **)classfunctions_gap->ga_data)[classfunctions_gap->ga_len]
+									= nf;
+	++classfunctions_gap->ga_len;
+
+	nf->uf_flags |= FC_NEW;
+	nf->uf_ret_type = get_type_ptr(type_list_gap);
+	if (nf->uf_ret_type != NULL)
+	{
+	    nf->uf_ret_type->tt_type = VAR_OBJECT;
+	    nf->uf_ret_type->tt_class = cl;
+	    nf->uf_ret_type->tt_argcount = 0;
+	    nf->uf_ret_type->tt_args = NULL;
+	}
+    }
+}
+
+/*
+ * Add the class methods and object methods to the new class "cl".
+ * When extending a class "extends_cl", add the instance methods from the
+ * parent class also.
+ * Returns OK on success and FAIL on memory allocation failure.
+ */
+    static int
+add_classfuncs_objmethods(
+    class_T	*cl,
+    class_T	*extends_cl,
+    garray_T	*classfunctions_gap,
+    garray_T	*objmethods_gap)
+{
+    // loop 1: class functions, loop 2: object methods
+    for (int loop = 1; loop <= 2; ++loop)
+    {
+	garray_T	*gap = loop == 1 ? classfunctions_gap : objmethods_gap;
+	int		*fcount = loop == 1 ? &cl->class_class_function_count
+						: &cl->class_obj_method_count;
+	ufunc_T		***fup = loop == 1 ? &cl->class_class_functions
+						: &cl->class_obj_methods;
+
+	int parent_count = 0;
+	if (extends_cl != NULL)
+	    // Include object methods from the parent.
+	    // Don't include the parent class methods.
+	    parent_count = loop == 1
+				? 0
+				: extends_cl->class_obj_method_count;
+
+	*fcount = parent_count + gap->ga_len;
+	if (*fcount == 0)
+	{
+	    *fup = NULL;
+	    continue;
+	}
+	*fup = ALLOC_MULT(ufunc_T *, *fcount);
+	if (*fup == NULL)
+	    return FAIL;
+
+	if (gap->ga_len != 0)
+	    mch_memmove(*fup, gap->ga_data, sizeof(ufunc_T *) * gap->ga_len);
+	MNV_CLEAR(gap->ga_data);
+	if (loop == 1)
+	    cl->class_class_function_count_child = gap->ga_len;
+	else
+	    cl->class_obj_method_count_child = gap->ga_len;
+
+	if (loop == 2)
+	{
+	    // Copy instance methods from the parent.
+
+	    for (int i = 0; i < parent_count; ++i)
+	    {
+		// Can't use the same parent function, because "uf_class" is
+		// different and compilation will have a different result.
+		// Put them after the functions in the current class, object
+		// methods may be overruled, then "super.Method()" is used to
+		// find a method from the parent.
+		ufunc_T *pf = (extends_cl->class_obj_methods)[i];
+		(*fup)[gap->ga_len + i] = copy_function(pf, 0);
+
+		// If the child class overrides a function from the parent
+		// the signature must be equal.
+		char_u *pname = pf->uf_name;
+		for (int ci = 0; ci < gap->ga_len; ++ci)
+		{
+		    ufunc_T *cf = (*fup)[ci];
+		    char_u *cname = cf->uf_name;
+		    if (STRCMP(pname, cname) == 0)
+		    {
+			where_T where = WHERE_INIT;
+			where.wt_func_name = (char *)pname;
+			where.wt_kind = WT_METHOD;
+			(void)check_type(pf->uf_func_type, cf->uf_func_type,
+								TRUE, where);
+		    }
+		}
+	    }
+	}
+
+	// Set the class pointer on all the functions and object methods.
+	for (int i = 0; i < *fcount; ++i)
+	{
+	    ufunc_T *fp = (*fup)[i];
+	    fp->uf_class = cl;
+	    if (i < gap->ga_len)
+		fp->uf_defclass = cl;
+	    if (loop == 2)
+		fp->uf_flags |= FC_OBJECT;
+	}
+
+	ga_clear(gap);
+    }
+
+    return OK;
+}
+
+/*
+ * Update the index of object methods called by builtin functions.
+ */
+    static void
+update_builtin_method_index(class_T *cl)
+{
+    int	i;
+
+    for (i = 0; i < CLASS_BUILTIN_MAX; i++)
+	cl->class_builtin_methods[i] = -1;
+
+    for (i = 0; i < cl->class_obj_method_count; i++)
+    {
+	ufunc_T *uf = cl->class_obj_methods[i];
+
+	if (cl->class_builtin_methods[CLASS_BUILTIN_STRING] == -1
+		&& STRCMP(uf->uf_name, "string") == 0)
+	    cl->class_builtin_methods[CLASS_BUILTIN_STRING] = i;
+	else if (cl->class_builtin_methods[CLASS_BUILTIN_EMPTY] == -1 &&
+		STRCMP(uf->uf_name, "empty") == 0)
+	    cl->class_builtin_methods[CLASS_BUILTIN_EMPTY] = i;
+	else if (cl->class_builtin_methods[CLASS_BUILTIN_LEN] == -1 &&
+		STRCMP(uf->uf_name, "len") == 0)
+	    cl->class_builtin_methods[CLASS_BUILTIN_LEN] = i;
+    }
+}
+
+/*
+ * Return the end of the class name starting at "arg".  Valid characters in a
+ * class name are alphanumeric characters and "_".  Also handles imported class
+ * names.
+ */
+    static char_u *
+find_class_name_end(char_u *arg)
+{
+    char_u *end = arg;
+
+    while (ASCII_ISALNUM(*end) || *end == '_'
+	    || (*end == '.' && (ASCII_ISALNUM(end[1]) || end[1] == '_')))
+	++end;
+
+    return end;
+}
+
+/*
+ * Returns TRUE if the enum value "varname" is already defined.
+ */
+    static int
+is_duplicate_enum(
+    garray_T	*enum_gap,
+    char_u	*varname,
+    char_u	*varname_end)
+{
+    string_T	name = {varname, (size_t)(varname_end - varname)};  // Note: the .string field may
+								    // point to a string longer
+								    // than the .length field.
+								    // So we need to use STRNCMP()
+								    // to compare it.
+    int		dup = FALSE;
+
+    for (int i = 0; i < enum_gap->ga_len; ++i)
+    {
+	ocmember_T *m = ((ocmember_T *)enum_gap->ga_data) + i;
+
+	if (name.length == m->ocm_name.length
+	    && STRNCMP(name.string, m->ocm_name.string, name.length) == 0)
+	{
+	    char_u  save_c = *varname_end;
+
+	    *varname_end = NUL;
+	    semsg(_(e_duplicate_enum_str), varname);
+	    *varname_end = save_c;
+	    dup = TRUE;
+	    break;
+	}
+    }
+
+    return dup;
+}
+
+/*
+ * Parse the enum values in "line" separated by comma and add them to "gap".
+ * If the last enum value is found, then "enum_end" is set to TRUE.
+ */
+    static int
+enum_parse_values(
+    exarg_T	*eap,
+    class_T	*en,
+    char_u	*line,
+    garray_T	*gap,
+    int		*num_enum_values,
+    int		*enum_end)
+{
+    evalarg_T	evalarg;
+    char_u	*p = line;
+    char	initexpr_buf[1024];
+    size_t	initexpr_buflen;
+    char_u	last_char = NUL;
+    int		rc = OK;
+
+    fill_evalarg_from_eap(&evalarg, eap, FALSE);
+
+    int		did_emsg_before = did_emsg;
+    while (*p != NUL)
+    {
+	// ignore comment
+	if (*p == '#')
+	    break;
+
+	if (!eval_isnamec1(*p))
+	{
+	    semsg(_(e_invalid_enum_value_declaration_str), p);
+	    break;
+	}
+
+	char_u *eni_name_start = p;
+	char_u *eni_name_end = to_name_end(p, FALSE);
+
+	if (is_duplicate_enum(gap, eni_name_start, eni_name_end))
+	    break;
+
+	p = skipwhite(eni_name_end);
+
+	char_u	*init_expr = NULL;
+	if (*p == '(' || *p == '<')
+	{
+	    if (MNV_ISWHITE(p[-1]))
+	    {
+		semsg(_(e_no_white_space_allowed_before_str_str), "(", line);
+		break;
+	    }
+
+	    char_u *expr_start, *expr_end;
+
+	    p = eni_name_start;
+	    (void)skip_expr_concatenate(&p, &expr_start, &expr_end, &evalarg);
+
+	    while (*expr_start && *expr_start != '(' && *expr_start != '<')
+		expr_start++;
+
+	    if (expr_end > expr_start)
+		init_expr = mnv_strnsave(expr_start, expr_end - expr_start);
+	}
+
+	if (init_expr == NULL)
+	    initexpr_buflen = mnv_snprintf_safelen(
+		initexpr_buf, sizeof(initexpr_buf), "%s.new()", en->class_name.string);
+	else
+	{
+	    initexpr_buflen = mnv_snprintf_safelen(
+		initexpr_buf, sizeof(initexpr_buf), "%s.new%s", en->class_name.string,
+		init_expr);
+	    mnv_free(init_expr);
+	}
+	if (add_member(gap, eni_name_start, eni_name_end, FALSE,
+				TRUE, TRUE, TRUE, &en->class_object_type,
+				mnv_strnsave((char_u *)initexpr_buf, initexpr_buflen)) == FAIL)
+	    break;
+
+	++*num_enum_values;
+
+	if (*p != '#')
+	    last_char = *p;
+
+	if (*p != NUL && *p != ',')
+	    break;
+
+	if (*p == ',')
+	{
+	    if (!IS_WHITE_OR_NUL(p[1]))
+	    {
+		semsg(_(e_white_space_required_after_str_str), ",", line);
+		break;
+	    }
+	    if (MNV_ISWHITE(p[-1]))
+	    {
+		semsg(_(e_no_white_space_allowed_before_str_str), ",", line);
+		break;
+	    }
+	    p = skipwhite(p + 1);
+	}
+    }
+
+    p = skipwhite(p);
+
+    if (*p != NUL && *p != '#')
+    {
+	if (did_emsg == did_emsg_before)
+	    semsg(_(e_missing_comma_before_argument_str), p);
+	rc = FAIL;
+    }
+
+    if (last_char != ',')
+	// last enum value should not be terminated by ","
+	*enum_end = TRUE;
+
+    // Free the memory pointed by expr_start.
+    clear_evalarg(&evalarg, NULL);
+
+    return rc;
+}
+
+/*
+ * Add the "values" class variable (List of enum value objects) to the enum
+ * class "en"
+ */
+    static int
+enum_add_values_member(
+    class_T	*en,
+    garray_T	*gap,
+    int		num_enum_values,
+    garray_T	*type_list_gap)
+{
+    garray_T	fga;
+    int		rc = FAIL;
+
+    ga_init2(&fga, 1, 1000);
+    GA_CONCAT_LITERAL(&fga, "[");
+    for (int i = 0; i < num_enum_values; ++i)
+    {
+	ocmember_T *m = ((ocmember_T *)gap->ga_data) + i;
+
+	if (i > 0)
+	    GA_CONCAT_LITERAL(&fga, ", ");
+	ga_concat_len(&fga, en->class_name.string, en->class_name.length);
+	GA_CONCAT_LITERAL(&fga, ".");
+	ga_concat_len(&fga, (char_u *)m->ocm_name.string, m->ocm_name.length);
+    }
+    GA_CONCAT_LITERAL(&fga, "]");
+    ga_append(&fga, NUL);
+
+    char_u *varname = (char_u *)"values";
+
+    type_T *type = get_type_ptr(type_list_gap);
+    if (type == NULL)
+	goto done;
+
+    type->tt_type = VAR_LIST;
+    type->tt_member = get_type_ptr(type_list_gap);
+    if (type->tt_member != NULL)
+    {
+	type->tt_member->tt_type = VAR_OBJECT;
+	type->tt_member->tt_class = en;
+    }
+
+    rc = add_member(gap, varname, varname + 6, FALSE, FALSE, TRUE, TRUE, type,
+					mnv_strnsave((char_u *)fga.ga_data, fga.ga_len));
+
+done:
+    mnv_free(fga.ga_data);
+
+    return rc;
+}
+
+/*
+ * Clear the constructor method names in a enum class, so that an enum class
+ * cannot be instantiated.
+ */
+    static void
+enum_clear_constructors(class_T *en)
+{
+    for (int i = 0; i < en->class_class_function_count; ++i)
+    {
+	ufunc_T *fp = en->class_class_functions[i];
+
+	if (fp->uf_flags & FC_NEW)
+	    *fp->uf_name = NUL;
+    }
+}
+
+/*
+ * Initialize the name and ordinal object variable in the enum value "enval" in
+ * the enum "en".  These values are set during the enum value object creation.
+ */
+    void
+enum_set_internal_obj_vars(class_T *en, object_T *enval)
+{
+    int	i;
+
+    for (i = 0; i < en->class_class_member_count; ++i)
+    {
+	typval_T *en_tv = en->class_members_tv + i;
+	if (en_tv != NULL && en_tv->v_type == VAR_UNKNOWN)
+	    break;
+    }
+
+    if (i >= en->class_class_member_count)
+	// When adding enum values to an enum, the index value should be less
+	// than the member count.  It will be greater only when appending a
+	// new item to a list of enums.  In this case, skip setting the enum
+	// name and ordinal (as this is a dummy enum object)
+	return;
+
+    // First object variable is the name
+    ocmember_T *value_ocm = en->class_class_members + i;
+    typval_T *name_tv = (typval_T *)(enval + 1);
+    name_tv->v_type = VAR_STRING;
+    name_tv->vval.v_string =
+	mnv_strnsave(value_ocm->ocm_name.string, value_ocm->ocm_name.length);
+
+    // Second object variable is the ordinal
+    typval_T *ord_tv = (typval_T *)(name_tv + 1);
+    ord_tv->v_type = VAR_NUMBER;
+    ord_tv->vval.v_number = i;
+}
+
+/*
+ * Handle ":class" and ":abstract class" up to ":endclass".
+ * Handle ":enum" up to ":endenum".
+ * Handle ":interface" up to ":endinterface".
+ */
+    void
+ex_class(exarg_T *eap)
+{
+    int		is_class = eap->cmdidx == CMD_class;
+    int		is_abstract = eap->cmdidx == CMD_abstract;
+    int		is_enum = eap->cmdidx == CMD_enum;
+    int		added_enum_values = FALSE;
+    int		is_interface;
+    long	start_lnum = SOURCING_LNUM;
+    char_u	*arg = eap->arg;
+
+    if (is_abstract)
+    {
+	if (STRNCMP(arg, "class", 5) != 0 || !MNV_ISWHITE(arg[5]))
+	{
+	    semsg(_(e_invalid_argument_str), arg);
+	    return;
+	}
+	arg = skipwhite(arg + 5);
+	is_class = TRUE;
+    }
+
+    is_interface = !is_class && !is_enum;
+
+    if (!current_script_is_mnv9()
+		|| (cmdmod.cmod_flags & CMOD_LEGACY)
+		|| !getline_equal(eap->ea_getline, eap->cookie, getsourceline))
+    {
+	if (is_class)
+	    emsg(_(e_class_can_only_be_defined_in_mnv9_script));
+	else if (is_enum)
+	    emsg(_(e_enum_can_only_be_defined_in_mnv9_script));
+	else
+	    emsg(_(e_interface_can_only_be_defined_in_mnv9_script));
+	return;
+    }
+
+    if (!ASCII_ISUPPER(*arg))
+    {
+	if (is_class)
+	    semsg(_(e_class_name_must_start_with_uppercase_letter_str), arg);
+	else if (is_enum)
+	    semsg(_(e_enum_name_must_start_with_uppercase_letter_str), arg);
+	else
+	    semsg(_(e_interface_name_must_start_with_uppercase_letter_str),
+									  arg);
+	return;
+    }
+    char_u *name_end = find_name_end(arg, NULL, NULL, FNE_CHECK_START);
+    if (!IS_WHITE_OR_NUL(*name_end))
+    {
+	semsg(_(e_white_space_required_after_name_str), arg);
+	return;
+    }
+    char_u *name_start = arg;
+
+    // TODO:
+    //    generics: <Tkey, Tentry>
+
+    // Name for "extends BaseClass"
+    char_u *extends = NULL;
+
+    // Names for "implements SomeInterface"
+    garray_T	ga_impl;
+    ga_init2(&ga_impl, sizeof(char_u *), 5);
+
+    arg = skipwhite(name_end);
+    while (*arg != NUL && *arg != '#' && *arg != '\n')
+    {
+	// TODO:
+	//    specifies SomeInterface
+	if (STRNCMP(arg, "extends", 7) == 0 && IS_WHITE_OR_NUL(arg[7]))
+	{
+	    if (is_enum)
+	    {
+		emsg(_(e_enum_cannot_extend_class));
+		goto early_ret;
+	    }
+	    if (extends != NULL)
+	    {
+		emsg(_(e_duplicate_extends));
+		goto early_ret;
+	    }
+	    arg = skipwhite(arg + 7);
+
+	    char_u *end = find_class_name_end(arg);
+	    if (!IS_WHITE_OR_NUL(*end))
+	    {
+		semsg(_(e_white_space_required_after_name_str), arg);
+		goto early_ret;
+	    }
+	    extends = mnv_strnsave(arg, end - arg);
+	    if (extends == NULL)
+		goto early_ret;
+
+	    arg = skipwhite(end + 1);
+	}
+	else if (STRNCMP(arg, "implements", 10) == 0
+						   && IS_WHITE_OR_NUL(arg[10]))
+	{
+	    if (is_interface)
+	    {
+		emsg(_(e_interface_cannot_use_implements));
+		goto early_ret;
+	    }
+
+	    if (ga_impl.ga_len > 0)
+	    {
+		emsg(_(e_duplicate_implements));
+		goto early_ret;
+	    }
+	    arg = skipwhite(arg + 10);
+
+	    for (;;)
+	    {
+		char_u *impl_end = find_class_name_end(arg);
+		if ((!IS_WHITE_OR_NUL(*impl_end) && *impl_end != ',')
+			|| (*impl_end == ','
+			    && !IS_WHITE_OR_NUL(*(impl_end + 1))))
+		{
+		    semsg(_(e_white_space_required_after_name_str), arg);
+		    goto early_ret;
+		}
+		if (impl_end - arg == 0)
+		{
+		    emsg(_(e_missing_name_after_implements));
+		    goto early_ret;
+		}
+
+		char_u *iname = mnv_strnsave(arg, impl_end - arg);
+		if (iname == NULL)
+		    goto early_ret;
+		for (int i = 0; i < ga_impl.ga_len; ++i)
+		    if (STRCMP(((char_u **)ga_impl.ga_data)[i], iname) == 0)
+		    {
+			semsg(_(e_duplicate_interface_after_implements_str),
+									iname);
+			mnv_free(iname);
+			goto early_ret;
+		    }
+		if (ga_add_string(&ga_impl, iname) == FAIL)
+		{
+		    mnv_free(iname);
+		    goto early_ret;
+		}
+		if (*impl_end != ',')
+		{
+		    arg = skipwhite(impl_end);
+		    break;
+		}
+		arg = skipwhite(impl_end + 1);
+	    }
+	}
+	else
+	{
+	    semsg(_(e_trailing_characters_str), arg);
+early_ret:
+	    mnv_free(extends);
+	    ga_clear_strings(&ga_impl);
+	    return;
+	}
+    }
+
+    garray_T	type_list;	    // list of pointers to allocated types
+    ga_init2(&type_list, sizeof(type_T *), 10);
+
+    // Growarray with class members declared in the class.
+    garray_T classmembers;
+    ga_init2(&classmembers, sizeof(ocmember_T), 10);
+
+    // Growarray with functions declared in the class.
+    garray_T classfunctions;
+    ga_init2(&classfunctions, sizeof(ufunc_T *), 10);
+
+    // Growarray with object members declared in the class.
+    garray_T objmembers;
+    ga_init2(&objmembers, sizeof(ocmember_T), 10);
+
+    // Growarray with object methods declared in the class.
+    garray_T objmethods;
+    ga_init2(&objmethods, sizeof(ufunc_T *), 10);
+
+    class_T *cl = NULL;
+    class_T *extends_cl = NULL;  // class from "extends" argument
+    class_T **intf_classes = NULL;
+    int	    num_enum_values = 0;
+
+    cl = ALLOC_CLEAR_ONE(class_T);
+    if (cl == NULL)
+	goto cleanup;
+
+    if (is_enum)
+	cl->class_flags = CLASS_ENUM;
+    else if (is_interface)
+	cl->class_flags = CLASS_INTERFACE;
+    else if (is_abstract)
+	cl->class_flags = CLASS_ABSTRACT;
+
+    cl->class_refcount = 1;
+    cl->class_name.length = (size_t)(name_end - name_start);
+    cl->class_name.string = mnv_strnsave(name_start, cl->class_name.length);
+    if (cl->class_name.string == NULL)
+	goto cleanup;
+
+    cl->class_type.tt_type = VAR_CLASS;
+    cl->class_type.tt_class = cl;
+    cl->class_object_type.tt_type = VAR_OBJECT;
+    cl->class_object_type.tt_class = cl;
+
+    eap->ea_class = cl;
+
+    // Add the class to the script-local variables.
+    // TODO: handle other context, e.g. in a function
+    // TODO: does uf_hash need to be cleared?
+    typval_T tv;
+    tv.v_type = VAR_CLASS;
+    tv.vval.v_class = cl;
+    SOURCING_LNUM = start_lnum;
+    int rc = set_var_const(cl->class_name.string, 0, NULL, &tv, FALSE, 0, 0);
+    if (rc == FAIL)
+	goto cleanup;
+
+    if (is_enum)
+    {
+	// All the enum classes have the name and ordinal object variables.
+	char_u *varname = (char_u *)"name";
+	if (add_member(&objmembers, varname, varname + 4, FALSE, FALSE, TRUE,
+		    TRUE, &t_string, NULL) == FAIL)
+	    goto cleanup;
+
+	varname = (char_u *)"ordinal";
+	if (add_member(&objmembers, varname, varname + 7, FALSE, FALSE, TRUE,
+		    TRUE, &t_number, NULL) == FAIL)
+	    goto cleanup;
+    }
+
+    // "export class" gets used when creating the class, don't use "is_export"
+    // for the items inside the class.
+    is_export = FALSE;
+
+    // When parsing an enum definition, this denotes whether all the enumerated
+    // values are parsed or not.
+    int		enum_end = FALSE;
+
+    /*
+     * Go over the body of the class/interface until "endclass" or
+     * "endinterface" or "endenum" is found.
+     */
+    char_u *theline = NULL;
+    int success = FALSE;
+    for (;;)
+    {
+	mnv_free(theline);
+	theline = eap->ea_getline(':', eap->cookie, 0, GETLINE_CONCAT_ALL);
+	if (theline == NULL)
+	    break;
+	char_u *line = skipwhite(theline);
+
+	// Skip empty and comment lines.
+	if (*line == NUL)
+	    continue;
+	if (*line == '#')
+	{
+	    if (mnv9_bad_comment(line))
+		break;
+	    continue;
+	}
+
+	char_u *p = line;
+
+	char	*end_name;
+	int	shortlen;
+	int	fullen;
+	if (is_class)
+	{
+	    end_name = "endclass";
+	    shortlen = 4;
+	    fullen = 8;
+	}
+	else if (is_enum)
+	{
+	    end_name = "endenum";
+	    shortlen = 4;
+	    fullen = 7;
+	}
+	else
+	{
+	    end_name = "endinterface";
+	    shortlen = 5;
+	    fullen = 12;
+	}
+
+	if (checkforcmd(&p, end_name, shortlen))
+	{
+	    if (STRNCMP(line, end_name, fullen) != 0)
+		semsg(_(e_command_cannot_be_shortened_str), line);
+	    else if (*p == '|' || !ends_excmd2(line, p))
+		semsg(_(e_trailing_characters_str), p);
+	    else
+		success = TRUE;
+	    break;
+	}
+
+	int	wrong_endname = FALSE;
+	if (is_class)
+	    wrong_endname = checkforcmd(&p, "endinterface", 5)
+					|| checkforcmd(&p, "endenum", 4);
+	else if (is_enum)
+	    wrong_endname = checkforcmd(&p, "endclass", 4)
+					|| checkforcmd(&p, "endinterface", 5);
+	else
+	    wrong_endname = checkforcmd(&p, "endclass", 4)
+					|| checkforcmd(&p, "endenum", 4);
+	if (wrong_endname)
+	{
+	    semsg(_(e_invalid_command_str_expected_str), line, end_name);
+	    break;
+	}
+
+	if (is_enum && !enum_end)
+	{
+	    // In an enum, all the enumerated values are at the beginning
+	    // separated by comma.  The class and object variables/methods
+	    // follow the values.
+	    if (enum_parse_values(eap, cl, line, &classmembers,
+					&num_enum_values, &enum_end) == FAIL)
+		break;
+
+	    if (enum_end)
+	    {
+		// Add the enum "values" class variable.
+		enum_add_values_member(cl, &classmembers, num_enum_values,
+							&type_list);
+		added_enum_values = TRUE;
+	    }
+	    continue;
+	}
+
+	int has_public = FALSE;
+	if (checkforcmd(&p, "public", 3))
+	{
+	    if (STRNCMP(line, "public", 6) != 0)
+	    {
+		semsg(_(e_command_cannot_be_shortened_str), line);
+		break;
+	    }
+	    if (is_interface)
+	    {
+		emsg(_(e_public_variable_not_supported_in_interface));
+		break;
+	    }
+	    has_public = TRUE;
+	    p = skipwhite(line + 6);
+
+	    if (STRNCMP(p, "def", 3) == 0)
+	    {
+		emsg(_(e_public_keyword_not_supported_for_method));
+		break;
+	    }
+
+	    if (STRNCMP(p, "var", 3) != 0 && STRNCMP(p, "static", 6) != 0
+		&& STRNCMP(p, "final", 5) != 0 && STRNCMP(p, "const", 5) != 0)
+	    {
+		emsg(_(e_public_must_be_followed_by_var_static_final_or_const));
+		break;
+	    }
+	}
+
+	int abstract_method = FALSE;
+	char_u *pa = p;
+	if (checkforcmd(&p, "abstract", 3))
+	{
+	    if (STRNCMP(pa, "abstract", 8) != 0)
+	    {
+		semsg(_(e_command_cannot_be_shortened_str), pa);
+		break;
+	    }
+
+	    if (is_enum)
+	    {
+		// "abstract" not supported in an enum
+		emsg(_(e_abstract_cannot_be_used_in_enum));
+		break;
+	    }
+
+	    if (is_interface)
+	    {
+		// "abstract" not supported in an interface
+		emsg(_(e_abstract_cannot_be_used_in_interface));
+		break;
+	    }
+
+	    if (!is_abstract)
+	    {
+		semsg(_(e_abstract_method_in_concrete_class), pa);
+		break;
+	    }
+
+	    p = skipwhite(pa + 8);
+	    if (STRNCMP(p, "def", 3) != 0)
+	    {
+		emsg(_(e_abstract_must_be_followed_by_def));
+		break;
+	    }
+
+	    abstract_method = TRUE;
+	}
+
+	int has_static = FALSE;
+	char_u *ps = p;
+	if (checkforcmd(&p, "static", 4))
+	{
+	    if (STRNCMP(ps, "static", 6) != 0)
+	    {
+		semsg(_(e_command_cannot_be_shortened_str), ps);
+		break;
+	    }
+
+	    if (is_interface)
+	    {
+		emsg(_(e_static_member_not_supported_in_interface));
+		break;
+	    }
+	    has_static = TRUE;
+	    p = skipwhite(ps + 6);
+
+	    if (STRNCMP(p, "var", 3) != 0 && STRNCMP(p, "def", 3) != 0
+		&& STRNCMP(p, "final", 5) != 0 && STRNCMP(p, "const", 5) != 0)
+	    {
+		emsg(_(e_static_must_be_followed_by_var_def_final_or_const));
+		break;
+	    }
+	}
+
+	int has_final = FALSE;
+	int has_var = FALSE;
+	int has_const = FALSE;
+	if (checkforcmd(&p, "var", 3))
+	    has_var = TRUE;
+	else if (checkforcmd(&p, "final", 5))
+	{
+	    if (is_interface)
+	    {
+		emsg(_(e_final_variable_not_supported_in_interface));
+		break;
+	    }
+	    has_final = TRUE;
+	}
+	else if (checkforcmd(&p, "const", 5))
+	{
+	    if (is_interface)
+	    {
+		emsg(_(e_const_variable_not_supported_in_interface));
+		break;
+	    }
+	    has_const = TRUE;
+	}
+	p = skipwhite(p);
+
+	// object members (public, read access, private):
+	//	"var _varname"
+	//	"var varname"
+	//	"public var varname"
+	//	"final _varname"
+	//	"final varname"
+	//	"public final varname"
+	//	"const _varname"
+	//	"const varname"
+	//	"public const varname"
+	// class members (public, read access, private):
+	//	"static var _varname"
+	//	"static var varname"
+	//	"public static var varname"
+	//	"static final _varname"
+	//	"static final varname"
+	//	"public static final varname"
+	//	"static const _varname"
+	//	"static const varname"
+	//	"public static const varname"
+	if (has_var || has_final || has_const)
+	{
+	    char_u *varname = p;
+	    char_u *varname_end = NULL;
+	    type_T *type = NULL;
+	    char_u *init_expr = NULL;
+	    int	    has_type = FALSE;
+
+	    if (!eval_isnamec1(*p))
+	    {
+		if (has_static)
+		    semsg(_(e_invalid_class_variable_declaration_str), line);
+		else
+		    semsg(_(e_invalid_object_variable_declaration_str), line);
+		break;
+	    }
+
+	    if (is_interface && *varname == '_')
+	    {
+		// private variables are not supported in an interface
+		semsg(_(e_protected_variable_not_supported_in_interface),
+			varname);
+		break;
+	    }
+
+	    if (parse_member(eap, line, varname, has_public,
+			  &varname_end, &has_type, &type_list, &type,
+			  !is_interface ? &init_expr: NULL) == FAIL)
+		break;
+
+	    if (is_reserved_varname(varname, varname_end)
+		    || is_duplicate_variable(&classmembers, &objmembers,
+							varname, varname_end))
+	    {
+		mnv_free(init_expr);
+		break;
+	    }
+	    if (add_member(has_static ? &classmembers : &objmembers, varname,
+				varname_end, has_public, has_final, has_const,
+				has_type, type, init_expr) == FAIL)
+	    {
+		mnv_free(init_expr);
+		break;
+	    }
+	}
+
+	// constructors:
+	//	  def new()
+	//	  enddef
+	//	  def newOther()
+	//	  enddef
+	// object methods and class functions:
+	//	  def SomeMethod()
+	//	  enddef
+	//	  static def ClassFunction()
+	//	  enddef
+	//	  def someMethod<typeA, typeB>()
+	//	  enddef
+	else if (checkforcmd(&p, "def", 3))
+	{
+	    exarg_T	ea;
+	    garray_T	lines_to_free;
+	    int		is_new = STRNCMP(p, "new", 3) == 0
+						|| STRNCMP(p, "_new", 4) == 0;
+
+	    if (has_public)
+	    {
+		// "public" keyword is not supported when defining an object or
+		// class method
+		emsg(_(e_public_keyword_not_supported_for_method));
+		break;
+	    }
+
+	    if (*p == NUL)
+	    {
+		// No method name following def
+		semsg(_(e_not_valid_command_in_class_str), line);
+		break;
+	    }
+
+	    if (is_interface && *p == '_')
+	    {
+		// private methods are not supported in an interface
+		semsg(_(e_protected_method_not_supported_in_interface), p);
+		break;
+	    }
+
+	    if (has_static && !is_new && SAFE_islower(*p) &&
+					is_valid_builtin_obj_methodname(p))
+	    {
+		semsg(_(e_builtin_class_method_not_supported), p);
+		break;
+	    }
+
+	    CLEAR_FIELD(ea);
+	    ea.cmd = line;
+	    ea.arg = p;
+	    ea.cmdidx = CMD_def;
+	    ea.ea_getline = eap->ea_getline;
+	    ea.cookie = eap->cookie;
+
+	    ga_init2(&lines_to_free, sizeof(char_u *), 50);
+	    int class_flags;
+	    if (is_interface)
+		class_flags = CF_INTERFACE;
+	    else
+		class_flags = abstract_method ? CF_ABSTRACT_METHOD : CF_CLASS;
+	    ufunc_T *uf = define_function(&ea, NULL, &lines_to_free,
+			class_flags, objmembers.ga_data, objmembers.ga_len,
+			NULL);
+	    ga_clear_strings(&lines_to_free);
+
+	    if (uf != NULL)
+	    {
+		if (is_new && !is_valid_constructor(uf, is_abstract,
+								has_static))
+		{
+		    // private variables are not supported in an interface
+		    semsg(_(e_protected_method_not_supported_in_interface),
+			    uf->uf_name);
+		    func_clear_free(uf, FALSE);
+		    break;
+		}
+
+		// check for builtin method
+		if (!is_new && SAFE_islower(*uf->uf_name) &&
+					!object_check_builtin_method_sig(uf))
+		{
+		    func_clear_free(uf, FALSE);
+		    break;
+		}
+
+		// Check the uf_name isn't used already.
+		if (is_duplicate_method(&classfunctions, &objmethods, uf->uf_name))
+		{
+		    success = FALSE;
+		    func_clear_free(uf, FALSE);
+		    break;
+		}
+
+		garray_T *fgap = has_static || is_new
+					       ? &classfunctions : &objmethods;
+		if (ga_grow(fgap, 1) == OK)
+		{
+		    if (is_new)
+			uf->uf_flags |= FC_NEW;
+
+		    if (abstract_method)
+			uf->uf_flags |= FC_ABSTRACT;
+
+		    ((ufunc_T **)fgap->ga_data)[fgap->ga_len] = uf;
+		    ++fgap->ga_len;
+		}
+	    }
+	}
+
+	else
+	{
+	    if (is_class)
+		semsg(_(e_not_valid_command_in_class_str), line);
+	    else if (is_enum)
+		semsg(_(e_not_valid_command_in_enum_str), line);
+	    else
+		semsg(_(e_not_valid_command_in_interface_str), line);
+	    break;
+	}
+    }
+
+    if (theline == NULL && !success && is_enum)
+	emsg(_(e_missing_endenum));
+
+    mnv_free(theline);
+
+    if (success && is_enum && (num_enum_values == 0 || !added_enum_values))
+	// Empty enum statement. Add an empty "values" class variable
+	success = enum_add_values_member(cl, &classmembers, num_enum_values,
+								&type_list);
+
+    /*
+     * Check a few things
+     */
+
+    // Check the "extends" class is valid.
+    if (success && extends != NULL)
+	success = validate_extends_class(cl, extends, &extends_cl, is_class);
+    MNV_CLEAR(extends);
+
+    // Check the new object methods to make sure their access (public or
+    // private) is the same as that in the extended class lineage.
+    if (success && extends_cl != NULL)
+	success = validate_extends_methods(&objmethods, extends_cl);
+
+    // Check the new class and object variables are not duplicates of the
+    // variables in the extended class lineage.  If an interface is extending
+    // another interface, then it can duplicate the member variables.
+    if (success && extends_cl != NULL)
+    {
+	if (is_class)
+	    success = extends_check_dup_members(&objmembers, extends_cl);
+	else
+	    success = extends_check_intf_var_type(&objmembers, extends_cl);
+    }
+
+    // When extending an abstract class, make sure all the abstract methods in
+    // the parent class are implemented.  If the current class is an abstract
+    // class, then there is no need for this check.
+    if (success && !is_abstract && extends_cl != NULL
+				&& (extends_cl->class_flags & CLASS_ABSTRACT))
+	success = validate_abstract_class_methods(&classfunctions,
+						&objmethods, extends_cl);
+
+    // Process the "implements" entries
+    // Check all "implements" entries are valid.
+    garray_T  intf_classes_ga;
+
+    ga_init2(&intf_classes_ga, sizeof(class_T *), 5);
+
+    if (success && ga_impl.ga_len > 0)
+	success = validate_implements_classes(&ga_impl, &intf_classes_ga,
+					&objmethods, &objmembers, extends_cl);
+
+    // inherit the super class interfaces
+    if (success && extends_cl != NULL)
+	success = add_super_class_interfaces(extends_cl, &ga_impl,
+							&intf_classes_ga);
+
+    intf_classes = intf_classes_ga.ga_data;
+    intf_classes_ga.ga_len = 0;
+
+    // Check no function argument name is used as a class member.
+    if (success)
+	success = check_func_arg_names(&classfunctions, &objmethods,
+							&classmembers);
+
+    if (success)
+    {
+	// "endclass" or "endinterface" or "endenum" encountered without any
+	// failures
+
+	if (extends_cl != NULL)
+	{
+	    cl->class_extends = extends_cl;
+	    extends_cl->class_flags |= CLASS_EXTENDED;
+	}
+
+	// Add class and object variables to "cl".
+	if (add_members_to_class(&classmembers,
+				 NULL,
+				 0,
+				 &cl->class_class_members,
+				 &cl->class_class_member_count) == FAIL
+		|| add_members_to_class(&objmembers,
+				 extends_cl == NULL ? NULL
+					       : extends_cl->class_obj_members,
+				 extends_cl == NULL ? 0
+					  : extends_cl->class_obj_member_count,
+				 &cl->class_obj_members,
+				 &cl->class_obj_member_count) == FAIL)
+	    goto cleanup;
+
+	if (ga_impl.ga_len > 0)
+	{
+	    // Move the "implements" names into the class.
+	    cl->class_interface_count = ga_impl.ga_len;
+	    cl->class_interfaces = ALLOC_MULT(char_u *, ga_impl.ga_len);
+	    if (cl->class_interfaces == NULL)
+		goto cleanup;
+	    for (int i = 0; i < ga_impl.ga_len; ++i)
+		cl->class_interfaces[i] = ((char_u **)ga_impl.ga_data)[i];
+	    MNV_CLEAR(ga_impl.ga_data);
+	    ga_impl.ga_len = 0;
+
+	    cl->class_interfaces_cl = intf_classes;
+	    intf_classes = NULL;
+	}
+
+	if (cl->class_interface_count > 0 || extends_cl != NULL)
+	{
+	    // Add a method and member lookup table to each of the interface
+	    // classes.
+	    if (add_lookup_tables(cl, extends_cl, &objmethods) == FAIL)
+		goto cleanup;
+	}
+
+	int	have_new = FALSE;
+	ufunc_T	*class_func = NULL;
+	for (int i = 0; i < classfunctions.ga_len; ++i)
+	{
+	    class_func = ((ufunc_T **)classfunctions.ga_data)[i];
+	    if (STRCMP(class_func->uf_name, "new") == 0
+				|| STRCMP(class_func->uf_name, "_new") == 0)
+	    {
+		have_new = TRUE;
+		break;
+	    }
+	}
+
+	if (have_new)
+	    // The return type of new() is an object of class "cl"
+	    class_func->uf_ret_type->tt_class = cl;
+	else if ((is_class || is_enum) && !is_abstract && !have_new)
+	    // No new() method was defined, add the default constructor.
+	    add_default_constructor(cl, &classfunctions, &type_list);
+
+	// Move all the functions into the created class.
+	if (add_classfuncs_objmethods(cl, extends_cl, &classfunctions,
+							&objmethods) == FAIL)
+	    goto cleanup;
+
+	update_builtin_method_index(cl);
+
+	class_created(cl);
+
+	// Allocate a typval for each class member and initialize it.
+	if ((is_class || is_enum) && cl->class_class_member_count > 0)
+	    if (add_class_members(cl, eap, &type_list) == FAIL)
+	    {
+		cl->class_type_list = type_list;
+		return;
+	    }
+
+	cl->class_type_list = type_list;
+
+	if (is_enum)
+	{
+	    // clear the constructor method names, so that an enum class cannot
+	    // be instantiated
+	    enum_clear_constructors(cl);
+	}
+
+	// TODO:
+	// - Fill hashtab with object members and methods ?
+
+	return;
+    }
+
+cleanup:
+    mnv_free(extends);
+    class_unref(extends_cl);
+
+    if (intf_classes != NULL)
+    {
+	for (int i = 0; i < ga_impl.ga_len; ++i)
+	    class_unref(intf_classes[i]);
+	mnv_free(intf_classes);
+    }
+    ga_clear_strings(&ga_impl);
+
+    for (int round = 1; round <= 2; ++round)
+    {
+	garray_T *gap = round == 1 ? &classmembers : &objmembers;
+	if (gap->ga_len == 0 || gap->ga_data == NULL)
+	    continue;
+
+	for (int i = 0; i < gap->ga_len; ++i)
+	{
+	    ocmember_T *m = ((ocmember_T *)gap->ga_data) + i;
+	    MNV_CLEAR_STRING(m->ocm_name);
+	    mnv_free(m->ocm_init);
+	}
+	ga_clear(gap);
+    }
+
+    for (int i = 0; i < objmethods.ga_len; ++i)
+    {
+	ufunc_T *uf = ((ufunc_T **)objmethods.ga_data)[i];
+	func_clear_free(uf, FALSE);
+    }
+    ga_clear(&objmethods);
+
+    for (int i = 0; i < classfunctions.ga_len; ++i)
+    {
+	ufunc_T *uf = ((ufunc_T **)classfunctions.ga_data)[i];
+	func_clear_free(uf, FALSE);
+    }
+    ga_clear(&classfunctions);
+
+    clear_type_list(&type_list);
+}
+
+/*
+ * Find member "name" in class "cl", set "member_idx" to the member index and
+ * return its type.
+ * When "is_object" is TRUE, then look for object members.  Otherwise look for
+ * class members.
+ * When not found "member_idx" is set to -1 and t_any is returned.
+ * Set *p_m ocmmember_T if not NULL
+ */
+    type_T *
+oc_member_type(
+    class_T	*cl,
+    int		is_object,
+    char_u	*name,
+    char_u	*name_end,
+    int		*member_idx)
+{
+    size_t	len = name_end - name;
+    ocmember_T	*m;
+
+    *member_idx = -1;  // not found (yet)
+
+    m = member_lookup(cl, is_object ? VAR_OBJECT : VAR_CLASS, name, len,
+								member_idx);
+    if (m == NULL)
+    {
+	member_not_found_msg(cl, is_object ? VAR_OBJECT : VAR_CLASS, name,
+									len);
+	return &t_any;
+    }
+
+    return m->ocm_type;
+}
+
+/*
+ * Given a class or object variable index, return the variable type
+ */
+    type_T *
+oc_member_type_by_idx(
+    class_T	*cl,
+    int		is_object,
+    int		member_idx)
+{
+    ocmember_T	*m;
+    int		member_count;
+
+    if (is_object)
+    {
+	m = cl->class_obj_members;
+	member_count = cl->class_obj_member_count;
+    }
+    else
+    {
+	m = cl->class_class_members;
+	member_count = cl->class_class_member_count;
+    }
+
+    if (member_idx >= member_count)
+	return NULL;
+
+    return m[member_idx].ocm_type;
+}
+
+/*
+ * Type aliases (:type)
+ */
+
+    static void
+typealias_free(typealias_T *ta)
+{
+    // ta->ta_type is freed in clear_type_list()
+    mnv_free(ta->ta_name);
+    mnv_free(ta);
+}
+
+    void
+typealias_unref(typealias_T *ta)
+{
+    if (ta != NULL && --ta->ta_refcount <= 0)
+	typealias_free(ta);
+}
+
+/*
+ * Handle ":type".  Create an alias for a type specification.
+ */
+    void
+ex_type(exarg_T *eap)
+{
+    char_u	*arg = eap->arg;
+
+    if (!current_script_is_mnv9()
+		|| (cmdmod.cmod_flags & CMOD_LEGACY)
+		|| !getline_equal(eap->ea_getline, eap->cookie, getsourceline))
+    {
+	emsg(_(e_type_can_only_be_defined_in_mnv9_script));
+	return;
+    }
+
+    if (*arg == NUL)
+    {
+	emsg(_(e_missing_typealias_name));
+	return;
+    }
+
+    if (!ASCII_ISUPPER(*arg))
+    {
+	semsg(_(e_type_name_must_start_with_uppercase_letter_str), arg);
+	return;
+    }
+
+    char_u *name_end = find_name_end(arg, NULL, NULL, FNE_CHECK_START);
+    if (!IS_WHITE_OR_NUL(*name_end))
+    {
+	semsg(_(e_white_space_required_after_name_str), arg);
+	return;
+    }
+    char_u *name_start = arg;
+
+    arg = skipwhite(name_end);
+    if (*arg != '=')
+    {
+	semsg(_(e_missing_equal_str), arg);
+	return;
+    }
+    if (!IS_WHITE_OR_NUL(*(arg + 1)))
+    {
+	semsg(_(e_white_space_required_after_str_str), "=", arg);
+	return;
+    }
+    arg++;
+    arg = skipwhite(arg);
+
+    if (*arg == NUL)
+    {
+	emsg(_(e_missing_typealias_type));
+	return;
+    }
+
+    scriptitem_T    *si = SCRIPT_ITEM(current_sctx.sc_sid);
+    type_T *type = parse_type(&arg, &si->sn_type_list, NULL, NULL, TRUE);
+    if (type == NULL)
+	return;
+
+    if (*arg != NUL)
+    {
+	// some text after the type
+	semsg(_(e_trailing_characters_str), arg);
+	return;
+    }
+
+    int cc = *name_end;
+    *name_end = NUL;
+
+    typval_T tv;
+    tv.v_type = VAR_UNKNOWN;
+    if (eval_variable_import(name_start, &tv) == OK)
+    {
+	if (tv.v_type == VAR_TYPEALIAS)
+	    semsg(_(e_typealias_already_exists_for_str), name_start);
+	else
+	    semsg(_(e_redefining_script_item_str), name_start);
+	clear_tv(&tv);
+	goto done;
+    }
+
+    // Create a script-local variable for the type alias.
+    if (type->tt_type != VAR_OBJECT)
+    {
+	tv.v_type = VAR_TYPEALIAS;
+	tv.v_lock = 0;
+	tv.vval.v_typealias = ALLOC_CLEAR_ONE(typealias_T);
+	++tv.vval.v_typealias->ta_refcount;
+	tv.vval.v_typealias->ta_name = mnv_strsave(name_start);
+	tv.vval.v_typealias->ta_type = type;
+    }
+    else
+    {
+	// When creating a type alias for a class, use the class type itself to
+	// create the type alias variable.  This is needed to use the type
+	// alias to invoke class methods (e.g. new()) and use class variables.
+	tv.v_type = VAR_CLASS;
+	tv.v_lock = 0;
+	tv.vval.v_class = type->tt_class;
+	++tv.vval.v_class->class_refcount;
+    }
+    set_var_const(name_start, current_sctx.sc_sid, NULL, &tv, FALSE,
+						ASSIGN_CONST | ASSIGN_FINAL, 0);
+
+done:
+    *name_end = cc;
+}
+
+/*
+ * Returns OK if a member variable named "name" is present in the class "cl".
+ * Otherwise returns FAIL.  If found, the member variable typval is set in
+ * "rettv".  If "is_object" is TRUE, then the object member variable table is
+ * searched.  Otherwise the class member variable table is searched.
+ */
+    int
+get_member_tv(
+    class_T	*cl,
+    int		is_object,
+    char_u	*name,
+    size_t	namelen,
+    class_T	*current_class,
+    typval_T	*rettv)
+{
+    ocmember_T *m;
+    int		m_idx;
+
+    m = member_lookup(cl, is_object ? VAR_OBJECT : VAR_CLASS, name, namelen,
+								&m_idx);
+    if (m == NULL)
+	return FAIL;
+
+    if (*name == '_' && (current_class == NULL ||
+				!class_instance_of(current_class, cl)))
+    {
+	emsg_var_cl_define(e_cannot_access_protected_variable_str,
+							m->ocm_name.string, 0, cl);
+	return FAIL;
+    }
+
+    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);
+	set_tv_type(rettv, m->ocm_type);
+	object_unref(obj);
+    }
+    else
+    {
+	copy_tv(&cl->class_members_tv[m_idx], rettv);
+	set_tv_type(rettv, m->ocm_type);
+	class_unref(cl);
+    }
+
+    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,
+    gfargs_tab_T	*gfatab,	// generic types
+    typval_T	*rettv)
+{
+    ufunc_T	*fp;
+    typval_T	argvars[MAX_FUNC_ARGS + 1];
+    int		argcount = 0;
+    ocmember_T	*ocm = NULL;
+    int		m_idx;
+
+    fp = method_lookup(cl, rettv->v_type, name, len, NULL);
+    if (fp == NULL)
+    {
+	// could be an object or class funcref variable
+	ocm = member_lookup(cl, rettv->v_type, name, len, &m_idx);
+	if (ocm == NULL || ocm->ocm_type->tt_type != VAR_FUNC)
+	{
+	    method_not_found_msg(cl, rettv->v_type, name, len);
+	    return FAIL;
+	}
+
+	if (*name == '_')
+	{
+	    // Protected object or class funcref variable
+	    semsg(_(e_cannot_access_protected_variable_str), ocm->ocm_name.string,
+		    cl->class_name.string);
+	    return FAIL;
+	}
+
+	if (rettv->v_type == VAR_OBJECT)
+	{
+	    // funcref object variable
+	    object_T	*obj = rettv->vval.v_object;
+	    typval_T	*tv = (typval_T *)(obj + 1) + m_idx;
+	    copy_tv(tv, rettv);
+	}
+	else
+	    // funcref class variable
+	    copy_tv(&cl->class_members_tv[m_idx], rettv);
+	*arg = name_end;
+	return OK;
+    }
+
+    if (ocm == NULL && *fp->uf_name == '_')
+    {
+	// Cannot access a protected method outside of a class
+	semsg(_(e_cannot_access_protected_method_str), fp->uf_name);
+	return FAIL;
+    }
+
+    // process generic function call
+    if (fp != NULL)
+    {
+	fp = generic_func_get(fp, gfatab);
+	if (fp == NULL)
+	    return FAIL;
+    }
+
+    char_u *argp = name_end;
+    int ret = get_func_arguments(&argp, evalarg, 0, argvars, &argcount, FALSE);
+    if (ret == FAIL)
+    {
+	while (--argcount >= 0)
+	    clear_tv(&argvars[argcount]);
+	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;
+    }
+    if (evalarg != NULL)
+	funcexe.fe_cctx = evalarg->eval_cctx;
+
+    // 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;
+}
+
+/*
+ * Create a partial typval for "obj.obj_method" and store it in "rettv".
+ * Returns OK on success and FAIL on memory allocation failure.
+ */
+    int
+obj_method_to_partial_tv(object_T *obj, ufunc_T *obj_method, typval_T *rettv)
+{
+    partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
+    if (pt == NULL)
+	return FAIL;
+
+    pt->pt_refcount = 1;
+    if (obj != NULL)
+    {
+	pt->pt_obj = obj;
+	++pt->pt_obj->obj_refcount;
+    }
+    pt->pt_auto = TRUE;
+    pt->pt_func = obj_method;
+    func_ptr_ref(pt->pt_func);
+
+    rettv->v_type = VAR_PARTIAL;
+    rettv->vval.v_partial = pt;
+
+    return OK;
+}
+
+/*
+ * Evaluate what comes after a class:
+ * - class member: SomeClass.varname
+ * - class function: SomeClass.SomeMethod()
+ * - class constructor: SomeClass.new()
+ * - object member: someObject.varname
+ * - object method: someObject.SomeMethod()
+ *
+ * "*arg" points to the '.'.
+ * "*arg" is advanced to after the member name or method call.
+ *
+ * Returns FAIL or OK.
+ */
+    int
+class_object_index(
+    char_u	**arg,
+    typval_T	*rettv,
+    evalarg_T	*evalarg,
+    int		verbose UNUSED)	// give error messages
+{
+    int	ret = FAIL;
+
+    if (MNV_ISWHITE((*arg)[1]))
+    {
+	semsg(_(e_no_white_space_allowed_after_str_str), ".", *arg);
+	return FAIL;
+    }
+
+    ++*arg;
+    char_u *name = *arg;
+    char_u *name_end = find_name_end(name, NULL, NULL, FNE_CHECK_START);
+    if (name_end == name)
+	return FAIL;
+    size_t len = name_end - name;
+
+    int did_emsg_save = did_emsg;
+    class_T *cl;
+    if (rettv->v_type == VAR_CLASS)
+	cl = rettv->vval.v_class;
+    else // VAR_OBJECT
+    {
+	if (rettv->vval.v_object == NULL)
+	{
+	    emsg(_(e_using_null_object));
+	    return FAIL;
+	}
+	cl = rettv->vval.v_object->obj_class;
+    }
+
+    if (cl == NULL)
+    {
+	emsg(_(e_incomplete_type));
+	return FAIL;
+    }
+
+    gfargs_tab_T    gfatab;
+
+    generic_func_args_table_init(&gfatab);
+
+    if (*name_end == '<')
+    {
+	cctx_T	    *cctx = NULL;
+
+	if (evalarg != NULL)
+	    cctx = evalarg->eval_cctx;
+
+	// calling a generic method
+	name_end = parse_generic_func_type_args(name, len, name + len,
+						&gfatab, cctx);
+	if (name_end == NULL)
+	    goto done;
+    }
+
+    if (*name_end == '(')
+	// Invoke the class or object method
+	ret = call_oc_method(cl, name, len, name_end, evalarg, arg,
+							&gfatab, rettv);
+    else if (rettv->v_type == VAR_OBJECT || rettv->v_type == VAR_CLASS)
+    {
+	// Search in the object member variable table and the class member
+	// variable table.
+	int is_object = rettv->v_type == VAR_OBJECT;
+	if (get_member_tv(cl, is_object, name, len, NULL, rettv) == OK)
+	{
+	    *arg = name_end;
+	    ret = OK;
+	    goto done;
+	}
+
+	// could be a class method or an object method
+	int	fidx;
+	ufunc_T	*fp = method_lookup(cl, rettv->v_type, name, len, &fidx);
+	if (fp != NULL)
+	{
+	    // Protected methods are not accessible outside the class
+	    if (fp->uf_defclass != evalarg->eval_class
+		    && *name == '_')
+	    {
+		semsg(_(e_cannot_access_protected_method_str), fp->uf_name);
+		goto done;
+	    }
+
+	    if (obj_method_to_partial_tv(is_object ? rettv->vval.v_object :
+						NULL, fp, rettv) == FAIL)
+		goto done;
+
+	    *arg = name_end;
+	    ret = OK;
+	    goto done;
+	}
+
+	if (did_emsg == did_emsg_save)
+	    member_not_found_msg(cl, rettv->v_type, name, len);
+    }
+
+done:
+    generic_func_args_table_clear(&gfatab);
+
+    return ret;
+}
+
+/*
+ * If "arg" points to a class or object method, return it.
+ * Otherwise return NULL.
+ */
+    ufunc_T *
+find_class_func(char_u **arg)
+{
+    char_u *name = *arg;
+    char_u *name_end = find_name_end(name, NULL, NULL, FNE_CHECK_START);
+    if (name_end == name || *name_end != '.')
+	return NULL;
+
+    ufunc_T	*fp = NULL;
+    size_t	len = name_end - name;
+    typval_T	tv;
+    tv.v_type = VAR_UNKNOWN;
+    if (eval_variable(name, (int)len,
+				    0, &tv, NULL, EVAL_VAR_NOAUTOLOAD) == FAIL)
+	return NULL;
+    if (tv.v_type != VAR_CLASS && tv.v_type != VAR_OBJECT)
+	goto fail_after_eval;
+
+    class_T *cl = tv.v_type == VAR_CLASS ? tv.vval.v_class
+						 : tv.vval.v_object->obj_class;
+    if (cl == NULL)
+	goto fail_after_eval;
+    char_u *fname = name_end + 1;
+    char_u *fname_end = find_name_end(fname, NULL, NULL, FNE_CHECK_START);
+    if (fname_end == fname)
+	goto fail_after_eval;
+    len = fname_end - fname;
+
+    fp = method_lookup(cl, tv.v_type, fname, len, NULL);
+
+    if (fp != NULL)
+    {
+	fp = eval_generic_func(fp, fname, &fname_end);
+	if (fp != NULL)
+	    *arg = fname_end;
+    }
+
+fail_after_eval:
+    clear_tv(&tv);
+    return fp;
+}
+
+/*
+ * Returns the index of class 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
+class_member_idx(class_T *cl, char_u *name, size_t namelen)
+{
+    int idx;
+    class_member_lookup(cl, name, namelen, &idx);
+    return idx;
+}
+
+/*
+ * Returns a pointer to the class member variable "name" in the class "cl".
+ * Returns NULL if the variable is not found.
+ * The member variable index is set in "idx".
+ */
+    ocmember_T *
+class_member_lookup(class_T *cl, char_u *name, size_t namelen, int *idx)
+{
+    ocmember_T	*ret_m = NULL;
+    int		ret_idx = -1;
+    for (int i = 0; i < cl->class_class_member_count; ++i)
+    {
+	ocmember_T *m = &cl->class_class_members[i];
+	if (namelen)
+	{
+	    if (namelen == m->ocm_name.length
+		&& STRNCMP(name, m->ocm_name.string, namelen) == 0)
+	    {
+		ret_m = m;
+		ret_idx = i;
+		break;
+	    }
+	}
+	else if (STRCMP(name, m->ocm_name.string) == 0)
+	{
+	    ret_m = m;
+	    ret_idx = i;
+	    break;
+	}
+    }
+    if (idx != NULL)
+	*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)
+{
+    int idx;
+    class_method_lookup(cl, name, namelen, &idx);
+    return idx;
+}
+
+/*
+ * 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.
+ */
+    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;
+}
+
+/*
+ * Returns a pointer to the object member variable "name" in the class "cl".
+ * Returns NULL if the variable is not found.
+ * The object member variable index is set in "idx".
+ */
+    ocmember_T *
+object_member_lookup(class_T *cl, char_u *name, size_t namelen, int *idx)
+{
+    ocmember_T	*ret_m = NULL;
+    int		ret_idx = -1;
+    for (int i = 0; i < cl->class_obj_member_count; ++i)
+    {
+	ocmember_T  *m = &cl->class_obj_members[i];
+	if (namelen)
+	{
+	    if (namelen == m->ocm_name.length
+		&& STRNCMP(name, m->ocm_name.string, namelen) == 0)
+	    {
+		ret_m = m;
+		ret_idx = i;
+		break;
+	    }
+	}
+	else if (STRCMP(name, m->ocm_name.string) == 0)
+	{
+	    ret_m = m;
+	    ret_idx = i;
+	    break;
+	}
+    }
+    if (idx != NULL)
+	*idx = ret_idx;
+    return ret_m;
+}
+
+/*
+ * 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".
+ */
+    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)
+    {
+	ufunc_T *fp = cl->class_obj_methods[i];
+	// Use a separate pointer to avoid that ASAN complains about
+	// uf_name[] only being 4 characters.
+	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 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
+ * object member variable.
+ *
+ * Returns a pointer to the member variable structure if variable is found.
+ * Otherwise returns NULL.  The member variable index is set in "*idx".
+ */
+    ocmember_T *
+member_lookup(
+    class_T	*cl,
+    vartype_T	v_type,
+    char_u	*name,
+    size_t	namelen,
+    int		*idx)
+{
+    if (v_type == VAR_CLASS)
+	return class_member_lookup(cl, name, namelen, idx);
+
+    return object_member_lookup(cl, name, namelen, idx);
+}
+
+/*
+ * Find the class that defines the named member. Look up the hierarchy
+ * starting at "cl".
+ *
+ * Return the class that defines the member "name", else NULL.
+ * Fill in "p_m", if specified, for ocmember_T in found class.
+ */
+// NOTE: if useful for something could also indirectly return vartype and idx.
+    static class_T *
+class_defining_member(class_T *cl, char_u *name, size_t len, ocmember_T **p_m)
+{
+    class_T	*cl_found = NULL;
+    vartype_T	vartype = VAR_UNKNOWN;
+    ocmember_T	*m_found = NULL;
+
+    len = len != 0 ? len : STRLEN(name);
+
+    // Loop assumes if member is not defined in "cl", then it is not
+    // defined in any super class; the last class where it's found is the
+    // class where it is defined. Once the vartype is found, the other
+    // type is no longer checked.
+    for (class_T *super = cl; super != NULL; super = super->class_extends)
+    {
+	class_T		*cl_tmp = NULL;
+	ocmember_T	*m = NULL;
+	if (vartype == VAR_UNKNOWN || vartype == VAR_OBJECT)
+	{
+	    if ((m = object_member_lookup(super, name, len, NULL)) != NULL)
+	    {
+		cl_tmp = super;
+		vartype = VAR_OBJECT;
+	    }
+	}
+	if (vartype == VAR_UNKNOWN || vartype == VAR_CLASS)
+	{
+	    if (( m = class_member_lookup(super, name, len, NULL)) != NULL)
+	    {
+		cl_tmp = super;
+		vartype = VAR_CLASS;
+	    }
+	}
+	if (cl_tmp == NULL)
+	    break;  // member is not in this or any super class.
+	cl_found = cl_tmp;
+	m_found = m;
+    }
+    if (p_m != NULL)
+	*p_m = m_found;
+    return cl_found;
+}
+
+/*
+ * Lookup a class or object method by name.  If v_type is VAR_CLASS, then
+ * lookup a class method and if it is VAR_OBJECT, then lookup a object method.
+ *
+ * Returns a pointer to the method structure if variable is found.
+ * Otherwise returns NULL.  The method variable index is set in "*idx".
+ */
+    ufunc_T *
+method_lookup(
+    class_T	*cl,
+    vartype_T	v_type,
+    char_u	*name,
+    size_t	namelen,
+    int		*idx)
+{
+    if (v_type == VAR_CLASS)
+	return class_method_lookup(cl, name, namelen, idx);
+    else
+	return object_method_lookup(cl, name, namelen, idx);
+}
+
+/*
+ * Return TRUE if current context "cctx_arg" is inside class "cl".
+ * Return FALSE if not.
+ */
+    int
+inside_class(cctx_T *cctx_arg, class_T *cl)
+{
+    for (cctx_T *cctx = cctx_arg; cctx != NULL; cctx = cctx->ctx_outer)
+	if (cctx->ctx_ufunc != NULL
+			&& class_instance_of(cctx->ctx_ufunc->uf_class, cl))
+	    return TRUE;
+    return FALSE;
+}
+
+/*
+ * Return TRUE if object/class variable "m" is read-only.
+ * Also give an error message.
+ */
+    int
+oc_var_check_ro(class_T *cl, ocmember_T *m)
+{
+    if (m->ocm_flags & (OCMFLAG_FINAL | OCMFLAG_CONST))
+    {
+	semsg(_(e_cannot_change_readonly_variable_str_in_class_str),
+		m->ocm_name.string, cl->class_name.string);
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/*
+ * Lock all the constant object variables.  Called after creating and
+ * initializing a new object.
+ */
+    void
+obj_lock_const_vars(object_T *obj)
+{
+    for (int i = 0; i < obj->obj_class->class_obj_member_count; i++)
+    {
+	ocmember_T *ocm = &obj->obj_class->class_obj_members[i];
+	if (ocm->ocm_flags & OCMFLAG_CONST)
+	{
+	    typval_T *mtv = ((typval_T *)(obj + 1)) + i;
+	    item_lock(mtv, DICT_MAXNEST, TRUE, TRUE);
+	}
+    }
+}
+
+/*
+ * Create a new instance of class "cl"
+ */
+    object_T *
+alloc_object(class_T *cl)
+{
+    object_T	*obj;
+    int		sz;
+
+    if (cl == NULL)
+	return NULL;
+
+    sz = sizeof(object_T) + cl->class_obj_member_count * sizeof(typval_T);
+    obj = alloc_clear(sz);
+    if (obj == NULL)
+	return NULL;
+
+    obj->obj_class = cl;
+    ++cl->class_refcount;
+    obj->obj_refcount = 1;
+    object_created(obj);
+
+    // When creating an enum value object, initialize the name and ordinal
+    // object variables.
+    if (IS_ENUM(cl))
+	enum_set_internal_obj_vars(cl, obj);
+
+    return obj;
+}
+
+/*
+ * Make a copy of an object.
+ */
+    void
+copy_object(typval_T *from, typval_T *to)
+{
+    if (from->vval.v_object == NULL)
+	to->vval.v_object = NULL;
+    else
+    {
+	to->vval.v_object = from->vval.v_object;
+	++to->vval.v_object->obj_refcount;
+    }
+}
+
+/*
+ * Make a copy of a class.
+ */
+    void
+copy_class(typval_T *from, typval_T *to)
+{
+    if (from->vval.v_class == NULL)
+	to->vval.v_class = NULL;
+    else
+    {
+	to->vval.v_class = from->vval.v_class;
+	++to->vval.v_class->class_refcount;
+    }
+}
+
+/*
+ * Free the class "cl" and its contents.
+ */
+    static void
+class_free(class_T *cl)
+{
+    // Freeing what the class contains may recursively come back here.
+    // Clear "class_name" first, if it is NULL the class does not need to
+    // be freed.
+    MNV_CLEAR_STRING(cl->class_name);
+
+    class_unref(cl->class_extends);
+
+    for (int i = 0; i < cl->class_interface_count; ++i)
+    {
+	mnv_free(((char_u **)cl->class_interfaces)[i]);
+	if (cl->class_interfaces_cl[i] != NULL)
+	    class_unref(cl->class_interfaces_cl[i]);
+    }
+    mnv_free(cl->class_interfaces);
+    mnv_free(cl->class_interfaces_cl);
+
+    itf2class_T *next;
+    for (itf2class_T *i2c = cl->class_itf2class; i2c != NULL; i2c = next)
+    {
+	next = i2c->i2c_next;
+	mnv_free(i2c);
+    }
+
+    for (int i = 0; i < cl->class_class_member_count; ++i)
+    {
+	ocmember_T *m = &cl->class_class_members[i];
+	MNV_CLEAR_STRING(m->ocm_name);
+	mnv_free(m->ocm_init);
+	if (cl->class_members_tv != NULL)
+	    clear_tv(&cl->class_members_tv[i]);
+    }
+    mnv_free(cl->class_class_members);
+    mnv_free(cl->class_members_tv);
+
+    for (int i = 0; i < cl->class_obj_member_count; ++i)
+    {
+	ocmember_T *m = &cl->class_obj_members[i];
+	MNV_CLEAR_STRING(m->ocm_name);
+	mnv_free(m->ocm_init);
+    }
+    mnv_free(cl->class_obj_members);
+
+    for (int i = 0; i < cl->class_class_function_count; ++i)
+    {
+	ufunc_T *uf = cl->class_class_functions[i];
+	// For an enum class, the constructor function names are cleared.  Set
+	// the name back, so that clearing the function will work properly.
+	if (IS_ENUM(cl) && IS_CONSTRUCTOR_METHOD(uf) && *uf->uf_name == NUL)
+	    STRCPY(uf->uf_name, "new");
+	func_clear_free(uf, FALSE);
+    }
+    mnv_free(cl->class_class_functions);
+
+    for (int i = 0; i < cl->class_obj_method_count; ++i)
+    {
+	ufunc_T *uf = cl->class_obj_methods[i];
+	func_clear_free(uf, FALSE);
+    }
+    mnv_free(cl->class_obj_methods);
+
+    clear_type_list(&cl->class_type_list);
+
+    class_cleared(cl);
+
+    mnv_free(cl);
+}
+
+/*
+ * Returns the number of references from the class members of class "cl" to cl"
+ * itself.
+ */
+    static int
+class_get_selfrefs(class_T *cl)
+{
+    int		self_refs = 0;
+    typval_T	*tv;
+
+    for (int i = 0; i < cl->class_class_member_count; ++i)
+    {
+	tv = &cl->class_members_tv[i];
+	if (tv->v_type == VAR_OBJECT && tv->vval.v_object != NULL
+		&& tv->vval.v_object->obj_class == cl
+		&& (tv->vval.v_object->obj_refcount == 1
+		    || (IS_ENUM(cl) && tv->vval.v_object->obj_refcount == 2)))
+	    self_refs++;
+    }
+
+    return self_refs;
+}
+
+/*
+ * Returns TRUE if enum "cl" can be freed.  An enum can be freed, if the enum
+ * values are no longer referenced and the "values" class member is also not
+ * referenced.
+ */
+    static int
+can_free_enum(class_T *cl)
+{
+    for (int i = 0; i < cl->class_class_member_count; ++i)
+    {
+	typval_T	*tv = &cl->class_members_tv[i];
+	ocmember_T	*ocm = &cl->class_class_members[i];
+
+	if (tv->v_type != VAR_OBJECT && tv->v_type != VAR_LIST)
+	    // In an enum, the first set of class members are the enum values.
+	    // Followed by the "values" member which is a List of enum values.
+	    // If all of those members are no longer referenced, then the enum
+	    // may be freed.
+	    return TRUE;
+
+	if (tv->v_type == VAR_LIST
+		&& tv->vval.v_list->lv_type->tt_member->tt_type == VAR_OBJECT
+		&& tv->vval.v_list->lv_type->tt_member->tt_class == cl
+		&& STRCMP(ocm->ocm_name.string, "values") == 0)
+	{
+	    // "values" class member is referenced outside
+	    if (tv->vval.v_list->lv_refcount > 1)
+		return FALSE;
+	    break;
+	}
+
+	if (tv->vval.v_object->obj_refcount > 2)
+	    // enum value is referenced outside
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*
+ * Returns TRUE if class "cl" has no references outside of the references from
+ * it's own class members and can be freed.  If it is an enum, then checks
+ * whether the enum values and the "values" members are referenced elsewhere.
+ */
+    static int
+can_free_class(class_T *cl)
+{
+    int		can_free = FALSE;
+    int		self_refs = 0;
+
+    if (IS_ENUM(cl) && !can_free_enum(cl))
+	return FALSE;
+
+    if (cl->class_refcount > 0)
+	self_refs = class_get_selfrefs(cl);
+
+    // If the class is no longer referenced or only referenced from it's own
+    // class member, then it can be freed.
+    if (cl->class_refcount <= 0 || cl->class_refcount == self_refs)
+	can_free = TRUE;
+
+    return can_free;
+}
+
+/*
+ * Unreference a class.  Free it when the reference count goes down to zero.
+ */
+    void
+class_unref(class_T *cl)
+{
+    if (cl == NULL)
+	return;
+
+    --cl->class_refcount;
+
+    if (cl->class_name.string == NULL)
+	return;
+
+    if (can_free_class(cl))
+	class_free(cl);
+}
+
+/*
+ * Go through the list of all classes and free items without "copyID".
+ */
+    int
+class_free_nonref(int copyID)
+{
+    int		did_free = FALSE;
+
+    for (class_T *cl = first_class; cl != NULL; cl = next_nonref_class)
+    {
+	next_nonref_class = cl->class_next_used;
+	if ((cl->class_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
+	{
+	    // Free the class and items it contains.
+	    class_free(cl);
+	    did_free = TRUE;
+	}
+    }
+
+    next_nonref_class = NULL;
+    return did_free;
+}
+
+    int
+set_ref_in_classes(int copyID)
+{
+    for (class_T *cl = first_class; cl != NULL; cl = cl->class_next_used)
+	set_ref_in_item_class(cl, copyID, NULL, NULL, NULL);
+
+    return FALSE;
+}
+
+static object_T *first_object = NULL;
+
+/*
+ * Call this function when an object has been created.  It will be added to the
+ * list headed by "first_object".
+ */
+    void
+object_created(object_T *obj)
+{
+    if (first_object != NULL)
+    {
+	obj->obj_next_used = first_object;
+	first_object->obj_prev_used = obj;
+    }
+    first_object = obj;
+}
+
+/*
+ * 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".
+ */
+    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)
+	obj->obj_prev_used->obj_next_used = obj->obj_next_used;
+    else if (first_object == obj)
+	first_object = obj->obj_next_used;
+}
+
+/*
+ * Free the contents of an object ignoring the reference count.
+ */
+    static void
+object_free_contents(object_T *obj)
+{
+    class_T *cl = obj->obj_class;
+
+    if (!cl)
+	return;
+
+    // Avoid a recursive call, it can happen if "obj" has a circular reference.
+    obj->obj_refcount = INT_MAX;
+
+    // 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);
+}
+
+    static void
+object_free_object(object_T *obj)
+{
+    class_T *cl = obj->obj_class;
+
+    if (!cl)
+	return;
+
+    // Remove from the list headed by "first_object".
+    object_cleared(obj);
+
+    mnv_free(obj);
+    class_unref(cl);
+}
+
+    static void
+object_free(object_T *obj)
+{
+    if (in_free_unref_items)
+	return;
+
+    object_free_contents(obj);
+    object_free_object(obj);
+}
+
+/*
+ * Unreference an object.
+ */
+    void
+object_unref(object_T *obj)
+{
+    if (obj != NULL && --obj->obj_refcount <= 0)
+	object_free(obj);
+}
+
+/*
+ * Go through the list of all objects and free items without "copyID".
+ */
+    int
+object_free_nonref(int copyID)
+{
+    int		did_free = FALSE;
+
+    for (object_T *obj = first_object; obj != NULL; obj = obj->obj_next_used)
+    {
+	if ((obj->obj_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
+	{
+	    // Free the object contents.  Object itself will be freed later.
+	    object_free_contents(obj);
+	    did_free = TRUE;
+	}
+    }
+
+    return did_free;
+}
+
+    void
+object_free_items(int copyID)
+{
+    object_T	*obj_next;
+
+    for (object_T *obj = first_object; obj != NULL; obj = obj_next)
+    {
+	obj_next = obj->obj_next_used;
+	if ((obj->obj_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
+	    object_free_object(obj);
+    }
+}
+
+/*
+ * Output message which takes a variable name and the class that defines it.
+ * "cl" is that class where the name was found. Search "cl"'s hierarchy to
+ * find the defining class.
+ */
+    void
+emsg_var_cl_define(char *msg, char_u *name, size_t len, class_T *cl)
+{
+    ocmember_T	*m;
+    class_T	*cl_def = class_defining_member(cl, name, len, &m);
+    if (cl_def != NULL)
+	semsg(_(msg), m->ocm_name.string, cl_def->class_name.string);
+    else
+	emsg(_(e_internal_error_please_report_a_bug));
+}
+
+/*
+ * Echo a class or object method not found message.
+ */
+    void
+method_not_found_msg(class_T *cl, vartype_T v_type, char_u *name, size_t len)
+{
+    char_u *method_name = mnv_strnsave(name, len);
+    if ((v_type == VAR_OBJECT)
+	    && (class_method_idx(cl, name, len) >= 0))
+    {
+	// If this is a class method, then give a different error
+	if (*name == '_')
+	    semsg(_(e_cannot_access_protected_method_str), method_name);
+	else
+	    semsg(_(e_class_method_str_accessible_only_using_class_str),
+		    method_name, cl->class_name.string);
+    }
+    else if ((v_type == VAR_CLASS)
+	    && (object_method_idx(cl, name, len) >= 0))
+    {
+	// If this is an object method, then give a different error
+	if (*name == '_')
+	    semsg(_(e_cannot_access_protected_method_str), method_name);
+	else
+	    semsg(_(e_object_method_str_accessible_only_using_object_str),
+		    method_name, cl->class_name.string);
+    }
+    else
+	semsg(_(e_method_not_found_on_class_str_str), method_name,
+		cl->class_name.string);
+    mnv_free(method_name);
+}
+
+/*
+ * Echo a class or object member not found message.
+ */
+    void
+member_not_found_msg(class_T *cl, vartype_T v_type, char_u *name, size_t len)
+{
+    char_u *varname = len ? mnv_strnsave(name, len) : mnv_strsave(name);
+
+    if (v_type == VAR_OBJECT)
+    {
+	if (class_member_idx(cl, name, len) >= 0)
+	    semsg(_(e_class_variable_str_accessible_only_using_class_str),
+		    varname, cl->class_name.string);
+	else
+	    semsg(_(e_variable_not_found_on_object_str_str), varname,
+		    cl->class_name.string);
+    }
+    else
+    {
+	if (object_member_idx(cl, name, len) >= 0)
+	    semsg(_(e_object_variable_str_accessible_only_using_object_str),
+		    varname, cl->class_name.string);
+	else
+	{
+	    if (IS_ENUM(cl))
+		semsg(_(e_enum_value_str_not_found_in_enum_str),
+			varname, cl->class_name.string);
+	    else
+		semsg(_(e_class_variable_str_not_found_in_class_str),
+			varname, cl->class_name.string);
+	}
+    }
+    mnv_free(varname);
+}
+
+/*
+ * Compile all the class and object methods in "cl".
+ */
+    void
+defcompile_class(class_T *cl)
+{
+    for (int loop = 1; loop <= 2; ++loop)
+    {
+	int func_count = loop == 1 ? cl->class_class_function_count
+						: cl->class_obj_method_count;
+	for (int i = 0; i < func_count; i++)
+	{
+	    ufunc_T *ufunc = loop == 1 ? cl->class_class_functions[i]
+						: cl->class_obj_methods[i];
+	    // Don't compile abstract methods
+	    if (!IS_ABSTRACT_METHOD(ufunc))
+		defcompile_function(ufunc, cl);
+	}
+    }
+}
+
+/*
+ * Compile all the classes defined in the current script
+ */
+    void
+defcompile_classes_in_script(void)
+{
+    for (class_T *cl = first_class; cl != NULL; cl = cl->class_next_used)
+    {
+	if (eval_variable(cl->class_name.string, 0, 0, NULL, NULL,
+			EVAL_VAR_NOAUTOLOAD | EVAL_VAR_NO_FUNC) != FAIL)
+	    defcompile_class(cl);
+    }
+}
+
+/*
+ * Returns TRUE if "name" is the name of a class.  The typval for the class is
+ * returned in "rettv".
+ */
+    int
+is_class_name(char_u *name, typval_T *rettv)
+{
+    rettv->v_type = VAR_UNKNOWN;
+
+    if (eval_variable(name, 0, 0, rettv, NULL, EVAL_VAR_NOAUTOLOAD |
+						EVAL_VAR_NO_FUNC) != FAIL)
+	return rettv->v_type == VAR_CLASS;
+    return FALSE;
+}
+
+/*
+ * Calls the object builtin method "name" with arguments "argv".  The value
+ * returned by the builtin method is in "rettv".  Returns OK or FAIL.
+ */
+    static int
+object_call_builtin_method(
+    object_T		*obj,
+    class_builtin_T	builtin_method,
+    int			argc,
+    typval_T		*argv,
+    typval_T		*rettv)
+{
+    ufunc_T *uf;
+    int	    midx;
+
+    if (obj == NULL)
+	return FAIL;
+
+    uf = class_get_builtin_method(obj->obj_class, builtin_method, &midx);
+    if (uf == NULL)
+	return FAIL;
+
+    funccall_T  *fc = create_funccal(uf, rettv);
+    int		r;
+
+    if (fc == NULL)
+	return FAIL;
+
+    ++obj->obj_refcount;
+
+    r = call_def_function(uf, argc, argv, 0, NULL, obj, fc, rettv);
+
+    remove_funccal();
+
+    return r;
+}
+
+/*
+ * Calls the object "empty()" method and returns the method return value.  In
+ * case of an error, returns TRUE.
+ */
+    int
+object_empty(object_T *obj)
+{
+    typval_T	rettv;
+
+    if (object_call_builtin_method(obj, CLASS_BUILTIN_EMPTY, 0, NULL, &rettv)
+								== FAIL)
+	return TRUE;
+
+    return tv_get_bool(&rettv);
+}
+
+/*
+ * Use the object "len()" method to get an object length.  Returns 0 if the
+ * method is not found or there is an error.
+ */
+    int
+object_len(object_T *obj)
+{
+    typval_T	rettv;
+
+    if (object_call_builtin_method(obj, CLASS_BUILTIN_LEN, 0, NULL, &rettv)
+								== FAIL)
+	return 0;
+
+    return tv_to_number(&rettv);
+}
+
+/*
+ * Return TRUE when two objects have exactly the same values.
+ */
+    int
+object_equal(
+	object_T *o1,
+	object_T *o2,
+	int	ic)	// ignore case for strings
+{
+    class_T *cl1, *cl2;
+
+    if (o1 == o2)
+	return TRUE;
+    if (o1 == NULL || o2 == NULL)
+	return FALSE;
+
+    cl1 = o1->obj_class;
+    cl2 = o2->obj_class;
+
+    if (cl1 != cl2 || cl1 == NULL || cl2 == NULL)
+	return FALSE;
+
+    for (int i = 0; i < cl1->class_obj_member_count; ++i)
+	if (!tv_equal((typval_T *)(o1 + 1) + i, (typval_T *)(o2 + 1) + i, ic))
+	    return FALSE;
+
+    return TRUE;
+}
+
+/*
+ * Return a textual representation of object "obj".
+ * "obj" must not be NULL.
+ * May return NULL.
+ */
+    char_u *
+object2string(
+    object_T	*obj,
+    char_u	*numbuf,
+    int		copyID,
+    int		echo_style,
+    int		restore_copyID,
+    int		composite_val)
+{
+    typval_T	rettv;
+
+    if (object_call_builtin_method(obj, CLASS_BUILTIN_STRING, 0, NULL, &rettv)
+								== OK
+					&& rettv.vval.v_string != NULL)
+	return rettv.vval.v_string;
+
+    int		ok = OK;
+    class_T	*cl = obj->obj_class;
+    garray_T	ga;
+    ga_init2(&ga, 1, 50);
+
+    if (cl != NULL && IS_ENUM(cl))
+    {
+	GA_CONCAT_LITERAL(&ga, "enum ");
+	ga_concat_len(&ga, cl->class_name.string, cl->class_name.length);
+	char_u *enum_name = ((typval_T *)(obj + 1))->vval.v_string;
+	GA_CONCAT_LITERAL(&ga, ".");
+	ga_concat(&ga, enum_name);
+    }
+    else
+    {
+	GA_CONCAT_LITERAL(&ga, "object of ");
+	if (cl == NULL)
+	    GA_CONCAT_LITERAL(&ga, "[unknown]");
+	else
+	    ga_concat_len(&ga, cl->class_name.string, cl->class_name.length);
+    }
+    if (cl != NULL)
+    {
+	GA_CONCAT_LITERAL(&ga, " {");
+	for (int i = 0; i < cl->class_obj_member_count; ++i)
+	{
+	    if (i > 0)
+		GA_CONCAT_LITERAL(&ga, ", ");
+	    ocmember_T *m = &cl->class_obj_members[i];
+	    ga_concat_len(&ga, m->ocm_name.string, m->ocm_name.length);
+	    GA_CONCAT_LITERAL(&ga, ": ");
+	    char_u *tf = NULL;
+	    char_u *s = echo_string_core((typval_T *)(obj + 1) + i,
+					 &tf, numbuf, copyID, echo_style,
+					 restore_copyID, composite_val);
+	    if (s != NULL)
+		ga_concat(&ga, s);
+	    mnv_free(tf);
+	    if (s == NULL || did_echo_string_emsg)
+	    {
+		ok = FAIL;
+		break;
+	    }
+	    line_breakcheck();
+	}
+	GA_CONCAT_LITERAL(&ga, "}");
+    }
+    if (ok == FAIL)
+    {
+	mnv_free(ga.ga_data);
+	return NULL;
+    }
+    ga_append(&ga, NUL);
+    return (char_u *)ga.ga_data;
+}
+
+/*
+ * Return TRUE when the class "cl", its base class or one of the implemented
+ * interfaces matches the class "other_cl".
+ */
+    int
+class_instance_of(class_T *cl, class_T *other_cl)
+{
+    if (cl == other_cl)
+	return TRUE;
+
+    // Recursively check the base classes.
+    for (; cl != NULL; cl = cl->class_extends)
+    {
+	if (cl == other_cl)
+	    return TRUE;
+	// Check the implemented interfaces and the super interfaces
+	for (int i = cl->class_interface_count - 1; i >= 0; --i)
+	{
+	    class_T	*intf = cl->class_interfaces_cl[i];
+	    while (intf != NULL)
+	    {
+		if (intf == other_cl)
+		    return TRUE;
+		// check the super interfaces
+		intf = intf->class_extends;
+	    }
+	}
+    }
+
+    return FALSE;
+}
+
+/*
+ * "instanceof(object, classinfo, ...)" function
+ */
+    void
+f_instanceof(typval_T *argvars, typval_T *rettv)
+{
+    typval_T	*object_tv = &argvars[0];
+    typval_T	*classinfo_tv = &argvars[1];
+    class_T	*c;
+
+    rettv->vval.v_number = VVAL_FALSE;
+
+    if (check_for_object_arg(argvars, 0) == FAIL
+	    || check_for_class_or_typealias_args(argvars, 1) == FAIL)
+	return;
+
+    if (object_tv->vval.v_object == NULL)
+    {
+	if (classinfo_tv->vval.v_class == NULL)
+	    // consider null_object as an instance of null_class
+	    rettv->vval.v_number = VVAL_TRUE;
+	return;
+    }
+
+    for (; classinfo_tv->v_type != VAR_UNKNOWN; ++classinfo_tv)
+    {
+	if (classinfo_tv->v_type == VAR_TYPEALIAS)
+	    c = classinfo_tv->vval.v_typealias->ta_type->tt_class;
+	else
+	    c = classinfo_tv->vval.v_class;
+
+	if (class_instance_of(object_tv->vval.v_object->obj_class, c))
+	{
+	    rettv->vval.v_number = VVAL_TRUE;
+	    return;
+	}
+    }
+}
+
+#endif // FEAT_EVAL