vim: src/ex_eval.c comparison

comparison src/ex_eval.c @ 18779:8f05b3cf8557 v8.1.2379

patch 8.1.2379: using old C style comments Commit: https://github.com/vim/vim/commit/217e1b8359447f5550dcb0d1ee43380a90c253c5 Author: Bram Moolenaar <Bram@vim.org> Date: Sun Dec 1 21:41:28 2019 +0100 patch 8.1.2379: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 01 Dec 2019 21:45:04 +0100
parents	1febd1aa9930
children	2bdc2e1f6e1f

comparison

equal deleted inserted replaced

-:2182f82b04e4
+:8f05b3cf8557
 * && did_emsg is not a reliant test that the exception currently being thrown
 * is an error exception.)  -  The macros can be defined as expressions checking
 * for a variable that is allowed to be changed during execution of a script.
 */
 #if 0
-/* Expressions used for testing during the development phase. */
+// Expressions used for testing during the development phase.
 # define THROW_ON_ERROR		(!eval_to_number("$VIMNOERRTHROW"))
 # define THROW_ON_INTERRUPT	(!eval_to_number("$VIMNOINTTHROW"))
 # define THROW_TEST
 #else
-/* Values used for the Vim release. */
+// Values used for the Vim release.
 # define THROW_ON_ERROR		TRUE
 # define THROW_ON_ERROR_TRUE
 # define THROW_ON_INTERRUPT	TRUE
 # define THROW_ON_INTERRUPT_TRUE
 #endif
 * commands are still reported.
 */
 int
 aborted_in_try(void)
 {
-/* This function is only called after an error.  In this case, "force_abort"
+// This function is only called after an error.  In this case, "force_abort"
-* determines whether searching for finally clauses is necessary. */
+// determines whether searching for finally clauses is necessary.
 return force_abort;
 }
 /*
 * cause_errthrow(): Cause a throw of an error exception if appropriate.
 * exception currently being thrown to prevent it from being caught.  Just
 * execute finally clauses and terminate.
 */
 if (did_throw)
 {
-	/* When discarding an interrupt exception, reset got_int to prevent the
+	// When discarding an interrupt exception, reset got_int to prevent the
-	 * same interrupt being converted to an exception again and discarding
+	// same interrupt being converted to an exception again and discarding
-	 * the error exception we are about to throw here. */
+	// the error exception we are about to throw here.
 	if (current_exception->type == ET_INTERRUPT)
 	    got_int = FALSE;
 	discard_current_exception();
 }
 		    *plist = elem;
 		    if (plist == msg_list || severe)
 		    {
 			char	    *tmsg;
-			/* Skip the extra "Vim " prefix for message "E458". */
+			// Skip the extra "Vim " prefix for message "E458".
 			tmsg = elem->msg;
 			if (STRNCMP(tmsg, "Vim E", 5) == 0
 				&& VIM_ISDIGIT(tmsg[5])
 				&& VIM_ISDIGIT(tmsg[6])
 				&& VIM_ISDIGIT(tmsg[7])
 {
 	cause_abort = FALSE;
 	force_abort = TRUE;
 }
-/* If no exception is to be thrown or the conversion should be done after
+// If no exception is to be thrown or the conversion should be done after
-* returning to a previous invocation of do_one_cmd(), do nothing. */
+// returning to a previous invocation of do_one_cmd(), do nothing.
 if (msg_list == NULL || *msg_list == NULL)
 	return;
 if (throw_exception(*msg_list, ET_ERROR, cmdname) == FAIL)
 	free_msglist(*msg_list);
 * is being thrown, do nothing (for compatibility of non-EH scripts).
 */
 if (!got_int || (trylevel == 0 && !did_throw))
 	return FALSE;
-#ifdef THROW_TEST	/* avoid warning for condition always true */
+#ifdef THROW_TEST	// avoid warning for condition always true
 if (!THROW_ON_INTERRUPT)
 {
 	/*
 	 * The interrupt aborts everything except for executing finally clauses.
 	 * Discard any user or error or interrupt exception currently being
 	if (did_throw)
 	{
 	    if (current_exception->type == ET_INTERRUPT)
 		return FALSE;
-	    /* An interrupt exception replaces any user or error exception. */
+	    // An interrupt exception replaces any user or error exception.
 	    discard_current_exception();
 	}
 	if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL)
 	    do_throw(cstack);
 }
 	    if (ret == NULL)
 		return ret;
 	    val = ret + 4;
 	}
-	/* msg_add_fname may have been used to prefix the message with a file
+	// msg_add_fname may have been used to prefix the message with a file
-	 * name in quotes.  In the exception value, put the file name in
+	// name in quotes.  In the exception value, put the file name in
-	 * parentheses and move it to the end. */
+	// parentheses and move it to the end.
 	for (p = mesg; ; p++)
 	{
 	    if (*p == NUL
 		    || (*p == 'E'
 			&& VIM_ISDIGIT(p[1])
 				&& (p[3] == ':'
 				    || (VIM_ISDIGIT(p[3])
 					&& p[4] == ':'))))))
 	    {
 		if (*p == NUL || p == mesg)
-		    STRCAT(val, mesg);  /* 'E123' missing or at beginning */
+		    STRCAT(val, mesg);  // 'E123' missing or at beginning
 		else
 		{
-		    /* '"filename" E123: message text' */
+		    // '"filename" E123: message text'
 		    if (mesg[0] != '"' || p-2 < &mesg[1] ||
 			    p[-2] != '"' || p[-1] != ' ')
-			/* "E123:" is part of the file name. */
+			// "E123:" is part of the file name.
 			continue;
 		    STRCAT(val, p);
 		    p[-2] = NUL;
 		    sprintf((char *)(val + STRLEN(p)), " (%s)", &mesg[1]);
 excp = ALLOC_ONE(except_T);
 if (excp == NULL)
 	goto nomem;
 if (type == ET_ERROR)
-	/* Store the original message and prefix the exception value with
+	// Store the original message and prefix the exception value with
-	 * "Vim:" or, if a command name is given, "Vim(cmdname):". */
+	// "Vim:" or, if a command name is given, "Vim(cmdname):".
 	excp->messages = (struct msglist *)value;
 excp->value = get_exception_string(value, type, cmdname, &should_free);
 if (excp->value == NULL && should_free)
 	goto nomem;
 if (p_verbose >= 13 || debug_break_level > 0)
 {
 	int	save_msg_silent = msg_silent;
 	if (debug_break_level > 0)
-	    msg_silent = FALSE;		/* display messages */
+	    msg_silent = FALSE;		// display messages
 	else
 	    verbose_enter();
 	++no_wait_return;
 	if (debug_break_level > 0 || *p_vfile == NUL)
-	    msg_scroll = TRUE;	    /* always scroll up, don't overwrite */
+	    msg_scroll = TRUE;	    // always scroll up, don't overwrite
 	smsg(_("Exception thrown: %s"), excp->value);
-	msg_puts("\n");   /* don't overwrite this either */
+	msg_puts("\n");   // don't overwrite this either
 	if (debug_break_level > 0 || *p_vfile == NUL)
 	    cmdline_row = msg_row;
 	--no_wait_return;
 	if (debug_break_level > 0)
 {
 	int	save_msg_silent = msg_silent;
 	saved_IObuff = vim_strsave(IObuff);
 	if (debug_break_level > 0)
-	    msg_silent = FALSE;		/* display messages */
+	    msg_silent = FALSE;		// display messages
 	else
 	    verbose_enter();
 	++no_wait_return;
 	if (debug_break_level > 0 || *p_vfile == NUL)
-	    msg_scroll = TRUE;	    /* always scroll up, don't overwrite */
+	    msg_scroll = TRUE;	    // always scroll up, don't overwrite
 	smsg(was_finished
 		    ? _("Exception finished: %s")
 		    : _("Exception discarded: %s"),
 		excp->value);
-	msg_puts("\n");   /* don't overwrite this either */
+	msg_puts("\n");   // don't overwrite this either
 	if (debug_break_level > 0 || *p_vfile == NUL)
 	    cmdline_row = msg_row;
 	--no_wait_return;
 	if (debug_break_level > 0)
 	    msg_silent = save_msg_silent;
 	else
 	    vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name);
 	set_vim_var_string(VV_THROWPOINT, IObuff, -1);
 }
 else
-	/* throw_name not set on an exception from a command that was typed. */
+	// throw_name not set on an exception from a command that was typed.
 	set_vim_var_string(VV_THROWPOINT, NULL, -1);
 if (p_verbose >= 13 || debug_break_level > 0)
 {
 	int	save_msg_silent = msg_silent;
 	if (debug_break_level > 0)
-	    msg_silent = FALSE;		/* display messages */
+	    msg_silent = FALSE;		// display messages
 	else
 	    verbose_enter();
 	++no_wait_return;
 	if (debug_break_level > 0 || *p_vfile == NUL)
-	    msg_scroll = TRUE;	    /* always scroll up, don't overwrite */
+	    msg_scroll = TRUE;	    // always scroll up, don't overwrite
 	smsg(_("Exception caught: %s"), excp->value);
-	msg_puts("\n");   /* don't overwrite this either */
+	msg_puts("\n");   // don't overwrite this either
 	if (debug_break_level > 0 || *p_vfile == NUL)
 	    cmdline_row = msg_row;
 	--no_wait_return;
 	if (debug_break_level > 0)
 		vim_snprintf((char *)IObuff, IOSIZE, "%s",
 						    caught_stack->throw_name);
 	    set_vim_var_string(VV_THROWPOINT, IObuff, -1);
 	}
 	else
-	    /* throw_name not set on an exception from a command that was
+	    // throw_name not set on an exception from a command that was
-	     * typed. */
+	    // typed.
 	    set_vim_var_string(VV_THROWPOINT, NULL, -1);
 }
 else
 {
 	set_vim_var_string(VV_EXCEPTION, NULL, -1);
 	set_vim_var_string(VV_THROWPOINT, NULL, -1);
 }
-/* Discard the exception, but use the finish message for 'verbose'. */
+// Discard the exception, but use the finish message for 'verbose'.
 discard_exception(excp, TRUE);
 }
 /*
 * Flags specifying the message displayed by report_pending.
 	    mesg = _("%s made pending");
 	    break;
 	case RP_RESUME:
 	    mesg = _("%s resumed");
 	    break;
-	/* case RP_DISCARD: */
+	// case RP_DISCARD:
 	default:
 	    mesg = _("%s discarded");
 	    break;
 }
 	    break;
 	case CSTP_FINISH:
 	    s = ":finish";
 	    break;
 	case CSTP_RETURN:
-	    /* ":return" command producing value, allocated */
+	    // ":return" command producing value, allocated
 	    s = (char *)get_return_cmd(value);
 	    break;
 	default:
 	    if (pending & CSTP_THROW)
 	    }
 	    else if ((pending & CSTP_ERROR) && (pending & CSTP_INTERRUPT))
 		s = _("Error and interrupt");
 	    else if (pending & CSTP_ERROR)
 		s = _("Error");
-	    else /* if (pending & CSTP_INTERRUPT) */
+	    else // if (pending & CSTP_INTERRUPT)
 		s = _("Interrupt");
 }
 save_msg_silent = msg_silent;
 if (debug_break_level > 0)
-	msg_silent = FALSE;	/* display messages */
+	msg_silent = FALSE;	// display messages
 ++no_wait_return;
-msg_scroll = TRUE;		/* always scroll up, don't overwrite */
+msg_scroll = TRUE;		// always scroll up, don't overwrite
 smsg(mesg, s);
-msg_puts("\n");   /* don't overwrite this either */
+msg_puts("\n");   // don't overwrite this either
 cmdline_row = msg_row;
 --no_wait_return;
 if (debug_break_level > 0)
 	msg_silent = save_msg_silent;
 	{
 	    if (result)
 		cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
 	}
 	else
-	    /* set TRUE, so this conditional will never get active */
+	    // set TRUE, so this conditional will never get active
 	    cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
 }
 }
 /*
 	}
 	eap->errmsg = N_("E584: :elseif after :else");
 	skip = TRUE;
 }
-/* if skipping or the ":if" was TRUE, reset ACTIVE, otherwise set it */
+// if skipping or the ":if" was TRUE, reset ACTIVE, otherwise set it
 if (skip || cstack->cs_flags[cstack->cs_idx] & CSF_TRUE)
 {
 	if (eap->errmsg == NULL)
 	    cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
-	skip = TRUE;	/* don't evaluate an ":elseif" */
+	skip = TRUE;	// don't evaluate an ":elseif"
 }
 else
 	cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE;
 /*
 }
 if (eap->cmdidx == CMD_elseif)
 {
 	result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip);
-	/* When throwing error exceptions, we want to throw always the first
+	// When throwing error exceptions, we want to throw always the first
-	 * of several errors in a row.  This is what actually happens when
+	// of several errors in a row.  This is what actually happens when
-	 * a conditional error was detected above and there is another failure
+	// a conditional error was detected above and there is another failure
-	 * when parsing the expression.  Since the skip flag is set in this
+	// when parsing the expression.  Since the skip flag is set in this
-	 * case, the parsing error will be ignored by emsg(). */
+	// case, the parsing error will be ignored by emsg().
 	if (!skip && !error)
 	{
 	    if (result)
 		cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
 	    else
 		cstack->cs_flags[cstack->cs_idx] = 0;
 	}
 	else if (eap->errmsg == NULL)
-	    /* set TRUE, so this conditional will never get active */
+	    // set TRUE, so this conditional will never get active
 	    cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
 }
 else
 	cstack->cs_flags[cstack->cs_idx] |= CSF_ELSE;
 }
 	    /*
 	     * ":for var in list-expr"
 	     */
 	    if ((cstack->cs_lflags & CSL_HAD_LOOP) != 0)
 	    {
-		/* Jumping here from a ":continue" or ":endfor": use the
+		// Jumping here from a ":continue" or ":endfor": use the
-		 * previously evaluated list. */
+		// previously evaluated list.
 		fi = cstack->cs_forinfo[cstack->cs_idx];
 		error = FALSE;
 	    }
 	    else
 	    {
-		/* Evaluate the argument and get the info in a structure. */
+		// Evaluate the argument and get the info in a structure.
 		fi = eval_for_line(eap->arg, &error, &eap->nextcmd, skip);
 		cstack->cs_forinfo[cstack->cs_idx] = fi;
 	    }
-	    /* use the element at the start of the list and advance */
+	    // use the element at the start of the list and advance
 	    if (!error && fi != NULL && !skip)
 		result = next_for_item(fi, eap->arg);
 	    else
 		result = FALSE;
 	    cstack->cs_lflags ^= CSL_HAD_LOOP;
 	}
 	else
 	{
 	    cstack->cs_lflags &= ~CSL_HAD_LOOP;
-	    /* If the ":while" evaluates to FALSE or ":for" is past the end of
+	    // If the ":while" evaluates to FALSE or ":for" is past the end of
-	     * the list, show the debug prompt at the ":endwhile"/":endfor" as
+	    // the list, show the debug prompt at the ":endwhile"/":endfor" as
-	     * if there was a ":break" in a ":while"/":for" evaluating to
+	    // if there was a ":break" in a ":while"/":for" evaluating to
-	     * TRUE. */
+	    // TRUE.
 	    if (!skip && !error)
 		cstack->cs_flags[cstack->cs_idx] |= CSF_TRUE;
 	}
 }
 }
 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
 	eap->errmsg = N_("E586: :continue without :while or :for");
 else
 {
-	/* Try to find the matching ":while".  This might stop at a try
+	// Try to find the matching ":while".  This might stop at a try
-	 * conditional not in its finally clause (which is then to be executed
+	// conditional not in its finally clause (which is then to be executed
-	 * next).  Therefor, inactivate all conditionals except the ":while"
+	// next).  Therefor, inactivate all conditionals except the ":while"
-	 * itself (if reached). */
+	// itself (if reached).
 	idx = cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
 	if (idx >= 0 && (cstack->cs_flags[idx] & (CSF_WHILE | CSF_FOR)))
 	{
 	    rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
 	    /*
 	     * Set CSL_HAD_CONT, so do_cmdline() will jump back to the
 	     * matching ":while".
 	     */
-	    cstack->cs_lflags |= CSL_HAD_CONT;	/* let do_cmdline() handle it */
+	    cstack->cs_lflags |= CSL_HAD_CONT;	// let do_cmdline() handle it
 	}
 	else
 	{
-	    /* If a try conditional not in its finally clause is reached first,
+	    // If a try conditional not in its finally clause is reached first,
-	     * make the ":continue" pending for execution at the ":endtry". */
+	    // make the ":continue" pending for execution at the ":endtry".
 	    cstack->cs_pending[idx] = CSTP_CONTINUE;
 	    report_make_pending(CSTP_CONTINUE, NULL);
 	}
 }
 }
 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
 	eap->errmsg = N_("E587: :break without :while or :for");
 else
 {
-	/* Inactivate conditionals until the matching ":while" or a try
+	// Inactivate conditionals until the matching ":while" or a try
-	 * conditional not in its finally clause (which is then to be
+	// conditional not in its finally clause (which is then to be
-	 * executed next) is found.  In the latter case, make the ":break"
+	// executed next) is found.  In the latter case, make the ":break"
-	 * pending for execution at the ":endtry". */
+	// pending for execution at the ":endtry".
 	idx = cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, TRUE);
 	if (idx >= 0 && !(cstack->cs_flags[idx] & (CSF_WHILE | CSF_FOR)))
 	{
 	    cstack->cs_pending[idx] = CSTP_BREAK;
 	    report_make_pending(CSTP_BREAK, NULL);
 else
 {
 	fl =  cstack->cs_flags[cstack->cs_idx];
 	if (!(fl & csf))
 	{
-	    /* If we are in a ":while" or ":for" but used the wrong endloop
+	    // If we are in a ":while" or ":for" but used the wrong endloop
-	     * command, do not rewind to the next enclosing ":for"/":while". */
+	    // command, do not rewind to the next enclosing ":for"/":while".
 	    if (fl & CSF_WHILE)
 		eap->errmsg = _("E732: Using :endfor with :while");
 	    else if (fl & CSF_FOR)
 		eap->errmsg = _("E733: Using :endwhile with :for");
 	}
 	{
 	    if (!(fl & CSF_TRY))
 		eap->errmsg = e_endif;
 	    else if (fl & CSF_FINALLY)
 		eap->errmsg = e_endtry;
-	    /* Try to find the matching ":while" and report what's missing. */
+	    // Try to find the matching ":while" and report what's missing.
 	    for (idx = cstack->cs_idx; idx > 0; --idx)
 	    {
 		fl =  cstack->cs_flags[idx];
 		if ((fl & CSF_TRY) && !(fl & CSF_FINALLY))
 		{
-		    /* Give up at a try conditional not in its finally clause.
+		    // Give up at a try conditional not in its finally clause.
-		     * Ignore the ":endwhile"/":endfor". */
+		    // Ignore the ":endwhile"/":endfor".
 		    eap->errmsg = err;
 		    return;
 		}
 		if (fl & csf)
 		    break;
 	    }
-	    /* Cleanup and rewind all contained (and unclosed) conditionals. */
+	    // Cleanup and rewind all contained (and unclosed) conditionals.
 	    (void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
 	    rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
 	}
 	/*
 {
 	emsg(_(e_argreq));
 	value = NULL;
 }
-/* On error or when an exception is thrown during argument evaluation, do
+// On error or when an exception is thrown during argument evaluation, do
-* not throw. */
+// not throw.
 if (!eap->skip && value != NULL)
 {
 	if (throw_exception(value, ET_USER, NULL) == FAIL)
 	    vim_free(value);
 	else
 	if (!(cstack->cs_flags[idx] & CSF_CAUGHT))
 	{
 	    if (cstack->cs_flags[idx] & CSF_ACTIVE)
 		cstack->cs_flags[idx] |= CSF_THROWN;
 	    else
-		/* THROWN may have already been set for a catchable exception
+		// THROWN may have already been set for a catchable exception
-		 * that has been discarded.  Ensure it is reset for the new
+		// that has been discarded.  Ensure it is reset for the new
-		 * exception. */
+		// exception.
 		cstack->cs_flags[idx] &= ~CSF_THROWN;
 	}
 	cstack->cs_flags[idx] &= ~CSF_ACTIVE;
 	cstack->cs_exception[idx] = current_exception;
 }
 #if 0
-/* TODO: Add optimization below.  Not yet done because of interface
+// TODO: Add optimization below.  Not yet done because of interface
-* problems to eval.c and ex_cmds2.c. (Servatius) */
+// problems to eval.c and ex_cmds2.c. (Servatius)
 else
 {
 	/*
 	 * There are no catch clauses to check or finally clauses to execute.
 	 * End the current script or function.  The exception will be rethrown
 	skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
 		&& !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE));
 	if (!skip)
 	{
-	    /* Set ACTIVE and TRUE.  TRUE means that the corresponding ":catch"
+	    // Set ACTIVE and TRUE.  TRUE means that the corresponding ":catch"
-	     * commands should check for a match if an exception is thrown and
+	    // commands should check for a match if an exception is thrown and
-	     * that the finally clause needs to be executed. */
+	    // that the finally clause needs to be executed.
 	    cstack->cs_flags[cstack->cs_idx] |= CSF_ACTIVE | CSF_TRUE;
 	    /*
 	     * ":silent!", even when used in a try conditional, disables
 	     * displaying of error messages and conversion of errors to
 }
 else
 {
 	if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
 	{
-	    /* Report what's missing if the matching ":try" is not in its
+	    // Report what's missing if the matching ":try" is not in its
-	     * finally clause. */
+	    // finally clause.
 	    eap->errmsg = get_end_emsg(cstack);
 	    skip = TRUE;
 	}
 	for (idx = cstack->cs_idx; idx > 0; --idx)
 	    if (cstack->cs_flags[idx] & CSF_TRY)
 		break;
 	if (cstack->cs_flags[idx] & CSF_FINALLY)
 	{
-	    /* Give up for a ":catch" after ":finally" and ignore it.
+	    // Give up for a ":catch" after ":finally" and ignore it.
-	     * Just parse. */
+	    // Just parse.
 	    eap->errmsg = N_("E604: :catch after :finally");
 	    give_up = TRUE;
 	}
 	else
 	    rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
 						       &cstack->cs_looplevel);
 }
-if (ends_excmd(*eap->arg))	/* no argument, catch all errors */
+if (ends_excmd(*eap->arg))	// no argument, catch all errors
 {
 	pat = (char_u *)".*";
 	end = NULL;
 	eap->nextcmd = find_nextcmd(eap->arg);
 }
 	    {
 		emsg(_(e_trailing));
 		return;
 	    }
-	    /* When debugging or a breakpoint was encountered, display the
+	    // When debugging or a breakpoint was encountered, display the
-	     * debug prompt (if not already done) before checking for a match.
+	    // debug prompt (if not already done) before checking for a match.
-	     * This is a helpful hint for the user when the regular expression
+	    // This is a helpful hint for the user when the regular expression
-	     * matching fails.  Handle a ">quit" debug command as if an
+	    // matching fails.  Handle a ">quit" debug command as if an
-	     * interrupt had occurred before the ":catch".  That is, discard
+	    // interrupt had occurred before the ":catch".  That is, discard
-	     * the original exception, replace it by an interrupt exception,
+	    // the original exception, replace it by an interrupt exception,
-	     * and don't catch it in this try block. */
+	    // and don't catch it in this try block.
 	    if (!dbg_check_skipped(eap) || !do_intthrow(cstack))
 	    {
-		/* Terminate the pattern and avoid the 'l' flag in 'cpoptions'
+		// Terminate the pattern and avoid the 'l' flag in 'cpoptions'
-		 * while compiling it. */
+		// while compiling it.
 		if (end != NULL)
 		{
 		    save_char = *end;
 		    *end = NUL;
 		}
 		save_cpo  = p_cpo;
 		p_cpo = (char_u *)"";
-		/* Disable error messages, it will make current_exception
+		// Disable error messages, it will make current_exception
-		 * invalid. */
+		// invalid.
 		++emsg_off;
 		regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
 		--emsg_off;
 		regmatch.rm_ic = FALSE;
 		if (end != NULL)
 	    }
 	}
 	if (caught)
 	{
-	    /* Make this ":catch" clause active and reset did_emsg, got_int,
+	    // Make this ":catch" clause active and reset did_emsg, got_int,
-	     * and did_throw.  Put the exception on the caught stack. */
+	    // and did_throw.  Put the exception on the caught stack.
 	    cstack->cs_flags[idx] |= CSF_ACTIVE | CSF_CAUGHT;
 	    did_emsg = got_int = did_throw = FALSE;
 	    catch_exception((except_T *)cstack->cs_exception[idx]);
-	    /* It's mandatory that the current exception is stored in the cstack
+	    // It's mandatory that the current exception is stored in the cstack
-	     * so that it can be discarded at the next ":catch", ":finally", or
+	    // so that it can be discarded at the next ":catch", ":finally", or
-	     * ":endtry" or when the catch clause is left by a ":continue",
+	    // ":endtry" or when the catch clause is left by a ":continue",
-	     * ":break", ":return", ":finish", error, interrupt, or another
+	    // ":break", ":return", ":finish", error, interrupt, or another
-	     * exception. */
+	    // exception.
 	    if (cstack->cs_exception[cstack->cs_idx] != current_exception)
 		internal_error("ex_catch()");
 	}
 	else
 	{
 	{
 	    eap->errmsg = get_end_emsg(cstack);
 	    for (idx = cstack->cs_idx - 1; idx > 0; --idx)
 		if (cstack->cs_flags[idx] & CSF_TRY)
 		    break;
-	    /* Make this error pending, so that the commands in the following
+	    // Make this error pending, so that the commands in the following
-	     * finally clause can be executed.  This overrules also a pending
+	    // finally clause can be executed.  This overrules also a pending
-	     * ":continue", ":break", ":return", or ":finish". */
+	    // ":continue", ":break", ":return", or ":finish".
 	    pending = CSTP_ERROR;
 	}
 	else
 	    idx = cstack->cs_idx;
 	if (cstack->cs_flags[idx] & CSF_FINALLY)
 	{
-	    /* Give up for a multiple ":finally" and ignore it. */
+	    // Give up for a multiple ":finally" and ignore it.
 	    eap->errmsg = N_("E607: multiple :finally");
 	    return;
 	}
 	rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
 						       &cstack->cs_looplevel);
 	 */
 	skip = !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
 	if (!skip)
 	{
-	    /* When debugging or a breakpoint was encountered, display the
+	    // When debugging or a breakpoint was encountered, display the
-	     * debug prompt (if not already done).  The user then knows that the
+	    // debug prompt (if not already done).  The user then knows that the
-	     * finally clause is executed. */
+	    // finally clause is executed.
 	    if (dbg_check_skipped(eap))
 	    {
-		/* Handle a ">quit" debug command as if an interrupt had
+		// Handle a ">quit" debug command as if an interrupt had
-		 * occurred before the ":finally".  That is, discard the
+		// occurred before the ":finally".  That is, discard the
-		 * original exception and replace it by an interrupt
+		// original exception and replace it by an interrupt
-		 * exception. */
+		// exception.
 		(void)do_intthrow(cstack);
 	    }
 	    /*
 	     * If there is a preceding catch clause and it caught the exception,
 		    pending |= did_throw ? CSTP_THROW : 0;
 		pending |= did_emsg  ? CSTP_ERROR     : 0;
 		pending |= got_int   ? CSTP_INTERRUPT : 0;
 		cstack->cs_pending[cstack->cs_idx] = pending;
-		/* It's mandatory that the current exception is stored in the
+		// It's mandatory that the current exception is stored in the
-		 * cstack so that it can be rethrown at the ":endtry" or be
+		// cstack so that it can be rethrown at the ":endtry" or be
-		 * discarded if the finally clause is left by a ":continue",
+		// discarded if the finally clause is left by a ":continue",
-		 * ":break", ":return", ":finish", error, interrupt, or another
+		// ":break", ":return", ":finish", error, interrupt, or another
-		 * exception.  When emsg() is called for a missing ":endif" or
+		// exception.  When emsg() is called for a missing ":endif" or
-		 * a missing ":endwhile"/":endfor" detected here, the
+		// a missing ":endwhile"/":endfor" detected here, the
-		 * exception will be discarded. */
+		// exception will be discarded.
 		if (did_throw && cstack->cs_exception[cstack->cs_idx]
 							 != current_exception)
 		    internal_error("ex_finally()");
 	    }
 	    !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
 	if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
 	{
 	    eap->errmsg = get_end_emsg(cstack);
-	    /* Find the matching ":try" and report what's missing. */
+	    // Find the matching ":try" and report what's missing.
 	    idx = cstack->cs_idx;
 	    do
 		--idx;
 	    while (idx > 0 && !(cstack->cs_flags[idx] & CSF_TRY));
 	    rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
 	    if (did_throw && (cstack->cs_flags[idx] & CSF_TRUE)
 		    && !(cstack->cs_flags[idx] & CSF_FINALLY))
 		rethrow = TRUE;
 	}
-	/* If there was no finally clause, show the user when debugging or
+	// If there was no finally clause, show the user when debugging or
-	 * a breakpoint was encountered that the end of the try conditional has
+	// a breakpoint was encountered that the end of the try conditional has
-	 * been reached: display the debug prompt (if not already done).  Do
+	// been reached: display the debug prompt (if not already done).  Do
-	 * this on normal control flow or when an exception was thrown, but not
+	// this on normal control flow or when an exception was thrown, but not
-	 * on an interrupt or error not converted to an exception or when
+	// on an interrupt or error not converted to an exception or when
-	 * a ":break", ":continue", ":return", or ":finish" is pending.  These
+	// a ":break", ":continue", ":return", or ":finish" is pending.  These
-	 * actions are carried out immediately.
+	// actions are carried out immediately.
-	 */
 	if ((rethrow || (!skip
 			&& !(cstack->cs_flags[idx] & CSF_FINALLY)
 			&& !cstack->cs_pending[idx]))
 		&& dbg_check_skipped(eap))
 	{
-	    /* Handle a ">quit" debug command as if an interrupt had occurred
+	    // Handle a ">quit" debug command as if an interrupt had occurred
-	     * before the ":endtry".  That is, throw an interrupt exception and
+	    // before the ":endtry".  That is, throw an interrupt exception and
-	     * set "skip" and "rethrow". */
+	    // set "skip" and "rethrow".
 	    if (got_int)
 	    {
 		skip = TRUE;
 		(void)do_intthrow(cstack);
-		/* The do_intthrow() call may have reset did_throw or
+		// The do_intthrow() call may have reset did_throw or
-		 * cstack->cs_pending[idx].*/
+		// cstack->cs_pending[idx].
 		rethrow = FALSE;
 		if (did_throw && !(cstack->cs_flags[idx] & CSF_FINALLY))
 		    rethrow = TRUE;
 	    }
 	}
 	    switch (pending)
 	    {
 		case CSTP_NONE:
 		    break;
-		/* Reactivate a pending ":continue", ":break", ":return",
+		// Reactivate a pending ":continue", ":break", ":return",
-		 * ":finish" from the try block or a catch clause of this try
+		// ":finish" from the try block or a catch clause of this try
-		 * conditional.  This is skipped, if there was an error in an
+		// conditional.  This is skipped, if there was an error in an
-		 * (unskipped) conditional command or an interrupt afterwards
+		// (unskipped) conditional command or an interrupt afterwards
-		 * or if the finally clause is present and executed a new error,
+		// or if the finally clause is present and executed a new error,
-		 * interrupt, throw, ":continue", ":break", ":return", or
+		// interrupt, throw, ":continue", ":break", ":return", or
-		 * ":finish". */
+		// ":finish".
 		case CSTP_CONTINUE:
 		    ex_continue(eap);
 		    break;
 		case CSTP_BREAK:
 		    ex_break(eap);
 		    break;
 		case CSTP_FINISH:
 		    do_finish(eap, FALSE);
 		    break;
-		/* When the finally clause was entered due to an error,
+		// When the finally clause was entered due to an error,
-		 * interrupt or throw (as opposed to a ":continue", ":break",
+		// interrupt or throw (as opposed to a ":continue", ":break",
-		 * ":return", or ":finish"), restore the pending values of
+		// ":return", or ":finish"), restore the pending values of
-		 * did_emsg, got_int, and did_throw.  This is skipped, if there
+		// did_emsg, got_int, and did_throw.  This is skipped, if there
-		 * was a new error, interrupt, throw, ":continue", ":break",
+		// was a new error, interrupt, throw, ":continue", ":break",
-		 * ":return", or ":finish".  in the finally clause. */
+		// ":return", or ":finish".  in the finally clause.
 		default:
 		    if (pending & CSTP_ERROR)
 			did_emsg = TRUE;
 		    if (pending & CSTP_INTERRUPT)
 			got_int = TRUE;
 		    break;
 	    }
 	}
 	if (rethrow)
-	    /* Rethrow the current exception (within this cstack). */
+	    // Rethrow the current exception (within this cstack).
 	    do_throw(cstack);
 }
 }
 /*
 	csp->pending = (did_emsg     ? CSTP_ERROR     : 0)
 		     | (got_int      ? CSTP_INTERRUPT : 0)
 		     | (did_throw    ? CSTP_THROW     : 0)
 		     | (need_rethrow ? CSTP_THROW     : 0);
-	/* If we are currently throwing an exception (did_throw), save it as
+	// If we are currently throwing an exception (did_throw), save it as
-	 * well.  On an error not yet converted to an exception, update
+	// well.  On an error not yet converted to an exception, update
-	 * "force_abort" and reset "cause_abort" (as do_errthrow() would do).
+	// "force_abort" and reset "cause_abort" (as do_errthrow() would do).
-	 * This is needed for the do_cmdline() call that is going to be made
+	// This is needed for the do_cmdline() call that is going to be made
-	 * for autocommand execution.  We need not save *msg_list because
+	// for autocommand execution.  We need not save *msg_list because
-	 * there is an extra instance for every call of do_cmdline(), anyway.
+	// there is an extra instance for every call of do_cmdline(), anyway.
-	 */
 	if (did_throw || need_rethrow)
 	{
 	    csp->exception = current_exception;
 	    current_exception = NULL;
 	}
 		cause_abort = FALSE;
 	    }
 	}
 	did_emsg = got_int = did_throw = need_rethrow = FALSE;
-	/* Report if required by the 'verbose' option or when debugging.  */
+	// Report if required by the 'verbose' option or when debugging.
 	report_make_pending(pending, csp->exception);
 }
 else
 {
 	csp->pending = CSTP_NONE;
 void
 leave_cleanup(cleanup_T *csp)
 {
 int		pending = csp->pending;
-if (pending == CSTP_NONE)	/* nothing to do */
+if (pending == CSTP_NONE)	// nothing to do
 	return;
-/* If there was an aborting error, an interrupt, or an uncaught exception
+// If there was an aborting error, an interrupt, or an uncaught exception
-* after the corresponding call to enter_cleanup(), discard what has been
+// after the corresponding call to enter_cleanup(), discard what has been
-* made pending by it.  Report this to the user if required by the
+// made pending by it.  Report this to the user if required by the
-* 'verbose' option or when debugging. */
+// 'verbose' option or when debugging.
 if (aborting() || need_rethrow)
 {
 	if (pending & CSTP_THROW)
-	    /* Cancel the pending exception (includes report). */
+	    // Cancel the pending exception (includes report).
 	    discard_exception((except_T *)csp->exception, FALSE);
 	else
 	    report_discard_pending(pending, NULL);
-	/* If an error was about to be converted to an exception when
+	// If an error was about to be converted to an exception when
-	 * enter_cleanup() was called, free the message list. */
+	// enter_cleanup() was called, free the message list.
 	if (msg_list != NULL)
 	    free_global_msglist();
 }
 /*
 	if (pending & CSTP_ERROR)
 	    did_emsg = TRUE;
 	if (pending & CSTP_INTERRUPT)
 	    got_int = TRUE;
 	if (pending & CSTP_THROW)
-	    need_rethrow = TRUE;    /* did_throw will be set by do_one_cmd() */
+	    need_rethrow = TRUE;    // did_throw will be set by do_one_cmd()
-	/* Report if required by the 'verbose' option or when debugging. */
+	// Report if required by the 'verbose' option or when debugging.
 	report_resume_pending(pending,
 		   (pending & CSTP_THROW) ? (void *)current_exception : NULL);
 }
 }
 		    default:
 			if (cstack->cs_flags[idx] & CSF_FINALLY)
 			{
 			    if (cstack->cs_pending[idx] & CSTP_THROW)
 			    {
-				/* Cancel the pending exception.  This is in the
+				// Cancel the pending exception.  This is in the
-				 * finally clause, so that the stack of the
+				// finally clause, so that the stack of the
-				 * caught exceptions is not involved. */
+				// caught exceptions is not involved.
 				discard_exception((except_T *)
 					cstack->cs_exception[idx],
 					FALSE);
 			    }
 			    else
 	    if (!(cstack->cs_flags[idx] & CSF_FINALLY))
 	    {
 		if ((cstack->cs_flags[idx] & CSF_ACTIVE)
 			&& (cstack->cs_flags[idx] & CSF_CAUGHT))
 		    finish_exception((except_T *)cstack->cs_exception[idx]);
-		/* Stop at this try conditional - except the try block never
+		// Stop at this try conditional - except the try block never
-		 * got active (because of an inactive surrounding conditional
+		// got active (because of an inactive surrounding conditional
-		 * or when the ":try" appeared after an error or interrupt or
+		// or when the ":try" appeared after an error or interrupt or
-		 * throw). */
+		// throw).
 		if (cstack->cs_flags[idx] & CSF_TRUE)
 		{
 		    if (searched_cond == 0 && !inclusive)
 			break;
 		    stop = TRUE;
 		}
 	    }
 	}
-	/* Stop on the searched conditional type (even when the surrounding
+	// Stop on the searched conditional type (even when the surrounding
-	 * conditional is not active or something has been made pending).
+	// conditional is not active or something has been made pending).
-	 * If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT,
+	// If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT,
-	 * check first whether "emsg_silent" needs to be restored. */
+	// check first whether "emsg_silent" needs to be restored.
 	if (cstack->cs_flags[idx] & searched_cond)
 	{
 	    if (!inclusive)
 		break;
 	    stop = TRUE;
 int
 has_loop_cmd(char_u *p)
 {
 int		len;
-/* skip modifiers, white space and ':' */
+// skip modifiers, white space and ':'
 for (;;)
 {
 	while (*p == ' ' || *p == '\t' || *p == ':')
 	    ++p;
 	len = modifier_len(p);
 	    || (p[0] == 'f' && p[1] == 'o' && p[2] == 'r'))
 	return TRUE;
 return FALSE;
 }
-#endif /* FEAT_EVAL */
+#endif // FEAT_EVAL

Mercurial > vim

comparison src/ex_eval.c @ 18779:8f05b3cf8557 v8.1.2379