cmd/cmd.cpp

#include "cmd.h"

// Initiator.
// Size is the number of commands, default callback is called if a command is
// not found.
Cmd::Cmd(size_t size, CmdFunction defaultCallback) {
	m_size = size;
	m_commands = (const char **)malloc(sizeof(const char *) * m_size);
	m_functions = (CmdFunction *)malloc(sizeof(CmdFunction) * m_size);
	m_defaultFunction = defaultCallback;
}

// Return the set size of the command array.
size_t Cmd::GetSize() { return m_size; }

// Add a command to the function list. If list is too full, false is returned.
bool Cmd::AddCmd(const char *cmd, CmdFunction function) {
	if (m_nextCmd >= m_size) {
		return false;
	}

	m_commands[m_nextCmd] = cmd;
	m_functions[m_nextCmd] = function;

	m_nextCmd++;
	return true;
}

// Get array of all commands.
const char **Cmd::GetCmds() { return m_commands; }

// Rather or not we echo back to serial characters received.
bool Cmd::GetEcho() { return m_echo; }
void Cmd::SetEcho(bool echo) { m_echo = echo; }

// The separator for command parsing.
const char *Cmd::GetSeparator() { return m_separator; }
void Cmd::SetSeparator(const char *separator) { m_separator = separator; }

// Indicates the command line.
const char *Cmd::GetLineIndicator() { return m_line_indicator; }
void Cmd::SetLineIndicator(const char *line_indicator) {
	m_line_indicator = line_indicator;
}

// Buffer size configuration.
size_t Cmd::GetBufferSize() { return m_buffer_size; }
void Cmd::SetBufferSize(size_t bufferSize) { m_buffer_size = bufferSize; }

// Return current buffer.
const char *Cmd::GetBuffer() { return m_buffer; }

// Resets the buffer and prints
void Cmd::StartNewBuffer() {
	free(m_buffer);
	m_buffer = NULL;
	Serial.print(m_line_indicator);
}

// Print the current buffer.
void Cmd::PrintBuffer() {
	// If we're processing a command, do not print.
	if (m_processing) {
		return;
	}
	// Set the last character in the buffer to null to terminate.
	m_buffer[m_buffer_read] = '\0';
	// Print indicator and buffer.
	Serial.print(m_line_indicator);
	Serial.print(m_buffer);
	// Move cursor to correct location.
	for (unsigned int i = m_buffer_cursor; i < m_buffer_read; i++) {
		Serial.write('\x08');
	}
}

// Parse next token.
char *Cmd::Parse() { return strtok(NULL, m_separator); }

// Print help for the current command.
void Cmd::PrintHelp() {
	// Copy buffer to token buffer.
	m_bufferTok = (char *)malloc(m_buffer_size);
	strcpy(m_bufferTok, m_buffer);

	// Tokenize buffer based on separator and get first token being the command.
	char *cmd = strtok(m_bufferTok, m_separator);

	// Printing help means the command line is currently the line we're on.
	Serial.println();

	// To prevent buffer printing during a command execution.
	m_processing = true;
	// Look for the command that matches.
	bool foundCmd = false;
	// Only scan for command if specified.
	if (cmd != NULL) {
		for (unsigned int i = 0; i < m_size && m_commands[i] != NULL; i++) {
			if (strcasecmp_P(cmd, m_commands[i]) == 0) {
				// If command matches, call its function and tell it we're asking for
				// help.
				m_functions[i](this, cmd, true);
				foundCmd = true;
				break;
			}
		}
	}

	// If command wasn't found, call the default callback and tell it we're asking
	// for help.
	if (!foundCmd) {
		Serial.println("Calling default function");
		m_defaultFunction(this, cmd, true);
	}
	m_processing = false;

	// Print the buffer now that help was provided.
	Serial.println();
	PrintBuffer();

	// Free memory used by the token buffer.
	free(m_bufferTok);
	m_bufferTok = NULL;
}

// Parse buffer for command.
void Cmd::ParseBuffer() {
	// Copy buffer to token buffer.
	m_bufferTok = (char *)malloc(m_buffer_size);
	strcpy(m_bufferTok, m_buffer);

	// Tokenize buffer based on separator and get first token being the command.
	char *cmd = strtok(m_bufferTok, m_separator);

	// To prevent buffer printing during a command execution.
	m_processing = true;
	// Look for the command that matches.
	bool foundCmd = false;
	// Only scan for command if specified.
	if (cmd != NULL) {
		for (unsigned int i = 0; i < m_size && m_commands[i] != NULL; i++) {
			if (strcasecmp_P(cmd, m_commands[i]) == 0) {
				// If command matches, call its function.
				m_functions[i](this, cmd, false);
				foundCmd = true;
				break;
			}
		}
	}

	// If command wasn't found, call the default callback.
	if (!foundCmd) {
		m_defaultFunction(this, cmd, false);
	}
	m_processing = false;

	// Free memory used by the token buffer.
	free(m_bufferTok);
	m_bufferTok = NULL;
}

// Main command loop, call in the main loop of your program.
void Cmd::Loop() {
	// If no serial data is available, we do not have anything to process.
	if (!Serial.available()) {
		return;
	}

	// If buffer is not allocated, let's reset.
	if (m_buffer == NULL) {
		m_buffer = (char *)malloc(m_buffer_size);
		m_buffer_read = 0;
		m_buffer_cursor = 0;
	}

	// Start read and read all available data in serial RX buffer.
	bool receivedEndLine = false;
	size_t availableData = Serial.available();
	for (size_t i = 1; i <= availableData; i++) {
		char byteRead = Serial.read();

		// If we're currently reading an escape character, verify state.
		if (m_buffer_reading_esc == 1) {
			// If we get the bracket, we need to move on to the next step in reading
			// an escape character. Otherwise, we are not reading an escape character.
			if (byteRead == '[') {
				m_buffer_reading_esc = 2;
				continue;
			} else {
				m_buffer_reading_esc = 0;
			}
		} else if (m_buffer_reading_esc == 2) {
			// Process escape character read.
			switch (byteRead) {
				case 'D':  // Move cursor left
					m_buffer_reading_esc = 0;
					if (m_buffer_cursor <= 0) {
						continue;
					}
					m_buffer_cursor--;
					Serial.print("\x1b[D");
					break;
				case 'C':  // Move cursor right
					m_buffer_reading_esc = 0;
					if (m_buffer_cursor >= m_buffer_read) {
						continue;
					}
					m_buffer_cursor++;
					Serial.print("\x1b[C");
					break;

				default:
					m_buffer_reading_esc = 0;
					break;
			}
			continue;
		}

		// Check if ascii byte.
		bool is_ascii = byteRead >= 32 && byteRead <= 126;

		// If we're to echo and its an ascii byte, send the byte we read back to the
		// serial console.
		if (m_echo && is_ascii) {
			Serial.write(byteRead);
		}

		// If escape character received, move into escape reading mode.
		if (byteRead == '\x1b') {
			m_buffer_reading_esc = 1;
			continue;
		}

		// If backspace or delete key.
		if (byteRead == 8 || byteRead == 127) {
			// Only perform character delete if buffer exists and cursor isn't at
			// start.
			if (m_buffer_read != 0 && m_buffer_cursor != 0) {
				// If cursor isn't at start, we need to re-print the line minus the
				// character deleted.
				if (m_buffer_cursor != m_buffer_read) {
					// Create new buffer for re-writing current buffer.
					char *buf = (char *)malloc(m_buffer_size);
					// Copy current buffer.
					strcpy(buf, m_buffer);
					// Clear the line from the curosr.
					Serial.print("\x08\x1b[1P");
					// Print and re-write the buffer from the cursor location minus
					// character deleted.
					for (unsigned int i = m_buffer_cursor; i < m_buffer_read; i++) {
						m_buffer[i - 1] = buf[i];
						Serial.write(buf[i]);
					}
					// Now that the buffer has been re-written, we can free the buffer.
					free(buf);
					// Move the cursor back to where it should be.
					for (unsigned int i = m_buffer_cursor; i < m_buffer_read; i++) {
						Serial.write('\x08');
					}
				} else {
					// As we're not deleting from cursor location, we can just clear the
					// last character via this escape.
					Serial.print("\x08\x1b[K");
				}
				// Wipe the last byte in the buffer in both cases.
				m_buffer_read--;
				m_buffer_cursor--;
				m_buffer[m_buffer_read] = '\0';
			}
		}

		// If begining of line requested.
		if (byteRead == 1) {
			// Move cursor to beginning of line.
			while (m_buffer_cursor != 0) {
				m_buffer_cursor--;
				Serial.print("\x1b[D");
			}
		}

		// If end of line requested.
		if (byteRead == 5) {
			// Move cursor to end of line.
			while (m_buffer_cursor < m_buffer_read) {
				m_buffer_cursor++;
				Serial.print("\x1b[C");
			}
		}

		// If cancel or exit received.
		if (byteRead == 3 || byteRead == 4) {
			Serial.println();
			// Clear buffer, start new line,
			StartNewBuffer();
			continue;
		}

		// Clear screen.
		if (byteRead == 12) {
			m_buffer[m_buffer_read] = '\0';
			Serial.print("\x1b[H\x1b[J");
			PrintBuffer();
		}

		// If end of line.
		if (byteRead == '\r') {
			receivedEndLine = true;
			break;
		}

		// If help requested, print it.
		if (byteRead == '?') {
			m_buffer[m_buffer_read] = '\0';
			PrintHelp();
			continue;
		}

		// If not ascii, we only allow ascii on the cli.
		if (!is_ascii) {
			continue;
		}

		// If cursor is not at end, we need to write new byte where cursor is.
		if (m_buffer_cursor != m_buffer_read) {
			// Copy current buffer for re-write.
			char *buf = (char *)malloc(m_buffer_size);
			strcpy(buf, m_buffer);
			// Set current cursor location byte to newly read byte.
			m_buffer[m_buffer_cursor] = byteRead;
			// From cursor location, re-write the buffer with old buffer data and
			// print to the console.
			for (unsigned int i = m_buffer_cursor; i < m_buffer_read; i++) {
				m_buffer[i + 1] = buf[i];
				Serial.write(buf[i]);
			}
			// We're done with the buffer copy.
			free(buf);
			// Move cursor back to where it was.
			for (unsigned int i = m_buffer_cursor; i < m_buffer_read; i++) {
				Serial.write('\x08');
			}
		} else {
			// Otherwise new byte can go to end of buffer.
			m_buffer[m_buffer_read] = byteRead;
		}
		// We read a new byte, increment the cursor location and read index.
		m_buffer_read++;
		m_buffer_cursor++;

		// If we're going to overflow next read, we need to stop that.
		if (m_buffer_read >= (m_buffer_size - 1)) {
			Serial.println("Data too large.");

			// Clear the buffer, and start new line.
			StartNewBuffer();

			// Clear the serial buffer.
			while (Serial.available()) {
				Serial.read();
			}
			break;
		}
	}

	// If we received end of line in read, we need to parse the buffer.
	if (receivedEndLine) {
		// Print new line and null terminate the buffer.
		Serial.println();
		m_buffer[m_buffer_read] = '\0';

		// Parse the buffer.
		ParseBuffer();

		// Start new buffer.
		StartNewBuffer();
	}
}