MicroStateMachine::input() returns whether a result was set now

 * this means that QRegSpecMachine::input() no longer has to return
   a dummy QRegister in parse-only mode.
   This saves an unnecessary QRegister table lookup and speeds up
   parsing.
 * QRegSpecMachine can now be easily extended to behave differently
   when returning a Q-Register, e.g. simply returning NULL if a register
   does not exist, or returning a register by prefix.
   This is important for some planned commands.
 * StateExpectQReg::got_register() now gets a QRegister *.
   It can theoretically be NULL - still we don't have to check
   for NULL in most cases since NULL is only passed in parse-only mode.

9 files changed, 113 insertions, 114 deletions

diff --git a/src/cmdline.cpp b/src/cmdline.cpp
index 06cb76e..1a3447f 100644
--- a/src/cmdline.cpp
+++ b/src/cmdline.cpp
@@ -815,12 +815,12 @@ symbol_complete(SymbolList &list, const gchar *symbol, gchar completed)
  * Q-Register <q>.
  */
 State *
-StateSaveCmdline::got_register(QRegister &reg)
+StateSaveCmdline::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
-	reg.undo_set_string();
-	reg.set_string(last_cmdline.str, last_cmdline.len);
+	reg->undo_set_string();
+	reg->set_string(last_cmdline.str, last_cmdline.len);
 
 	return &States::start;
 }
diff --git a/src/cmdline.h b/src/cmdline.h
index 40a794a..9a78605 100644
--- a/src/cmdline.h
+++ b/src/cmdline.h
@@ -107,7 +107,7 @@ public:
 	StateSaveCmdline() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 namespace States {
diff --git a/src/parser.cpp b/src/parser.cpp
index 3db7115..9ef3d64 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -303,8 +303,8 @@ StringBuildingMachine::reset(void)
 	undo.push_var(toctl) = false;
 }
 
-gchar *
-StringBuildingMachine::input(gchar chr)
+bool
+StringBuildingMachine::input(gchar chr, gchar *&result)
 {
 	QRegister *reg;
 
@@ -325,7 +325,7 @@ StringBuildingMachine::input(gchar chr)
 		undo.push_var(toctl) = false;
 	} else if (chr == '^') {
 		undo.push_var(toctl) = true;
-		return NULL;
+		return false;
 	}
 
 MICROSTATE_START;
@@ -339,25 +339,29 @@ MICROSTATE_START;
 		goto StateEscaped;
 	}
 
-	return NULL;
+	return false;
 
 StateLower:
 	set(StateStart);
 
-	if (chr != CTL_KEY('V'))
-		return String::chrdup(g_ascii_tolower(chr));
+	if (chr != CTL_KEY('V')) {
+		result = String::chrdup(g_ascii_tolower(chr));
+		return true;
+	}
 
 	undo.push_var(mode) = MODE_LOWER;
-	return NULL;
+	return false;
 
 StateUpper:
 	set(StateStart);
 
-	if (chr != CTL_KEY('W'))
-		return String::chrdup(g_ascii_toupper(chr));
+	if (chr != CTL_KEY('W')) {
+		result = String::chrdup(g_ascii_toupper(chr));
+		return true;
+	}
 
 	undo.push_var(mode) = MODE_UPPER;
-	return NULL;
+	return false;
 
 StateCtlE:
 	switch (g_ascii_toupper(chr)) {
@@ -373,49 +377,49 @@ StateCtlE:
 		undo.push_obj(qregspec_machine) = new QRegSpecMachine;
 		set(&&StateCtlEU);
 		break;
-	default: {
-		gchar *ret = (gchar *)g_malloc(3);
+	default:
+		result = (gchar *)g_malloc(3);
 
 		set(StateStart);
-		ret[0] = CTL_KEY('E');
-		ret[1] = chr;
-		ret[2] = '\0';
-		return ret;
-	}
+		result[0] = CTL_KEY('E');
+		result[1] = chr;
+		result[2] = '\0';
+		return true;
 	}
 
-	return NULL;
+	return false;
 
 StateCtlENum:
-	reg = qregspec_machine->input(chr);
-	if (!reg)
-		return NULL;
+	if (!qregspec_machine->input(chr, reg))
+		return false;
 
 	undo.push_obj(qregspec_machine) = NULL;
 	set(StateStart);
-	return g_strdup(expressions.format(reg->get_integer()));
+	result = g_strdup(expressions.format(reg->get_integer()));
+	return true;
 
 StateCtlEU:
-	reg = qregspec_machine->input(chr);
-	if (!reg)
-		return NULL;
+	if (!qregspec_machine->input(chr, reg))
+		return false;
 
 	undo.push_obj(qregspec_machine) = NULL;
 	set(StateStart);
-	return String::chrdup((gchar)reg->get_integer());
+	result = String::chrdup((gchar)reg->get_integer());
+	return true;
 
 StateCtlEQ:
-	reg = qregspec_machine->input(chr);
-	if (!reg)
-		return NULL;
+	if (!qregspec_machine->input(chr, reg))
+		return false;
 
 	undo.push_obj(qregspec_machine) = NULL;
 	set(StateStart);
-	return reg->get_string();
+	result = reg->get_string();
+	return true;
 
 StateEscaped:
 	set(StateStart);
-	return String::chrdup(chr);
+	result = String::chrdup(chr);
+	return true;
 }
 
 StringBuildingMachine::~StringBuildingMachine()
@@ -486,8 +490,7 @@ StateExpectString::custom(gchar chr)
 	 * String building characters
 	 */
 	if (string_building) {
-		insert = machine.input(chr);
-		if (!insert)
+		if (!machine.input(chr, insert))
 			return this;
 	} else {
 		insert = String::chrdup(chr);
diff --git a/src/parser.h b/src/parser.h
index feffb95..9858136 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -101,7 +101,7 @@ public:
 		set(StateStart);
 	}
 
-	virtual Type input(gchar chr) = 0;
+	virtual bool input(gchar chr, Type &result) = 0;
 };
 
 /* avoid circular dependency on qregisters.h */
@@ -126,7 +126,7 @@ public:
 
 	void reset(void);
 
-	gchar *input(gchar chr);
+	bool input(gchar chr, gchar *&result);
 };
 
 /*
diff --git a/src/qregisters.cpp b/src/qregisters.cpp
index ef47627..a82e219 100644
--- a/src/qregisters.cpp
+++ b/src/qregisters.cpp
@@ -796,8 +796,8 @@ QRegSpecMachine::reset(void)
 	name = NULL;
 }
 
-QRegister *
-QRegSpecMachine::input(gchar chr)
+bool
+QRegSpecMachine::input(gchar chr, QRegister *&result)
 {
 	gchar *insert;
 
@@ -811,13 +811,13 @@ MICROSTATE_START;
 		goto done;
 	}
 
-	return NULL;
+	return false;
 
 StateFirstChar:
 	undo.push_str(name) = (gchar *)g_malloc(3);
 	name[0] = g_ascii_toupper(chr);
 	set(&&StateSecondChar);
-	return NULL;
+	return false;
 
 StateSecondChar:
 	name[1] = g_ascii_toupper(chr);
@@ -837,37 +837,34 @@ StateString:
 	}
 
 	if (mode > MODE_NORMAL)
-		return NULL;
+		return false;
 
-	insert = string_machine.input(chr);
-	if (!insert)
-		return NULL;
+	if (!string_machine.input(chr, insert))
+		return false;
 
 	undo.push_str(name);
 	String::append(name, insert);
 	g_free(insert);
-	return NULL;
+	return false;
 
 done:
-	if (mode > MODE_NORMAL)
-		/*
-		 * FIXME: currently we must return *some* register
-		 * since got_register() expects one
-		 */
-		return QRegisters::globals["0"];
+	if (mode > MODE_NORMAL) {
+		result = NULL;
+		return true;
+	}
 
 	QRegisterTable &table = is_local ? *QRegisters::locals
-					 : QRegisters::globals;
-	QRegister *reg = table[name];
+	                                 : QRegisters::globals;
 
-	if (!reg) {
+	result = table[name];
+	if (!result) {
 		if (!initialize)
 			throw InvalidQRegError(name, is_local);
-		reg = table.insert(name);
-		table.undo_remove(reg);
+		result = table.insert(name);
+		table.undo_remove(result);
 	}
 
-	return reg;
+	return true;
 }
 
 /*
@@ -882,13 +879,13 @@ StateExpectQReg::StateExpectQReg(bool initialize) : State(), machine(initialize)
 State *
 StateExpectQReg::custom(gchar chr)
 {
-	QRegister *reg = machine.input(chr);
+	QRegister *reg;
 
-	if (!reg)
+	if (!machine.input(chr, reg))
 		return this;
 	machine.reset();
 
-	return got_register(*reg);
+	return got_register(reg);
 }
 
 /*$
@@ -898,11 +895,11 @@ StateExpectQReg::custom(gchar chr)
  * stack.
  */
 State *
-StatePushQReg::got_register(QRegister &reg)
+StatePushQReg::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
-	QRegisters::stack.push(reg);
+	QRegisters::stack.push(*reg);
 
 	return &States::start;
 }
@@ -921,11 +918,11 @@ StatePushQReg::got_register(QRegister &reg)
  * Memory is reclaimed on command-line termination.
  */
 State *
-StatePopQReg::got_register(QRegister &reg)
+StatePopQReg::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
-	if (!QRegisters::stack.pop(reg))
+	if (!QRegisters::stack.pop(*reg))
 		throw Error("Q-Register stack is empty");
 
 	return &States::start;
@@ -947,10 +944,10 @@ StatePopQReg::got_register(QRegister &reg)
  * The command fails if <file> could not be read.
  */
 State *
-StateEQCommand::got_register(QRegister &reg)
+StateEQCommand::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::loadqreg);
-	register_argument = &reg;
+	register_argument = reg;
 	return &States::loadqreg;
 }
 
@@ -987,10 +984,10 @@ StateLoadQReg::got_file(const gchar *filename)
  * characters are enabled by default.
  */
 State *
-StateEPctCommand::got_register(QRegister &reg)
+StateEPctCommand::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::saveqreg);
-	register_argument = &reg;
+	register_argument = reg;
 	return &States::saveqreg;
 }
 
@@ -1024,7 +1021,7 @@ StateSaveQReg::got_file(const gchar *filename)
  * The command fails for undefined registers.
  */
 State *
-StateQueryQReg::got_register(QRegister &reg)
+StateQueryQReg::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
@@ -1032,16 +1029,16 @@ StateQueryQReg::got_register(QRegister &reg)
 
 	if (eval_colon()) {
 		/* Query Q-Register string size */
-		expressions.push(reg.get_string_size());
+		expressions.push(reg->get_string_size());
 	} else if (expressions.args() > 0) {
 		/* Query character from Q-Register string */
-		gint c = reg.get_character(expressions.pop_num_calc());
+		gint c = reg->get_character(expressions.pop_num_calc());
 		if (c < 0)
 			throw RangeError('Q');
 		expressions.push(c);
 	} else {
 		/* Query integer */
-		expressions.push(reg.get_integer());
+		expressions.push(reg->get_integer());
 	}
 
 	return &States::start;
@@ -1074,10 +1071,10 @@ StateQueryQReg::got_register(QRegister &reg)
  * is desired.
  */
 State *
-StateCtlUCommand::got_register(QRegister &reg)
+StateCtlUCommand::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::setqregstring_nobuilding);
-	register_argument = &reg;
+	register_argument = reg;
 	return &States::setqregstring_nobuilding;
 }
 
@@ -1092,10 +1089,10 @@ StateCtlUCommand::got_register(QRegister &reg)
  * characters \fBenabled\fP.
  */
 State *
-StateEUCommand::got_register(QRegister &reg)
+StateEUCommand::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::setqregstring_building);
-	register_argument = &reg;
+	register_argument = reg;
 	return &States::setqregstring_building;
 }
 
@@ -1159,13 +1156,13 @@ StateSetQRegString::done(const gchar *str)
  * Specifying an undefined <q> yields an error.
  */
 State *
-StateGetQRegString::got_register(QRegister &reg)
+StateGetQRegString::got_register(QRegister *reg)
 {
 	gchar *str;
 
 	BEGIN_EXEC(&States::start);
 
-	str = reg.get_string();
+	str = reg->get_string();
 	if (*str) {
 		interface.ssm(SCI_BEGINUNDOACTION);
 		interface.ssm(SCI_ADDTEXT, strlen(str), (sptr_t)str);
@@ -1197,14 +1194,14 @@ StateGetQRegString::got_register(QRegister &reg)
  * The register is defined if it does not exist.
  */
 State *
-StateSetQRegInteger::got_register(QRegister &reg)
+StateSetQRegInteger::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
 	expressions.eval();
 	if (expressions.args() || expressions.num_sign < 0) {
-		reg.undo_set_integer();
-		reg.set_integer(expressions.pop_num_calc());
+		reg->undo_set_integer();
+		reg->set_integer(expressions.pop_num_calc());
 
 		if (eval_colon())
 			expressions.push(SUCCESS);
@@ -1225,15 +1222,15 @@ StateSetQRegInteger::got_register(QRegister &reg)
  * <q> will be defined if it does not exist.
  */
 State *
-StateIncreaseQReg::got_register(QRegister &reg)
+StateIncreaseQReg::got_register(QRegister *reg)
 {
 	tecoInt res;
 
 	BEGIN_EXEC(&States::start);
 
-	reg.undo_set_integer();
-	res = reg.get_integer() + expressions.pop_num_calc();
-	expressions.push(reg.set_integer(res));
+	reg->undo_set_integer();
+	res = reg->get_integer() + expressions.pop_num_calc();
+	expressions.push(reg->set_integer(res));
 
 	return &States::start;
 }
@@ -1261,12 +1258,12 @@ StateIncreaseQReg::got_register(QRegister &reg)
  * not modify the executed code.
  */
 State *
-StateMacro::got_register(QRegister &reg)
+StateMacro::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::start);
 
 	/* don't create new local Q-Registers if colon modifier is given */
-	reg.execute(!eval_colon());
+	reg->execute(!eval_colon());
 
 	return &States::start;
 }
@@ -1314,7 +1311,7 @@ StateMacroFile::got_file(const gchar *filename)
  * Register <q> will be created if it is undefined.
  */
 State *
-StateCopyToQReg::got_register(QRegister &reg)
+StateCopyToQReg::got_register(QRegister *reg)
 {
 	tecoInt from, len;
 	Sci_TextRange tr;
@@ -1352,11 +1349,11 @@ StateCopyToQReg::got_register(QRegister &reg)
 	interface.ssm(SCI_GETTEXTRANGE, 0, (sptr_t)&tr);
 
 	if (eval_colon()) {
-		reg.undo_append_string();
-		reg.append_string(tr.lpstrText);
+		reg->undo_append_string();
+		reg->append_string(tr.lpstrText);
 	} else {
-		reg.undo_set_string();
-		reg.set_string(tr.lpstrText);
+		reg->undo_set_string();
+		reg->set_string(tr.lpstrText);
 	}
 	g_free(tr.lpstrText);
 
diff --git a/src/qregisters.h b/src/qregisters.h
index dc560b8..f4f944d 100644
--- a/src/qregisters.h
+++ b/src/qregisters.h
@@ -389,7 +389,7 @@ public:
 
 	void reset(void);
 
-	QRegister *input(gchar chr);
+	bool input(gchar chr, QRegister *&result);
 };
 
 /*
@@ -409,12 +409,12 @@ private:
 	State *custom(gchar chr);
 
 protected:
-	virtual State *got_register(QRegister &reg) = 0;
+	virtual State *got_register(QRegister *reg) = 0;
 };
 
 class StatePushQReg : public StateExpectQReg {
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StatePopQReg : public StateExpectQReg {
@@ -422,7 +422,7 @@ public:
 	StatePopQReg() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateEQCommand : public StateExpectQReg {
@@ -430,7 +430,7 @@ public:
 	StateEQCommand() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateLoadQReg : public StateExpectFile {
@@ -440,7 +440,7 @@ private:
 
 class StateEPctCommand : public StateExpectQReg {
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateSaveQReg : public StateExpectFile {
@@ -450,7 +450,7 @@ private:
 
 class StateQueryQReg : public StateExpectQReg {
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateCtlUCommand : public StateExpectQReg {
@@ -458,7 +458,7 @@ public:
 	StateCtlUCommand() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateEUCommand : public StateExpectQReg {
@@ -466,7 +466,7 @@ public:
 	StateEUCommand() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateSetQRegString : public StateExpectString {
@@ -483,7 +483,7 @@ private:
 
 class StateGetQRegString : public StateExpectQReg {
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateSetQRegInteger : public StateExpectQReg {
@@ -491,7 +491,7 @@ public:
 	StateSetQRegInteger() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateIncreaseQReg : public StateExpectQReg {
@@ -499,12 +499,12 @@ public:
 	StateIncreaseQReg() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateMacro : public StateExpectQReg {
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 class StateMacroFile : public StateExpectFile {
@@ -517,7 +517,7 @@ public:
 	StateCopyToQReg() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 namespace States {
diff --git a/src/search.cpp b/src/search.cpp
index 8013385..447f16e 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -221,8 +221,7 @@ StateSearch::class2regexp(MatchState &state, const gchar *&pattern,
 			break;
 
 		case STATE_ANYQ:
-			reg = qreg_machine.input(*pattern);
-			if (!reg)
+			if (!qreg_machine.input(*pattern, reg))
 				break;
 			qreg_machine.reset();
 
diff --git a/src/spawn.cpp b/src/spawn.cpp
index b5d64e9..a6ca4e8 100644
--- a/src/spawn.cpp
+++ b/src/spawn.cpp
@@ -482,10 +482,10 @@ gerror:
  * The register <q> is defined if it does not already exist.
  */
 State *
-StateEGCommand::got_register(QRegister &reg)
+StateEGCommand::got_register(QRegister *reg)
 {
 	BEGIN_EXEC(&States::executecommand);
-	undo.push_var(register_argument) = &reg;
+	undo.push_var(register_argument) = reg;
 	return &States::executecommand;
 }
 
diff --git a/src/spawn.h b/src/spawn.h
index 6ae84fd..e65f18e 100644
--- a/src/spawn.h
+++ b/src/spawn.h
@@ -60,7 +60,7 @@ public:
 	StateEGCommand() : StateExpectQReg(true) {}
 
 private:
-	State *got_register(QRegister &reg);
+	State *got_register(QRegister *reg);
 };
 
 namespace States {