Command_ to CMD_

src/text_editor/commands.cpp

@@ -203,7 +203,7 @@ void ReportDebugf(const char *fmt, ...) {
     RawAppendf(TraceBuffer, "%S\n", string);
 }
 
-void Command_CenterView() {
+void CMD_CenterView() {
     BSet set = GetBSet(LastActiveLayoutWindowID);
     Caret c = set.view->carets[0];
     Int front = GetFront(c);
@@ -214,7 +214,7 @@ void Command_CenterView() {
     if (xy.line > y) {
         set.view->scroll.y = (xy.line) * set.window->font->line_spacing - (size.y / 2);
     }
-} RegisterCommand(Command_CenterView, "");
+} RegisterCommand(CMD_CenterView, "");
 
 void MoveCursorByPageSize(Window *window, int direction, bool shift = false) {
     Assert(direction == DIR_UP || direction == DIR_DOWN);
@@ -421,17 +421,17 @@ BSet ExecBuild(String cmd) {
     return build;
 }
 
-void Command_SaveAll() {
+void CMD_SaveAll() {
     For(Buffers) {
         // NOTE: file_mod_time is only set when buffer got read or written to disk already so should be saved
         if (it->file_mod_time) {
             SaveBuffer(it);
         }
     }
-} RegisterCommand(Command_SaveAll, "ctrl-shift-s");
+} RegisterCommand(CMD_SaveAll, "ctrl-shift-s");
 
-void Command_Build() {
+void CMD_Build() {
-    Command_SaveAll();
+    CMD_SaveAll();
 #if OS_WINDOWS
     ExecBuild("build.bat");
 #else
@@ -439,17 +439,17 @@ void Command_Build() {
 #endif
     BSet main = GetBSet(BuildWindowID);
     main.window->visible = true;
-} RegisterCommand(Command_Build, "f1");
+} RegisterCommand(CMD_Build, "f1");
 
-void Command_GotoNextInList() {
+void CMD_GotoNextInList() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     GotoNextInList(main.window, 1);
-} RegisterCommand(Command_GotoNextInList, "ctrl-e");
+} RegisterCommand(CMD_GotoNextInList, "ctrl-e");
 
-void Command_GotoPrevInList() {
+void CMD_GotoPrevInList() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     GotoNextInList(main.window, -1);
-} RegisterCommand(Command_GotoPrevInList, "alt-e");
+} RegisterCommand(CMD_GotoPrevInList, "alt-e");
 
 bool IsOpenBoundary(char c) {
     bool result = c == 0 || IsParen(c) || IsBrace(c) || c == ':' || c == '\t' || c == '\n' || c == '"' || c == '\'';
@@ -611,7 +611,7 @@ BSet Open(Window *window, String path, String meta, bool set_active = true) {
                 view->carets[0] = MakeCaret(pos);
             }
         }
-        Command_CenterView();
+        CMD_CenterView();
     } else if (o.kind == OpenKind_Exec) {
         if (set_active) {
             NextActiveWindowID = set.window->id;
@@ -644,23 +644,23 @@ BSet Open(String16 path, String meta) {
     return Open(string, meta);
 }
 
-void Command_Save() {
+void CMD_Save() {
     BSet active = GetBSet(LastActiveLayoutWindowID);
     SaveBuffer(active.buffer);
-} RegisterCommand(Command_Save, "ctrl-s");
+} RegisterCommand(CMD_Save, "ctrl-s");
 
-void Command_Reopen() {
+void CMD_Reopen() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     ReopenBuffer(main.buffer);
     NextActiveWindowID = main.window->id;
-} RegisterCommand(Command_Reopen, "");
+} RegisterCommand(CMD_Reopen, "");
 
-void Command_New() {
+void CMD_New() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     New(main.window, "");
-} RegisterCommand(Command_New, "ctrl-n");
+} RegisterCommand(CMD_New, "ctrl-n");
 
-void Command_ToggleFullscreen() {
+void CMD_ToggleFullscreen() {
     if (IsInFullscreen) {
         SDL_SetWindowSize(SDLWindow, FullScreenSizeX, FullScreenSizeY);
         SDL_SetWindowPosition(SDLWindow, FullScreenPositionX, FullScreenPositionY);
@@ -675,12 +675,12 @@ void Command_ToggleFullscreen() {
     }
 
     IsInFullscreen = !IsInFullscreen;
-} RegisterCommand(Command_ToggleFullscreen, "f11");
+} RegisterCommand(CMD_ToggleFullscreen, "f11");
 
-void Command_SetWorkDir() {
+void CMD_SetWorkDir() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     WorkDir = GetDir(main.buffer);
-} RegisterCommand(Command_SetWorkDir, "");
+} RegisterCommand(CMD_SetWorkDir, "");
 
 String CodeSkipPatterns[] = {".git/", ".obj", ".o", ".pdb", ".exe"};
 String Coro_OpenCodeDir;
@@ -718,18 +718,18 @@ void OpenCode(String dir) {
     data->dont_wait_until_resolved = true;
 }
 
-void Command_OpenCode() {
+void CMD_OpenCode() {
     OpenCode(WorkDir);
-} RegisterCommand(Command_OpenCode, "");
+} RegisterCommand(CMD_OpenCode, "");
 
-void Command_KillProcess() {
+void CMD_KillProcess() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     KillProcess(main.view);
-} RegisterCommand(Command_KillProcess, "");
+} RegisterCommand(CMD_KillProcess, "");
 
-void Command_CloseWindow() {
+void CMD_CloseWindow() {
     Close(LastActiveLayoutWindowID);
-} RegisterCommand(Command_CloseWindow, "");
+} RegisterCommand(CMD_CloseWindow, "");
 
 void AddHook(Array<CommandData> *arr, String name, String binding, Function *function) {
     CommandData n = {name, binding, function, ParseKeyCached(binding)};
@@ -774,9 +774,9 @@ void Coro_Rename(mco_coro *co) {
         buffer->name = Intern(&GlobalInternTable, string);
     }
 }
-void Command_Rename() {
+void CMD_Rename() {
     CoAdd(Coro_Rename);
-} RegisterCommand(Command_Rename, "");
+} RegisterCommand(CMD_Rename, "");
 
 String Coro_YesNoCancel(mco_coro *co, BSet main, String question) {
     JumpTempBuffer(&main);
@@ -848,9 +848,9 @@ void Coro_Close(mco_coro *co) {
     } ElseInvalidCodepath();
 }
 
-void Command_Close() {
+void CMD_Close() {
     CoAdd(Coro_Close);
-} RegisterCommand(Command_Close, "ctrl-w");
+} RegisterCommand(CMD_Close, "ctrl-w");
 
 // Considerations with coroutines:
 // 1. Does scratch memory leak across Yield boundary? Or interacts badly with Yield stuff in any way?
@@ -893,322 +893,322 @@ void Coro_Quit(mco_coro *co) {
     }
 }
 
-void Command_Quit() {
+void CMD_Quit() {
     CoAdd(Coro_Quit);
-} RegisterCommand(Command_Quit, "");
+} RegisterCommand(CMD_Quit, "");
 
 void Coro_CloseAll(mco_coro *co) {
     Coro_CloseAllEx(co);
 }
 
-void Command_CloseAll() {
+void CMD_CloseAll() {
     CoAdd(Coro_CloseAll);
-} RegisterCommand(Command_CloseAll, "");
+} RegisterCommand(CMD_CloseAll, "");
 
-void Command_JumpPrev() {
+void CMD_JumpPrev() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     JumpToLastValidView(main.window);
     NextActiveWindowID = main.window->id;
-} RegisterCommand(Command_JumpPrev, "ctrl-tab");
+} RegisterCommand(CMD_JumpPrev, "ctrl-tab");
 
-void Command_Prev() {
+void CMD_Prev() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     main.window->skip_checkpoint = true;
     JumpBack(main.window);
     NextActiveWindowID = main.window->id;
-} RegisterCommand(Command_Prev, "alt-q | mousex1");
+} RegisterCommand(CMD_Prev, "alt-q | mousex1");
 
-void Command_Next() {
+void CMD_Next() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     main.window->skip_checkpoint = true;
     JumpForward(main.window);
     NextActiveWindowID = main.window->id;
-} RegisterCommand(Command_Next, "alt-shift-q | mousex2");
+} RegisterCommand(CMD_Next, "alt-shift-q | mousex2");
 
-void Command_OpenUpFolder() {
+void CMD_OpenUpFolder() {
     BSet main = GetBSet(LastActiveLayoutWindowID);
     String name = ChopLastSlash(main.buffer->name);
     Open(name);
-} RegisterCommand(Command_OpenUpFolder, "ctrl-period");
+} RegisterCommand(CMD_OpenUpFolder, "ctrl-period");
 
-void Command_EncloseLine() {
+void CMD_EncloseLine() {
     BSet active = GetBSet(ActiveWindowID);
     EncloseLine(active.view);
-} RegisterCommand(Command_EncloseLine, "ctrl-l");
+} RegisterCommand(CMD_EncloseLine, "ctrl-l");
 
-void Command_SelectAll() {
+void CMD_SelectAll() {
     BSet active = GetBSet(ActiveWindowID);
     SelectEntireBuffer(active.view);
     active.view->update_scroll = false;
-} RegisterCommand(Command_SelectAll, "ctrl-a");
+} RegisterCommand(CMD_SelectAll, "ctrl-a");
 
-void Command_Redo() {
+void CMD_Redo() {
     BSet active = GetBSet(ActiveWindowID);
     RedoEdit(active.buffer, &active.view->carets);
-} RegisterCommand(Command_Redo, "ctrl-shift-z");
+} RegisterCommand(CMD_Redo, "ctrl-shift-z");
 
-void Command_Undo() {
+void CMD_Undo() {
     BSet active = GetBSet(ActiveWindowID);
     UndoEdit(active.buffer, &active.view->carets);
-} RegisterCommand(Command_Undo, "ctrl-z");
+} RegisterCommand(CMD_Undo, "ctrl-z");
 
-void Command_MakeFontLarger() {
+void CMD_MakeFontLarger() {
     ConfigFontSize += 1;
     ReloadFont(ConfigFont, (U32)ConfigFontSize);
-} RegisterCommand(Command_MakeFontLarger, "ctrl-equals");
+} RegisterCommand(CMD_MakeFontLarger, "ctrl-equals");
 
-void Command_MakeFontSmaller() {
+void CMD_MakeFontSmaller() {
     if (ConfigFontSize > 4) {
         ConfigFontSize -= 1;
         ReloadFont(ConfigFont, (U32)ConfigFontSize);
     }
-} RegisterCommand(Command_MakeFontSmaller, "ctrl-minus");
+} RegisterCommand(CMD_MakeFontSmaller, "ctrl-minus");
 
-void Command_Open() {
+void CMD_Open() {
     BSet active = GetBSet(ActiveWindowID);
     Open(FetchLoadWord(active.view));
-} RegisterCommand(Command_Open, "ctrl-q");
+} RegisterCommand(CMD_Open, "ctrl-q");
 
-void Command_KillSelectedLines() {
+void CMD_KillSelectedLines() {
     BSet active = GetBSet(ActiveWindowID);
     KillSelectedLines(active.view);
-} RegisterCommand(Command_KillSelectedLines, "ctrl-shift-k");
+} RegisterCommand(CMD_KillSelectedLines, "ctrl-shift-k");
 
-void Command_IndentSelectedLines() {
+void CMD_IndentSelectedLines() {
     BSet active = GetBSet(ActiveWindowID);
     IndentSelectedLines(active.view);
-} RegisterCommand(Command_IndentSelectedLines, "ctrl-rightbracket | tab");
+} RegisterCommand(CMD_IndentSelectedLines, "ctrl-rightbracket | tab");
 
-void Command_DedentSelectedLines() {
+void CMD_DedentSelectedLines() {
     BSet active = GetBSet(ActiveWindowID);
     IndentSelectedLines(active.view, true);
-} RegisterCommand(Command_DedentSelectedLines, "ctrl-leftbracket | shift-tab");
+} RegisterCommand(CMD_DedentSelectedLines, "ctrl-leftbracket | shift-tab");
 
-void Command_DuplicateLineDown() {
+void CMD_DuplicateLineDown() {
     BSet active = GetBSet(ActiveWindowID);
     DuplicateLine(active.view, DIR_DOWN);
-} RegisterCommand(Command_DuplicateLineDown, "ctrl-alt-down");
+} RegisterCommand(CMD_DuplicateLineDown, "ctrl-alt-down");
 
-void Command_CreateCursorDown() {
+void CMD_CreateCursorDown() {
     BSet active = GetBSet(ActiveWindowID);
     CreateCursorVertical(active.view, DIR_DOWN);
-} RegisterCommand(Command_CreateCursorDown, "alt-shift-down");
+} RegisterCommand(CMD_CreateCursorDown, "alt-shift-down");
 
-void Command_SelectDownToEmptyLine() {
+void CMD_SelectDownToEmptyLine() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_DOWN, CTRL_PRESSED, SHIFT_PRESS);
-} RegisterCommand(Command_SelectDownToEmptyLine, "ctrl-shift-down");
+} RegisterCommand(CMD_SelectDownToEmptyLine, "ctrl-shift-down");
 
-void Command_MoveLineDown() {
+void CMD_MoveLineDown() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCaretsLine(active.view, DIR_DOWN);
-} RegisterCommand(Command_MoveLineDown, "alt-down");
+} RegisterCommand(CMD_MoveLineDown, "alt-down");
 
-void Command_MoveDownToEmptyLine() {
+void CMD_MoveDownToEmptyLine() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_DOWN, CTRL_PRESSED);
-} RegisterCommand(Command_MoveDownToEmptyLine, "ctrl-down");
+} RegisterCommand(CMD_MoveDownToEmptyLine, "ctrl-down");
 
-void Command_SelectDown() {
+void CMD_SelectDown() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_DOWN, false, SHIFT_PRESS);
-} RegisterCommand(Command_SelectDown, "shift-down");
+} RegisterCommand(CMD_SelectDown, "shift-down");
 
-void Command_MoveDown() {
+void CMD_MoveDown() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_DOWN);
-} RegisterCommand(Command_MoveDown, "down");
+} RegisterCommand(CMD_MoveDown, "down");
 
-void Command_DuplicateLineUp() {
+void CMD_DuplicateLineUp() {
     BSet active = GetBSet(ActiveWindowID);
     DuplicateLine(active.view, DIR_UP);
-} RegisterCommand(Command_DuplicateLineUp, "ctrl-alt-up");
+} RegisterCommand(CMD_DuplicateLineUp, "ctrl-alt-up");
 
-void Command_CreateCursorUp() {
+void CMD_CreateCursorUp() {
     BSet active = GetBSet(ActiveWindowID);
     CreateCursorVertical(active.view, DIR_UP);
-} RegisterCommand(Command_CreateCursorUp, "alt-shift-up");
+} RegisterCommand(CMD_CreateCursorUp, "alt-shift-up");
 
-void Command_SelectUpToEmptyLine() {
+void CMD_SelectUpToEmptyLine() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_UP, CTRL_PRESSED, SHIFT_PRESS);
-} RegisterCommand(Command_SelectUpToEmptyLine, "ctrl-shift-up");
+} RegisterCommand(CMD_SelectUpToEmptyLine, "ctrl-shift-up");
 
-void Command_MoveLineUp() {
+void CMD_MoveLineUp() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCaretsLine(active.view, DIR_UP);
-} RegisterCommand(Command_MoveLineUp, "alt-up");
+} RegisterCommand(CMD_MoveLineUp, "alt-up");
 
-void Command_MoveUpToEmptyLine() {
+void CMD_MoveUpToEmptyLine() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_UP, CTRL_PRESSED);
-} RegisterCommand(Command_MoveUpToEmptyLine, "ctrl-up");
+} RegisterCommand(CMD_MoveUpToEmptyLine, "ctrl-up");
 
-void Command_SelectUp() {
+void CMD_SelectUp() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_UP, false, SHIFT_PRESS);
-} RegisterCommand(Command_SelectUp, "shift-up");
+} RegisterCommand(CMD_SelectUp, "shift-up");
 
-void Command_MoveUp() {
+void CMD_MoveUp() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_UP);
-} RegisterCommand(Command_MoveUp, "up");
+} RegisterCommand(CMD_MoveUp, "up");
 
-void Command_BoundarySelectLeft() {
+void CMD_BoundarySelectLeft() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_LEFT, CTRL_PRESSED, SHIFT_PRESS);
-} RegisterCommand(Command_BoundarySelectLeft, "ctrl-shift-left");
+} RegisterCommand(CMD_BoundarySelectLeft, "ctrl-shift-left");
 
-void Command_BoundaryMoveLeft() {
+void CMD_BoundaryMoveLeft() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_LEFT, CTRL_PRESSED);
-} RegisterCommand(Command_BoundaryMoveLeft, "ctrl-left");
+} RegisterCommand(CMD_BoundaryMoveLeft, "ctrl-left");
 
-void Command_SelectLeft() {
+void CMD_SelectLeft() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_LEFT, false, SHIFT_PRESS);
-} RegisterCommand(Command_SelectLeft, "shift-left");
+} RegisterCommand(CMD_SelectLeft, "shift-left");
 
-void Command_FocusLeftWindow() {
+void CMD_FocusLeftWindow() {
     NextActiveWindowID = SwitchWindow(DIR_LEFT)->id;
-} RegisterCommand(Command_FocusLeftWindow, "alt-left");
+} RegisterCommand(CMD_FocusLeftWindow, "alt-left");
 
-void Command_MoveLeft() {
+void CMD_MoveLeft() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_LEFT);
-} RegisterCommand(Command_MoveLeft, "left");
+} RegisterCommand(CMD_MoveLeft, "left");
 
-void Command_BoundarySelectRight() {
+void CMD_BoundarySelectRight() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_RIGHT, CTRL_PRESSED, SHIFT_PRESS);
-} RegisterCommand(Command_BoundarySelectRight, "ctrl-shift-right");
+} RegisterCommand(CMD_BoundarySelectRight, "ctrl-shift-right");
 
-void Command_BoundaryMoveRight() {
+void CMD_BoundaryMoveRight() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_RIGHT, CTRL_PRESSED);
-} RegisterCommand(Command_BoundaryMoveRight, "ctrl-right");
+} RegisterCommand(CMD_BoundaryMoveRight, "ctrl-right");
 
-void Command_SelectRight() {
+void CMD_SelectRight() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_RIGHT, false, SHIFT_PRESS);
-} RegisterCommand(Command_SelectRight, "shift-right");
+} RegisterCommand(CMD_SelectRight, "shift-right");
 
-void Command_FocusRightWindow() {
+void CMD_FocusRightWindow() {
     NextActiveWindowID = SwitchWindow(DIR_RIGHT)->id;
-} RegisterCommand(Command_FocusRightWindow, "alt-right");
+} RegisterCommand(CMD_FocusRightWindow, "alt-right");
 
-void Command_MoveRight() {
+void CMD_MoveRight() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCarets(active.view, DIR_RIGHT);
-} RegisterCommand(Command_MoveRight, "right");
+} RegisterCommand(CMD_MoveRight, "right");
 
-void Command_MoveUpAPage() {
+void CMD_MoveUpAPage() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorByPageSize(active.window, DIR_UP);
-} RegisterCommand(Command_MoveUpAPage, "pageup");
+} RegisterCommand(CMD_MoveUpAPage, "pageup");
 
-void Command_SelectUpPage() {
+void CMD_SelectUpPage() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorByPageSize(active.window, DIR_UP, SHIFT_PRESS);
-} RegisterCommand(Command_SelectUpPage, "shift-pageup");
+} RegisterCommand(CMD_SelectUpPage, "shift-pageup");
 
-void Command_MoveToStart() {
+void CMD_MoveToStart() {
     BSet active = GetBSet(ActiveWindowID);
     SelectRange(active.view, MakeRange(0));
-} RegisterCommand(Command_MoveToStart, "ctrl-pageup");
+} RegisterCommand(CMD_MoveToStart, "ctrl-pageup");
 
-void Command_SelectDownPage() {
+void CMD_SelectDownPage() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorByPageSize(active.window, DIR_DOWN, SHIFT_PRESS);
-} RegisterCommand(Command_SelectDownPage, "shift-pagedown");
+} RegisterCommand(CMD_SelectDownPage, "shift-pagedown");
 
-void Command_MoveToEnd() {
+void CMD_MoveToEnd() {
     BSet active = GetBSet(ActiveWindowID);
     SelectRange(active.view, MakeRange(active.buffer->len));
-} RegisterCommand(Command_MoveToEnd, "ctrl-pagedown");
+} RegisterCommand(CMD_MoveToEnd, "ctrl-pagedown");
 
-void Command_MoveDownPage() {
+void CMD_MoveDownPage() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorByPageSize(active.window, DIR_DOWN);
-} RegisterCommand(Command_MoveDownPage, "pagedown");
+} RegisterCommand(CMD_MoveDownPage, "pagedown");
 
-void Command_SelectToLineStart() {
+void CMD_SelectToLineStart() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_LEFT, SHIFT_PRESS);
-} RegisterCommand(Command_SelectToLineStart, "shift-home");
+} RegisterCommand(CMD_SelectToLineStart, "shift-home");
 
-void Command_MoveToLineStart() {
+void CMD_MoveToLineStart() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_LEFT);
-} RegisterCommand(Command_MoveToLineStart, "home");
+} RegisterCommand(CMD_MoveToLineStart, "home");
 
-void Command_MoveToLineEnd() {
+void CMD_MoveToLineEnd() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_RIGHT);
-} RegisterCommand(Command_MoveToLineEnd, "end");
+} RegisterCommand(CMD_MoveToLineEnd, "end");
 
-void Command_SelectToLineEnd() {
+void CMD_SelectToLineEnd() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_RIGHT, SHIFT_PRESS);
-} RegisterCommand(Command_SelectToLineEnd, "shift-end");
+} RegisterCommand(CMD_SelectToLineEnd, "shift-end");
 
-void Command_Delete() {
+void CMD_Delete() {
     BSet active = GetBSet(ActiveWindowID);
     Delete(active.view, DIR_LEFT);
-} RegisterCommand(Command_Delete, "shift-backspace | backspace");
+} RegisterCommand(CMD_Delete, "shift-backspace | backspace");
 
-void Command_DeleteBoundary() {
+void CMD_DeleteBoundary() {
     BSet active = GetBSet(ActiveWindowID);
     Delete(active.view, DIR_LEFT, SHIFT_PRESS);
-} RegisterCommand(Command_DeleteBoundary, "ctrl-backspace");
+} RegisterCommand(CMD_DeleteBoundary, "ctrl-backspace");
 
-void Command_DeleteForward() {
+void CMD_DeleteForward() {
     BSet active = GetBSet(ActiveWindowID);
     Delete(active.view, DIR_RIGHT);
-} RegisterCommand(Command_DeleteForward, "shift-delete | delete");
+} RegisterCommand(CMD_DeleteForward, "shift-delete | delete");
 
-void Command_DeleteForwardBoundary() {
+void CMD_DeleteForwardBoundary() {
     BSet active = GetBSet(ActiveWindowID);
     Delete(active.view, DIR_RIGHT, SHIFT_PRESS);
-} RegisterCommand(Command_DeleteForwardBoundary, "ctrl-delete");
+} RegisterCommand(CMD_DeleteForwardBoundary, "ctrl-delete");
 
-void Command_InsertNewLineUp() {
+void CMD_InsertNewLineUp() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_LEFT);
     IdentedNewLine(active.view);
     MoveCarets(active.view, DIR_UP);
-} RegisterCommand(Command_InsertNewLineUp, "ctrl-shift-enter");
+} RegisterCommand(CMD_InsertNewLineUp, "ctrl-shift-enter");
 
-void Command_InsertNewLineDown() {
+void CMD_InsertNewLineDown() {
     BSet active = GetBSet(ActiveWindowID);
     MoveCursorToSide(active.view, DIR_RIGHT);
     IdentedNewLine(active.view);
-} RegisterCommand(Command_InsertNewLineDown, "ctrl-enter");
+} RegisterCommand(CMD_InsertNewLineDown, "ctrl-enter");
 
-void Command_NewLine() {
+void CMD_NewLine() {
     BSet active = GetBSet(ActiveWindowID);
     IdentedNewLine(active.view);
-} RegisterCommand(Command_NewLine, "enter | shift-enter");
+} RegisterCommand(CMD_NewLine, "enter | shift-enter");
 
-void Command_CreateCaretOnNextFind() {
+void CMD_CreateCaretOnNextFind() {
     BSet active = GetBSet(ActiveWindowID);
     String16 string = GetString(active.buffer, active.view->carets[0].range);
     Caret    caret  = FindNext(active.buffer, string, active.view->carets[0]);
     Insert(&active.view->carets, caret, 0);
     MergeCarets(active.buffer, &active.view->carets);
-} RegisterCommand(Command_CreateCaretOnNextFind, "ctrl-d");
+} RegisterCommand(CMD_CreateCaretOnNextFind, "ctrl-d");
 
-void Command_FocusWindow1() {
+void CMD_FocusWindow1() {
     NextActiveWindowID = GetOverlappingWindow({0,0}, GetWindow(ActiveWindowID))->id;
-} RegisterCommand(Command_FocusWindow1, "ctrl-1");
+} RegisterCommand(CMD_FocusWindow1, "ctrl-1");
 
-void Command_FocusWindow2() {
+void CMD_FocusWindow2() {
     Window *first = GetOverlappingWindow({0,0}, GetWindow(ActiveWindowID));
     Vec2I p = GetSideOfWindow(first, DIR_RIGHT);
     NextActiveWindowID = GetOverlappingWindow(p, GetWindow(ActiveWindowID))->id;
-} RegisterCommand(Command_FocusWindow2, "ctrl-2");
+} RegisterCommand(CMD_FocusWindow2, "ctrl-2");
 
-void Command_FocusWindow3() {
+void CMD_FocusWindow3() {
     Window *first = GetOverlappingWindow({0,0});
     if (first) {
         Window *second = GetOverlappingWindow(GetSideOfWindow(first, DIR_RIGHT));
@@ -1219,13 +1219,13 @@ void Command_FocusWindow3() {
             }
         }
     }
-} RegisterCommand(Command_FocusWindow3, "ctrl-3");
+} RegisterCommand(CMD_FocusWindow3, "ctrl-3");
 
-void Command_NewWindow() {
+void CMD_NewWindow() {
     CreateWind();
-} RegisterCommand(Command_NewWindow, "ctrl-backslash");
+} RegisterCommand(CMD_NewWindow, "ctrl-backslash");
 
-void Command_ClearCarets() {
+void CMD_ClearCarets() {
     BSet active = GetBSet(ActiveWindowID);
     active.view->carets.len = 1;
     active.view->carets[0] = MakeCaret(GetFront(active.view->carets[0]));
@@ -1243,7 +1243,7 @@ void Command_ClearCarets() {
             it->visible = false;
         }
     }
-} RegisterCommand(Command_ClearCarets, "escape");
+} RegisterCommand(CMD_ClearCarets, "escape");
 
 void Set(String16 string) {
     Scratch scratch;
@@ -1354,7 +1354,7 @@ void Set(String16 string) {
     ReportErrorf("Failed to :Set, no such variable found: %S", name8);
 }
 
-void Command_Set() {
+void CMD_Set() {
     BSet set = GetBSet(ActiveWindowID);
     Range range = set.view->carets[0].range;
     if (GetSize(range) == 0) {
@@ -1364,7 +1364,7 @@ void Command_Set() {
 
     String16 string = GetString(set.buffer, {range.min, line_end});
     Set(string);
-} RegisterCommand(Command_Set, "");
+} RegisterCommand(CMD_Set, "");
 
 void EvalCommandsLineByLine(Buffer *buffer) {
     for (Int i = 0; i < buffer->line_starts.len; i += 1) {
@@ -1373,7 +1373,7 @@ void EvalCommandsLineByLine(Buffer *buffer) {
     }
 }
 
-void Command_EvalCommandsLineByLine() {
+void CMD_EvalCommandsLineByLine() {
     BSet set = GetBSet(LastActiveLayoutWindowID);
     EvalCommandsLineByLine(set.buffer);
-} RegisterCommand(Command_EvalCommandsLineByLine, "");
+} RegisterCommand(CMD_EvalCommandsLineByLine, "");

src/text_editor/commands_clipboard.cpp

@@ -87,19 +87,19 @@ void ClipboardPaste(View *view) {
     EndEdit(buffer, &edits, &view->carets, KILL_SELECTION);
 }
 
-void Command_Paste() {
+void CMD_Paste() {
     BSet active = GetBSet(ActiveWindowID);
     ClipboardPaste(active.view);
-} RegisterCommand(Command_Paste, "ctrl-v");
+} RegisterCommand(CMD_Paste, "ctrl-v");
 
-void Command_Copy() {
+void CMD_Copy() {
     BSet active = GetBSet(ActiveWindowID);
     ClipboardCopy(active.view);
-} RegisterCommand(Command_Copy, "ctrl-c");
+} RegisterCommand(CMD_Copy, "ctrl-c");
 
-void Command_Cut() {
+void CMD_Cut() {
     BSet active = GetBSet(ActiveWindowID);
     SaveCaretHistoryBeforeBeginEdit(active.buffer, active.view->carets);
     ClipboardCopy(active.view);
     Replace(active.view, u"");
-} RegisterCommand(Command_Cut, "ctrl-x");
+} RegisterCommand(CMD_Cut, "ctrl-x");

src/text_editor/text_editor.cpp

@@ -416,7 +416,7 @@ void OnCommand(Event event) {
     }
 
     if (event.kind == EVENT_QUIT) {
-        Command_Quit();
+        CMD_Quit();
     }
 
     IF_DEBUG(AssertRanges(main.view->carets));

src/text_editor/text_editor.h

@@ -136,7 +136,7 @@ struct Register_Function {
 };
 #define RegisterFunction(functions, name) Register_Function RF__##name(functions, #name, name)
 
-struct Register_Command { Register_Command(Array<CommandData> *fucs, Function *function, String name, String binding) { if (StartsWith(name, "Command_")) name = Skip(name, 8); Add(fucs, {name, binding, function}); } };
+struct Register_Command { Register_Command(Array<CommandData> *fucs, Function *function, String name, String binding) { if (StartsWith(name, "CMD_")) name = Skip(name, 8); Add(fucs, {name, binding, function}); } };
 #define RegisterCommand(name, binding) Register_Command RC__##name(&CommandFunctions, name, #name, binding)
 
 const int DIR_RIGHT = 0;

src/text_editor/window_build.cpp

@@ -27,7 +27,7 @@ void BuildWindowLayout(Rect2I *rect, Int wx, Int wy) {
     n->document_rect = n->total_rect = CutBottom(rect, barsize);
 }
 
-void Command_ShowBuildWindow() {
+void CMD_ShowBuildWindow() {
     BSet main = GetBSet(BuildWindowID);
     if (ActiveWindowID != BuildWindowID) {
         main.window->visible = true;
@@ -35,4 +35,4 @@ void Command_ShowBuildWindow() {
     } else {
         main.window->visible = false;
     }
-} RegisterCommand(Command_ShowBuildWindow, "ctrl-grave");
+} RegisterCommand(CMD_ShowBuildWindow, "ctrl-grave");

src/text_editor/window_command.cpp

@@ -69,8 +69,8 @@ void FuzzySearchViewUpdate() {
     }
 }
 
-void Command_ShowCommands() {
+void CMD_ShowCommands() {
-    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == Command_ShowCommands) {
+    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == CMD_ShowCommands) {
         NextActiveWindowID = LastActiveLayoutWindowID;
         return;
     }
@@ -88,10 +88,10 @@ void Command_ShowCommands() {
     }
     command_bar.view->update_scroll = true;
     SelectRange(command_bar.view, GetBufferBeginAsRange(command_bar.buffer));
-} RegisterCommand(Command_ShowCommands, "ctrl-shift-p");
+} RegisterCommand(CMD_ShowCommands, "ctrl-shift-p");
 
-void Command_ShowDebugBufferList() {
+void CMD_ShowDebugBufferList() {
-    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == Command_ShowDebugBufferList) {
+    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == CMD_ShowDebugBufferList) {
         NextActiveWindowID = LastActiveLayoutWindowID;
         return;
     }
@@ -106,10 +106,10 @@ void Command_ShowDebugBufferList() {
     }
     command_bar.view->update_scroll = true;
     SelectRange(command_bar.view, GetBufferBeginAsRange(command_bar.buffer));
-} RegisterCommand(Command_ShowDebugBufferList, "");
+} RegisterCommand(CMD_ShowDebugBufferList, "");
 
-void Command_ShowBufferList() {
+void CMD_ShowBufferList() {
-    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == Command_ShowBufferList) {
+    if (ActiveWindowID == CommandWindowID && LastExecutedManualCommand == CMD_ShowBufferList) {
         NextActiveWindowID = LastActiveLayoutWindowID;
         return;
     }
@@ -127,7 +127,7 @@ void Command_ShowBufferList() {
     }
     command_bar.view->update_scroll = true;
     SelectRange(command_bar.view, GetBufferBeginAsRange(command_bar.buffer));
-} RegisterCommand(Command_ShowBufferList, "ctrl-p");
+} RegisterCommand(CMD_ShowBufferList, "ctrl-p");
 
 void OpenCommand(BSet active) {
     ProfileFunction();
@@ -144,7 +144,7 @@ void OpenCommand(BSet active) {
     Open(string);
 }
 
-void Command_CommandWindowOpen() {
+void CMD_CommandWindowOpen() {
     BSet active = GetBSet(ActiveWindowID);
     BSet main = GetBSet(LastActiveLayoutWindowID);
     NextActiveWindowID = main.window->id;
@@ -163,7 +163,7 @@ void CommandWindowLayout(Rect2I *rect, Int wx, Int wy) {
 
 void SetFuzzy(View *view) {
     view->fuzzy = true;
-    AddHook(&view->hooks, "Open", "ctrl-q | enter", Command_CommandWindowOpen);
+    AddHook(&view->hooks, "Open", "ctrl-q | enter", CMD_CommandWindowOpen);
 }
 
 void CommandWindowInit() {

src/text_editor/window_debug.cpp

@@ -79,7 +79,7 @@ void DebugWindowUpdate() {
     RawAppendf(set.buffer, "int temp = %d\n", main.buffer->temp);
 }
 
-void Command_ToggleDebug() {
+void CMD_ToggleDebug() {
     Window *window = GetWindow(DebugWindowID);
     window->visible = !window->visible;
-} RegisterCommand(Command_ToggleDebug, "ctrl-0");
+} RegisterCommand(CMD_ToggleDebug, "ctrl-0");

src/text_editor/window_search.cpp

@@ -1,4 +1,4 @@
-void Command_Search() {
+void CMD_Search() {
     BSet main = GetBSet(ActiveWindowID);
     String16 string = {};
     if (main.view->carets.len == 1 && GetSize(main.view->carets[0]) > 0) {
@@ -12,7 +12,7 @@ void Command_Search() {
         Replace(set.view, string);
         SelectEntireBuffer(set.view);
     }
-} RegisterCommand(Command_Search, "ctrl-f");
+} RegisterCommand(CMD_Search, "ctrl-f");
 
 void SearchWindowFindNext(bool forward = true) {
     BSet main = GetBSet(LastActiveLayoutWindowID);
@@ -22,21 +22,21 @@ void SearchWindowFindNext(bool forward = true) {
     main.window->search_bar_anchor = main.view->carets[0];
 }
 
-void Command_SearchNextInSearch() {
+void CMD_SearchNextInSearch() {
     SearchWindowFindNext(true);
 }
 
-void Command_SearchPrevInSearch() {
+void CMD_SearchPrevInSearch() {
     SearchWindowFindNext(false);
 }
 
-void Command_SearchNext() {
+void CMD_SearchNext() {
     SearchWindowFindNext(true);
-} RegisterCommand(Command_SearchNext, "f3");
+} RegisterCommand(CMD_SearchNext, "f3");
 
-void Command_SearchPrev() {
+void CMD_SearchPrev() {
     SearchWindowFindNext(false);
-} RegisterCommand(Command_SearchPrev, "shift-f3");
+} RegisterCommand(CMD_SearchPrev, "shift-f3");
 
 void SearchAll() {
     Scratch scratch;
@@ -53,19 +53,19 @@ void SearchAll() {
     }
 }
 
-void Command_SearchAll() {
+void CMD_SearchAll() {
     SearchAll();
     BSet set = GetBSet(SearchWindowID);
     set.window->visible = false;
-} RegisterCommand(Command_SearchAll, "alt-f3");
+} RegisterCommand(CMD_SearchAll, "alt-f3");
 
-void Command_ToggleCaseSensitiveSearch() {
+void CMD_ToggleCaseSensitiveSearch() {
     SearchCaseSensitive = !SearchCaseSensitive;
-} RegisterCommand(Command_ToggleCaseSensitiveSearch, "alt-c");
+} RegisterCommand(CMD_ToggleCaseSensitiveSearch, "alt-c");
 
-void Command_ToggleSearchWordBoundary() {
+void CMD_ToggleSearchWordBoundary() {
     SearchWordBoundary = !SearchWordBoundary;
-} RegisterCommand(Command_ToggleSearchWordBoundary, "alt-w");
+} RegisterCommand(CMD_ToggleSearchWordBoundary, "alt-w");
 
 void SearchWindowUpdate() {
     BSet active = GetBSet(ActiveWindowID);
@@ -107,7 +107,7 @@ void SearchWindowInit() {
     window->visible = false;
     window->lose_visibility_on_escape = true;
     window->jump_history = false;
-    AddHook(&view->hooks, "SearchAll", "alt-enter", Command_SearchAll);
+    AddHook(&view->hooks, "SearchAll", "alt-enter", CMD_SearchAll);
-    AddHook(&view->hooks, "SearchPrevInSearch", "shift-enter", Command_SearchPrevInSearch);
+    AddHook(&view->hooks, "SearchPrevInSearch", "shift-enter", CMD_SearchPrevInSearch);
-    AddHook(&view->hooks, "SearchNextInSearch", "enter", Command_SearchNextInSearch);
+    AddHook(&view->hooks, "SearchNextInSearch", "enter", CMD_SearchNextInSearch);
 }