AI_Slop/DVX_GUI
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
DVX_GUI/src/apps/kpunch/dvxbasic/ide/ideMain.c
Scott Duensing e1e48c7619 All new BASIC compiler and VM.
2026-10-05 20:01:04 -05:00

11049 lines
343 KiB
C
Raw Blame History

// The MIT License (MIT)
//
// Copyright (C) 2026 Scott Duensing
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ideMain.c -- DVX BASIC IDE application
//
// A DVX app that edits, compiles, runs and debugs BASIC projects.
// PRINT output goes to a scrollable TextArea widget. Compile and
// runtime errors are displayed with file/procedure line numbers.
#include "dvxApp.h"
#include "dvxCur.h"
#include "dvxPlat.h"
#include "dvxDlg.h"
#include "dvxPrefs.h"
#include "dvxWgt.h"
#include "dvxWgtP.h"
#include "dvxWm.h"
#include "shellApp.h"
#include "box/box.h"
#include "checkbox/checkbox.h"
#include "imageButton/imgBtn.h"
#include "label/label.h"
#include "radio/radio.h"
#include "textInput/textInpt.h"
#include "dropdown/dropdown.h"
#include "canvas/canvas.h"
#include "listBox/listBox.h"
#include "tabControl/tabCtrl.h"
#include "button/button.h"
#include "splitter/splitter.h"
#include "statusBar/statBar.h"
#include "listView/listView.h"
#include "separator/separatr.h"
#include "toolbar/toolbar.h"
#include "ideDesigner.h"
#include "ideProject.h"
#include "ideMenuEditor.h"
#include "ideToolbox.h"
#include "ideProperties.h"
#include "../basBuild.h"
#include "../basRes.h"
#include "../compiler/basEvents.h"
#include "../compiler/compiler.h"
#include "../formrt/formrt.h"
#include "../formrt/frmParser.h"
#include "dvxRes.h"
#include "../../../../libs/kpunch/sql/dvxSql.h"
#include "../../../../libs/kpunch/texthelp/textHelp.h"
#include "../runtime/vm.h"
#include "../runtime/values.h"
#include "stb_ds_wrap.h"
#include <dlfcn.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
// ============================================================
// Constants
// ============================================================
#define IDE_MAX_SOURCE PRJ_MAX_SOURCE // editor capacity and largest loadable project file
#define IDE_MAX_OUTPUT 32768
#define IDE_WORD_BUF 32 // single-word scratch buffer
#define IDE_SOURCE_MARGIN 64
#define IDE_FULL_NAME_BUF (BAS_MAX_IDENT * 2) // "Obj.Evt" / "Obj_Evt" combined names
#define IDE_TITLE_BUF (PRJ_MAX_NAME + 32) // "DVX BASIC - [name] *"
#define IDE_FORM_TITLE_BUF (DSGN_MAX_TEXT + 32) // "caption [Design] *"
#define IDE_MSG_BUF (DVX_MAX_PATH + 32) // path plus short message
#define IDE_REPORT_BUF (DVX_MAX_PATH + BAS_MAX_IDENT * 4) // runtime error report
#define IDE_PREF_KEY_BUF 32 // "colorN" style preference keys
#define IDE_IMM_LINE_BUF 512 // one Immediate-window line
#define IDE_IMM_WRAP_BUF (IDE_IMM_LINE_BUF + 8) // line plus "PRINT " prefix
#define IDE_SKELETON_BUF 512 // generated "Sub ... End Sub" skeleton
#define IDE_EVENT_PARAMS_BUF 256 // an Event declaration's parameter list text
#define IDE_RENAME_TITLE "Rename File"
#define IDE_VALUE_BUF 256 // formatted variable value / watch text
#define IDE_FIND_TEXT_BUF 256 // find / replace text
#define IDE_LINE_NUM_BUF 16 // decimal line number text
#define IDE_TYPE_NAME_BUF (BAS_MAX_IDENT + 16) // "Integer()" / "Variant/ClassName" type column text
#define IDE_RGB_LABEL_BUF 16 // "Green 255"
#define IDE_TAB_WIDTH_BUF 8 // tab width text input
#define IDE_OUTPUT_LINE_RESERVE 256 // headroom kept in sOutputBuf per error line
#define IDE_QUOTE_OVERHEAD 3 // two quotes plus NUL around a string value
#define IDE_ARRAY_DIM_RESERVE 10 // room kept for ") [n]" after array dims
#define IDE_LOG_LINE_BUF 256 // one pending PRINT line for Output-to-log
#define IDE_SNIPPET_SLICE 10000 // Immediate/Watch snippet steps per slice
#define IDE_SNIPPET_MAX_SLICES 100 // slices before a snippet is abandoned
// sSyntaxMap flag: a color-only (not reserved) word, left uncolored where
// it names a member (obj.Width).
#define IDE_SYNTAX_UNRESERVED 0x80
#define IDE_MAIN_TITLE "DVX BASIC"
#define IDE_GENERAL_SECTION "(General)"
#define IDE_GLOBAL_SECTION "(Global)"
#define IDE_MODULE_FRAME "(module)"
#define IDE_COLLECTION_TYPE "Collection" // debugger type name of a Collection
#define IDE_OBJECT_TYPE "Object" // debugger type name of any other object
#define IDE_BREAK_TAG " [break]"
#define IDE_DEFAULT_FORM "Form1"
#define IDE_HELP_FILE "dvxbasic.hlp"
#define IDE_PREFS_FILE "dvxbasic.ini"
#define IDE_DBP_EXT ".dbp"
#define IDE_FORM_TYPE_NAME FRM_KW_FORM // designer/validator type name of a form
#define IDE_MENU_TYPE_NAME FRM_KW_MENU // validator type name of a menu item
#define IDE_MENU_EVENT BAS_EVT_CLICK // the only event a menu item fires
#define IDE_FALLBACK_EVENT BAS_EVT_CLICK // default event when a type names none
#define IDE_IMM_RHS_VAR "IDE_IMM_RHS" // Immediate assignment scratch variable
#define IDE_RENAME_TEMP_FMT "IDE_MNU_REN%d" // placeholder during menu renames
#define IDE_PASTE_FORM "IdePaste" // scratch form wrapping a pasted control
#define IDE_NEW_CLASS_FMT "Class%d" // name of a new class module
// Text of a new class module (%s = its name)
#define IDE_NEW_CLASS_TEXT BAS_CLS_KW_VERSION " DVX 1.00 CLASS\n" BAS_CLS_KW_ATTRIBUTE " " BAS_CLS_ATTR_NAME " = \"%s\"\n\nOption Explicit\n"
// Keyword tags for procedure scanning (case-insensitive prefix match)
#define KW_SUB "SUB "
#define KW_FUNCTION "FUNCTION "
#define KW_END_SUB "END SUB"
#define KW_END_FUNCTION "END FUNCTION"
#define KW_PUBLIC "PUBLIC "
#define KW_PRIVATE "PRIVATE "
#define KW_REM "REM"
#define KW_LET "LET "
#define KW_PRINT "PRINT"
#define KW_DIM "DIM"
#define KW_LINE_PREFIX "Line "
#define FRM_BEGIN_TAG "Begin "
#define FRM_END_TAG "End"
#define KW_LEN(s) ((int32_t)sizeof(s) - 1)
// Preference sections/keys used from more than one place
#define IDE_PREF_KEY_TAB_WIDTH "tabWidth"
#define IDE_PREF_KEY_USE_SPACES "useSpaces"
#define IDE_PREF_KEY_RENAME_SKIP "renameSkipComments"
#define PREF_SEC_SYNTAX "syntax"
#define PREF_KEY_COLOR_FMT "color%d"
#define PREF_SEC_RUN "run"
#define PREF_KEY_SAVE_ON_RUN "saveOnRun"
#define PREF_KEY_OUTPUT_TO_LOG "outputToLog"
#define PREF_SEC_VIEW "view"
#define PREF_KEY_TOOLBAR "toolbar"
#define PREF_KEY_STATUSBAR "statusbar"
#define PREF_SEC_RECENT "recent"
#define PREF_KEY_RECENT_FMT "file%ld"
#define IDE_DEFAULT_TAB_WIDTH 3
#define IDE_MIN_TAB_WIDTH 1
#define IDE_MAX_TAB_WIDTH 8
// Editor colors
#define IDE_BP_GUTTER_R 200
#define IDE_BP_GUTTER_G 0
#define IDE_BP_GUTTER_B 0
#define IDE_DBG_LINE_R 255
#define IDE_DBG_LINE_G 255
#define IDE_DBG_LINE_B 128
// Window geometry
#define IDE_WIN_MARGIN 10 // gap from screen edge
#define IDE_TOOLBAR_GAP 2 // gap below the toolbar window
#define IDE_TOOLBAR_FALLBACK_Y 60 // toolbar bottom when no toolbar window
#define IDE_TOOLBAR_SEP_W 10 // toolbar group separator width
#define IDE_TOOLBAR_INIT_H 200 // toolbar window height before fit
#define IDE_PROJECT_WIN_OFFSET 25 // project window y below toolbar bottom
#define IDE_BP_WIN_W 320
#define IDE_DEBUG_WIN_H 180 // breakpoints / call stack / watch height
#define IDE_CALLSTACK_WIN_W 220
#define IDE_CALLSTACK_WIN_Y_OFF 210 // below toolbar bottom
#define IDE_LOCALS_WIN_W 250
#define IDE_LOCALS_WIN_H 200
#define IDE_WATCH_WIN_W 280
#define IDE_WATCH_WIN_X_GAP 260 // watch window sits left of locals
#define IDE_FIND_WIN_W 320
#define IDE_FIND_WIN_H 210
#define IDE_FIND_ROOT_SPACING 3
#define IDE_PREFS_WIN_W 420
#define IDE_PREFS_WIN_H 440
#define IDE_PREFS_LABEL_W 80
#define IDE_PREFS_TAB_INPUT_W 40
#define IDE_PREFS_TAB_INPUT_MAX 4
#define IDE_PREFS_TEXT_MAX 64
#define IDE_PREFS_VERSION_MAX 16
#define IDE_PREFS_BUTTON_W 60
#define IDE_SWATCH_W 64
#define IDE_SWATCH_H 24
#define IDE_WIDGET_SPACING 4
#define IDE_WIDGET_SPACING_SM 2
#define IDE_WIDGET_SPACING_LG 8
// Debug ListView column widths (characters)
#define IDE_COL_W_FILE 12
#define IDE_COL_W_PROC 16
#define IDE_COL_W_LINE 6
#define IDE_COL_W_NAME 12
#define IDE_COL_W_TYPE 8
#define IDE_COL_W_VALUE 16
#define IDE_COL_W_EXPR 14
#define IDE_COL_W_WATCH_VALUE 20
// Menu command IDs
#define CMD_OPEN 100
#define CMD_RUN 101
#define CMD_STOP 102
#define CMD_CLEAR 103
#define CMD_EXIT 104
#define CMD_RUN_NOCMP 105
#define CMD_VIEW_CODE 106
#define CMD_VIEW_DESIGN 107
#define CMD_SAVE 108
#define CMD_WIN_CODE 109
#define CMD_WIN_OUTPUT 110
#define CMD_WIN_IMM 111
#define CMD_WIN_TOOLBOX 112
#define CMD_WIN_PROPS 113
#define CMD_DELETE 114
#define CMD_CUT 115
#define CMD_COPY 116
#define CMD_PASTE 117
#define CMD_SELECT_ALL 118
#define CMD_VIEW_TOOLBAR 119
#define CMD_VIEW_STATUS 120
#define CMD_SAVE_ALL 129
#define CMD_SAVE_ON_RUN 139
#define CMD_PRJ_NEW 130
#define CMD_PRJ_OPEN 131
#define CMD_PRJ_SAVE 132
#define CMD_PRJ_CLOSE 133
#define CMD_PRJ_NEW_CLASS 134
#define CMD_PRJ_RENAME 135
#define CMD_PRJ_REMOVE 136
#define CMD_PRJ_PROPS 138
#define CMD_WIN_PROJECT 137
#define CMD_HELP_ABOUT 140
#define CMD_FIND 141
#define CMD_REPLACE 142
#define CMD_FIND_NEXT 143
#define CMD_MENU_EDITOR 144
#define CMD_PREFERENCES 145
#define CMD_STEP_INTO 146
#define CMD_STEP_OVER 147
#define CMD_STEP_OUT 148
#define CMD_TOGGLE_BP 149
#define CMD_RUN_TO_CURSOR 150
#define CMD_WIN_LOCALS 151
#define CMD_DEBUG 152
#define CMD_WIN_CALLSTACK 153
#define CMD_WIN_WATCH 154
#define CMD_WIN_BREAKPOINTS 155
#define CMD_DEBUG_LAYOUT 156
#define CMD_OUTPUT_TO_LOG 159
#define CMD_RECENT_BASE 160 // 160-175 reserved for recent files
#define CMD_RECENT_MAX 16 // Keep cap: menu command-ID range is a fixed slice
#define CMD_MAKE_EXE 176
#define CMD_HELP_CONTENTS 157
#define CMD_HELP_API 158
#define IDE_MAX_IMM 1024
#define IDE_IMM_HEADROOM IDE_IMM_LINE_BUF // Immediate space output never takes, left for typing
#define IDE_SECTION_GENERAL (-1) // section index of (General) (sCurProcIdx, find, navigation)
#define IDE_SECTION_NONE (-2) // editor bound to no section / scan every section / not activated
#define IDE_SECTION_GAP 1 // blank lines between sections in the canonical layout
#define IDE_NO_LINE (-1) // no line (dropped anchor, unmapped line)
#define IDE_CARET_LOAD 0 // editorSetText: leave the caret where loading puts it
#define IDE_CARET_KEEP (-1) // editorSetText: keep the caret on its current line number
#define IDE_OUTPUT_WIN_H 120 // Output/Immediate window height
#define IDE_OUTPUT_WIN_GAP 2 // gap between code window and output strip
// View mode for activateFile
typedef enum {
ViewAutoE, // .frm -> design, .bas -> code
ViewCodeE, // force code view
ViewDesignE // force design view
} IdeViewModeE;
// Find scope: also the radio index in the Find dialog's Scope group
typedef enum {
ScopeFuncE,
ScopeObjE,
ScopeFileE,
ScopeProjE,
ScopeCountE
} FindScopeE;
// Find direction: also the radio index in the Direction group
typedef enum {
FindDirFwdE,
FindDirBackE,
FindDirCountE
} FindDirE;
// Debug state
typedef enum {
DbgIdleE, // no program loaded
DbgRunningE, // program executing
DbgPausedE, // stopped at breakpoint/step
DbgStoppingE // Stop requested; runModule has not unwound yet
} IdeDebugStateE;
typedef struct {
int32_t fileIdx; // project file index
int32_t codeLine; // line within file's code section (1-based)
char procName[IDE_FULL_NAME_BUF]; // "obj.evt" combined name
} IdeBreakpointT;
// Procedure table for Object/Event dropdowns
typedef struct {
char objName[BAS_MAX_IDENT];
char evtName[BAS_MAX_IDENT];
int32_t lineNum; // line of the SUB / FUNCTION declaration
int32_t endLineNum; // line of the END SUB / END FUNCTION
} IdeProcEntryT;
// A WithEvents variable declared in the file in the code window: an
// entry of the Object dropdown whose events are its class's
typedef struct {
char name[BAS_MAX_IDENT];
char className[BAS_MAX_IDENT];
} IdeWithEventsT;
// An Event a class module declares: its name and parameter list text
// (the handler skeleton takes the same parameters)
typedef struct {
char name[BAS_MAX_IDENT];
char params[IDE_EVENT_PARAMS_BUF];
} IdeClassEventT;
// Where one line of split source went (see splitProcs)
typedef struct {
int32_t piece; // IDE_SECTION_GENERAL or an index into the proc array
int32_t line; // 0-based line within that piece
} IdeLineDestT;
// A line pinned to its section while saveCurProc rearranges the buffers:
// a line of the edited text (edLine), or a line of a stored section.
typedef struct {
int32_t edLine; // 0-based line of the edited text, or IDE_NO_LINE
const char *section; // owning proc buffer; NULL = (General)
int32_t offset; // 0-based line within section, or IDE_NO_LINE (gone)
} IdeLineAnchorT;
typedef struct {
char *key;
uint8_t value;
} SyntaxMapEntryT;
typedef struct {
const char *keyword;
const char *topic;
} HelpMapEntryT;
// Row storage for the debug ListViews. Cell text is strdup'd row-major
// into strs; cells holds the same pointers in the layout
// wgtListViewSetData expects.
typedef struct {
char **strs; // stb_ds: owned cell text
const char **cells; // stb_ds: borrowed pointers into strs
} IdeListRowsT;
// Compile-time CtrlName.Member validator context
typedef struct {
char name[BAS_MAX_IDENT];
char wgtType[BAS_MAX_IDENT]; // "Form" for the form itself, else iface basName
char formName[BAS_MAX_IDENT]; // form that declares it (a form: its own name)
} IdeCtrlMapEntryT;
typedef struct {
char ctrlName[BAS_MAX_IDENT]; // control that has the bad type
char typeName[BAS_MAX_IDENT]; // the unrecognised type name
char formName[BAS_MAX_IDENT]; // enclosing form (for error message)
} IdeBadTypeT;
typedef struct {
IdeCtrlMapEntryT *entries; // stb_ds: known controls
IdeBadTypeT *badTypes; // stb_ds: unknown widget types encountered
const BasCompilerT *compiler; // compile in progress (form scope), or NULL
char currentForm[BAS_MAX_IDENT]; // most recent Begin Form
} IdeValidatorCtxT;
// One .frm parse during compile: the validator map plus the code section
typedef struct {
IdeValidatorCtxT *validator; // NULL = do not collect controls
char *code; // malloc'd code section (NULL = none)
} IdeFrmScanT;
// A running form's caption saved while " [break]" is appended to it
typedef struct {
const BasFormT *form;
char title[MAX_TITLE_LEN];
} IdeBreakTitleT;
// Preferences dialog state (used by several onPrefs* handlers)
typedef struct {
WindowT *win; // non-NULL while the dialog is open
bool done;
bool accepted;
// General tab
WidgetT *renameSkipComments;
WidgetT *optionExplicit;
WidgetT *tabWidthInput;
WidgetT *useSpaces;
WidgetT *defAuthor;
WidgetT *defPublisher;
WidgetT *defVersion;
WidgetT *defCopyright;
WidgetT *defDescription;
// Colors tab
WidgetT *colorList;
WidgetT *lblR;
WidgetT *lblG;
WidgetT *lblB;
WidgetT *colorSwatch;
uint32_t syntaxColors[TEXT_SYNTAX_MAX];
} IdePrefsDlgT;
// ============================================================
// Prototypes
// ============================================================
static bool activateFailed(void);
static bool activateFile(int32_t fileIdx, IdeViewModeE view);
static bool activeIsForm(void);
static bool addFileToProject(const char *path);
static void anchorCodeLine(IdeLineAnchorT *a, int32_t codeLine, int32_t cur, int32_t edLines, int32_t delta, const int32_t *starts);
static void anchorEditedLine(IdeLineAnchorT *a, const IdeLineDestT *map, char **procs, int32_t genBase);
static int32_t anchorLine(const IdeLineAnchorT *a, const int32_t *starts);
static bool anyFileModified(void);
static bool appendCompileFile(BasProjectSourceT *ps, int32_t fileIdx, const char *text, int32_t len, const char *ctrlList, BasSourceMapT *entry);
static int32_t appendDroppingLines(char *buf, int32_t cap, int32_t len, const char *text, int32_t textLen);
static void applySyntaxColors(void);
static void basicColorize(const char *line, int32_t lineLen, uint8_t *colors, void *ctx);
static BasVmT *buildSnippetVm(const char *src, BasModuleT **outMod, char *errBuf, int32_t errBufSize, const char *captureName, int32_t *outCaptureIdx);
static void buildVmBreakpoints(void);
static void buildWindow(void);
static void classEventsOf(const char *className, IdeClassEventT **events);
static bool classFollowsFile(int32_t fileIdx, const char *text);
static uint8_t classifyWord(const char *word, int32_t wordLen, bool afterDot);
static bool classNameUsed(const char *name, const char *fileName);
static void cleanupFormWin(void);
static void clearAllBreakpoints(void);
static void clearOutput(void);
static void clearVmStepState(void);
static void closeFindDialog(void);
static void closeProject(void);
static void closeProjectUi(void);
static int cmpEvtPtrs(const void *a, const void *b);
static int cmpStrPtrs(const void *a, const void *b);
static void compileAndRun(void);
static bool compileProject(void);
static int32_t countLines(const char *text);
static void createEventSubSkeleton(const char *objName, const char *evtName);
static void currentObjName(char *out, int32_t outSize);
static uint32_t debugLineDecorator(int32_t lineNum, uint32_t *gutterColor, void *ctx);
static void debugNavigateToLine(int32_t concatLine);
static void debugResume(const char *status);
static void debugSetBreakTitles(bool paused);
static void debugStartOrResume(int32_t cmd);
static void debugStop(void);
static void debugUpdateWindows(void);
static bool debugVarVisible(const BasDebugVarT *dv, int32_t curProcIdx);
static bool dedupeBreakpoints(void);
static void deleteSelectedControl(void);
static void designerEditCmd(int32_t cmd);
static void designerRelease(void);
static bool doEventsCallback(void *ctx);
static void dsgnCopySelected(void);
static void dsgnPasteControl(void);
static int32_t editCmdKey(int32_t cmd);
static int32_t editorLineToCodeLine(int32_t editorLine);
static void editorSetText(const char *text, int32_t caretLine);
static void editorSnapshot(int32_t lineCount);
static void ensureProject(const char *filePath);
static void ensureProjectWindow(bool raise);
static void evaluateImmediate(const char *expr);
static bool evalWatchExpr(const char *expr, char *outBuf, int32_t outBufSize);
static void evtItemAdd(const char *name, bool bracketed);
static void evtItemsReset(void);
static bool evtLabelMatches(const char *label, const char *evtName);
static bool fileCodeContains(int32_t fileIdx, const char *needle, int32_t needleLen, bool caseSensitive);
static const BasDebugVarT *findDebugVar(const char *name);
static bool findDialogBuild(bool showReplace);
static bool findInEditorSections(int32_t fromIdx, const char *needle, bool caseSensitive, bool forward, const char *objFilter);
static bool findInProject(const char *needle, bool caseSensitive, bool forward, FindScopeE scope);
static int32_t findMemberVarIdx(const BasObjectT *obj, const char *name);
static const char *findSubstrNoCase(const char *haystack, const char *needle, int32_t needleLen);
static int32_t findUdtFieldIdx(int32_t typeId, const char *fieldName);
static const IdeWithEventsT *findWithEvents(const char *name);
static void flushOutput(void);
static void formatValue(const BasValueT *v, char *buf, int32_t bufSize);
static void freeProcBufs(void);
static void frmScan(const char *frmText, IdeFrmScanT *scan);
static void frmScanOnFormEnd(void *userData, const char *trailingSrc, int32_t trailingLen);
static char *generalAppend(const char *general, const char *text);
static BasValueT *getDebugVarSlot(const BasDebugVarT *dv);
static const char *getEventParams(const char *evtName);
static bool getFindForward(void);
static bool getFindMatchCase(void);
static FindScopeE getFindScope(void);
static const char *getFullSource(void);
static WindowT *getLastFocusWin(void);
static void handleEditCmd(int32_t cmd);
static void handleFileCmd(int32_t cmd);
static void handleProjectCmd(int32_t cmd);
static void handleRunCmd(int32_t cmd);
static void handleViewCmd(int32_t cmd);
static void handleWindowCmd(int32_t cmd);
static bool hasProject(void);
static bool hasUnsavedData(void);
static void helpBuildCtrlTopic(const char *typeName, char *buf, int32_t bufSize);
static const char *helpLookupKeyword(const char *word);
static void helpQueryHandler(void *ctx);
static void helpSetCtrlTopic(const char *typeName);
static void ideErrorBox(const char *msg);
static void idePump(void);
static bool immEvalRhs(const char *rhs, uint8_t targetType, BasValueT *outVal);
static void immPrintCallback(void *ctx, const char *text, bool newline);
static void immReportSnippetResult(BasVmT *vm, BasVmResultE result);
static bool immTryAssign(const char *expr);
static void initSyntaxMap(void);
static bool inputCallback(void *ctx, const char *prompt, char *buf, int32_t bufSize);
static const char *instanceTypeName(const BasObjectT *obj);
static void invalidateCompiled(void);
static bool isCtrlArrayInDesigner(const char *ctrlName);
static bool isInStringOrComment(const char *src, int32_t i);
static bool isMangledDebugName(const char *name);
static bool isRemAt(const char *line, int32_t pos, int32_t lineLen);
static bool isReplaceEnabled(void);
static char *joinProcArrays(const char *general, char **procs);
static const char *joinProcBufs(void);
static bool kwMatch(const char *p, const char *kw);
static int32_t lineCopy(const char *text, int32_t line, char *out, int32_t outSize);
static int32_t lineStartOffset(const char *text, int32_t line);
static void listRowsAdd(IdeListRowsT *rows, const char *text);
static void listRowsCommit(const IdeListRowsT *rows, WidgetT *list, int32_t rowCount);
static void listRowsFree(IdeListRowsT *rows);
static void listRowsReset(IdeListRowsT *rows);
static char *loadCompileSource(int32_t fileIdx, IdeValidatorCtxT *validator, char **outCtrlList);
static bool loadDesignerFile(int32_t fileIdx);
static void loadFile(void);
static void loadFormCodeIntoEditor(void);
static void loadFrmFiles(BasFormRtT *rt);
static void loadModuleIntoEditor(int32_t fileIdx, const char *source);
static WidgetT *loadTbIcon(WidgetT *parent, const char *resName, const char *fallbackText);
static int32_t localToConcatLine(int32_t editorLine);
static void logFlushLine(void);
static bool lookupWatchVar(const char *expr, BasValueT *outVal);
static void makeExecutable(void);
static BasValueT *memberVarSlot(const BasDebugVarT *dv);
static void navigateToBreakpoint(int32_t bpIdx);
static int32_t navigateToCodeLine(int32_t fileIdx, int32_t codeLine, bool setDbgLine);
static void navigateToEventSub(void);
static void navigateToNamedEventSub(const char *ctrlName, const char *eventName);
static void newClassModule(void);
static void newProject(void);
static const char *objectClassName(const BasObjectT *obj);
static void onBreakpointHit(void *ctx, int32_t line);
static void onBreakpointListDblClick(WidgetT *w);
static void onBreakpointListKeyDown(WidgetT *w, int32_t keyCode, int32_t shift);
static void onBreakpointWinClose(WindowT *win);
static void onCallStackClose(WindowT *win);
static void onClose(WindowT *win);
static void onCodeWinClose(WindowT *win);
static void onColorChange(WidgetT *w);
static void onColorListChange(WidgetT *w);
static void onContentFocus(WindowT *win);
static void onEditorChange(WidgetT *w);
static void onEvtDropdownChange(WidgetT *w);
static void onFindClose(WindowT *win);
static void onFindCloseBtn(WidgetT *w);
static void onFindNext(WidgetT *w);
static void onFormWinClose(WindowT *win);
static int32_t onFormWinCursorQuery(WindowT *win, int32_t x, int32_t y);
static void onFormWinKey(WindowT *win, int32_t key, int32_t mod);
static void onFormWinMenu(WindowT *win, int32_t menuId);
static void onFormWinMouse(WindowT *win, int32_t x, int32_t y, int32_t buttons);
static void onFormWinPaint(WindowT *win, RectT *dirtyArea);
static void onFormWinResize(WindowT *win, int32_t newW, int32_t newH);
static void onGutterClick(WidgetT *w, int32_t lineNum);
static void onImmediateKeyDown(WidgetT *w, int32_t keyCode, int32_t shift);
static void onImmWinClose(WindowT *win);
static void onLocalsClose(WindowT *win);
static void onMenu(WindowT *win, int32_t menuId);
static void onObjDropdownChange(WidgetT *w);
static void onOutWinClose(WindowT *win);
static void onPrefsCancel(WidgetT *w);
static void onPrefsClose(WindowT *win);
static void onPrefsOk(WidgetT *w);
static void onPrjFileDblClick(int32_t fileIdx);
static void onProjectWinClose(WindowT *win);
static void onReplace(WidgetT *w);
static void onReplaceAll(WidgetT *w);
static void onReplCheckChange(WidgetT *w);
static void onTbCode(WidgetT *w);
static void onTbDebug(WidgetT *w);
static void onTbDesign(WidgetT *w);
static void onTbOpen(WidgetT *w);
static void onTbRun(WidgetT *w);
static void onTbRunToCur(WidgetT *w);
static void onTbSave(WidgetT *w);
static void onTbStepInto(WidgetT *w);
static void onTbStepOut(WidgetT *w);
static void onTbStepOver(WidgetT *w);
static void onTbStop(WidgetT *w);
static void onWatchClose(WindowT *win);
static void onWatchInputKeyDown(WidgetT *w, int32_t keyCode, int32_t shift);
static void onWatchListDblClick(WidgetT *w);
static void onWatchListKeyDown(WidgetT *w, int32_t keyCode, int32_t shift);
static void openAnyPath(const char *path);
static void openFindDialog(bool showReplace);
static void openProject(void);
static void openProjectPath(const char *path);
static void openSinglePath(const char *path);
static void outputAppend(const char *text, int32_t len);
static void outputLog(const char *text);
static char *packProcLayout(const char *source);
static const char *parseIndexList(const char *p, int32_t *indices, int32_t *outCount);
static void parseProcs(const char *source);
static DsgnControlT *pasteParseControl(const char *clip, int32_t clipLen);
static bool prefsBuild(WindowT *win);
static void prefsSetChannelLabel(WidgetT *label, const char *channel, uint8_t value);
static WidgetT *prefsTextRow(WidgetT *parent, const char *caption, int32_t maxLen, const char *value);
static void prefsUpdateColorSwatch(void);
static void printCallback(void *ctx, const char *text, bool newline);
static bool procBodyEmpty(const char *procText);
static bool procBufContains(const char *hay, const char *needle, int32_t needleLen, bool caseSensitive);
static const char *procDeclAt(const char *p, bool *outIsSub);
static int32_t procIndexByName(const char *objName, const char *evtName);
static int32_t procIndexForCodeLine(int32_t codeLine);
static void procNameFromDecl(const char *afterKw, char *out, int32_t outSize);
static void procNameOf(const char *procText, char *out, int32_t outSize);
static int32_t *procStartLines(const char *general, char **procs);
static const char *projectFileText(int32_t fileIdx, char **outOwned, bool *outMissing);
static bool promptAndSave(void);
static void rebuildProcTable(void);
static void recentAdd(const char *path);
static void recentLoad(void);
static void recentOpen(int32_t index);
static void recentRebuildMenu(void);
static void recentRemove(const char *path);
static void recentSave(void);
static void remapBreakpoints(const IdeLineAnchorT *anchors, const int32_t *starts);
static void removeBreakpointsForFile(int32_t fileIdx);
static char *renameInBuffer(const char *src, const char *oldName, const char *newName);
static bool renameMatchAt(const char *src, int32_t i, const char *oldName, int32_t oldLen, bool skipComments);
static void renameMenuItemsInCode(char **oldNames, int32_t oldCount);
static void renameProjectFile(int32_t fileIdx);
static bool renameProjectFileTo(int32_t fileIdx, const char *newName);
static int32_t replaceInSections(const char *objFilter, bool caseSensitive);
static void reportUnreadable(const char *path);
static BasValueT *resolveVarPath(const char *path, const char **endPtr);
static void runCached(void);
static void runModule(BasModuleT *mod);
static BasVmResultE runProgramSlices(BasVmT *vm);
static BasVmResultE runSnippetVm(BasVmT *vm);
static bool saveActiveFile(void);
static bool saveAllModified(void);
static bool saveCurProc(bool discardSkeleton);
static void saveFile(void);
static bool saveProjectFile(void);
static void scanClassEvents(const char *text, IdeClassEventT **events);
static void scanWithEvents(const char *src);
static bool sectionInScope(int32_t p, const char *objFilter);
static int32_t sectionLineCount(const char *text);
static void selectDropdowns(const char *objName, const char *evtName);
static void setBreakpointProcName(IdeBreakpointT *bp, int32_t procIdx);
static bool setClassNameAttr(int32_t fileIdx, const char *name);
static void setOutputText(const char *text);
static void setStatus(const char *text);
static void shiftBreakpointsForEdit(const char *oldText, const char *newText, int32_t delta);
static void showBreakpointWindow(void);
static void showCallStackWindow(void);
static void showCodeView(int32_t fileIdx);
static void showCodeWindow(void);
static void showCompileError(const char *status);
static void showImmediateWindow(void);
static void showLocalsWindow(void);
static void showOutputWindow(void);
static void showPreferencesDialog(void);
static void showProc(int32_t procIdx);
static bool showProcAndFind(int32_t procIdx, const char *needle, bool caseSensitive, bool forward);
static void showWatchWindow(void);
static const char *skipLine(const char *p);
static const char *skipToEndProc(const char *declLine, bool isSub, int32_t *outEndLineOffset);
static bool splitProcs(const char *source, char **outGeneral, char ***outProcs, IdeLineDestT **outMap);
static bool stashCurrentFile(void);
static void stashEditor(void);
static void stashFormCode(void);
static void switchToDesign(void);
static void syncFormDirty(void);
static void syncVmBreakpoints(void);
static void teardownFormWin(void);
static void toggleBreakpoint(void);
static void toggleBreakpointLine(int32_t editorLine);
static int32_t toolbarBottom(void);
static const char *typeNameStr(uint8_t dt);
static void updateBreakpointWindow(void);
static void updateCallStackWindow(void);
static void updateDirtyIndicators(void);
static void updateDropdowns(void);
static void updateLocalsWindow(void);
static void updateMainTitle(void);
static void updateProjectMenuState(void);
static void updateWatchWindow(void);
static void validatorFree(IdeValidatorCtxT *ctx);
static bool validatorIsMethodValid(void *ctx, const char *wgtType, const char *methodName);
static bool validatorIsPropValid(void *ctx, const char *wgtType, const char *propName);
static const char *validatorLookupCtrlType(void *ctx, const char *ctrlName);
static void validatorOnCtrlBegin(void *ud, const char *typeName, const char *name);
static bool validatorOnFormBegin(void *ud, const char *name);
static void validatorOnMenuBegin(void *ud, const char *name, int32_t level);
static int32_t vmCurProcIdx(void);
static int32_t vmProcIndexForPc(int32_t pc);
static const char *vmProcNameForPc(int32_t pc);
static void watchEditSelected(void);
static void watchPrintCallback(void *ctx, const char *text, bool newline);
static bool writeProjectFile(int32_t idx);
int32_t appMain(DxeAppContextT *ctx);
// ============================================================
// Keyword-to-topic lookup for context-sensitive help (F1)
// ============================================================
static const HelpMapEntryT sHelpMap[] = {
// Data types
{"Boolean", "lang.datatypes"},
{"Double", "lang.datatypes"},
{"Integer", "lang.datatypes"},
{"Long", "lang.datatypes"},
{"Single", "lang.datatypes"},
{"String", "lang.datatypes"},
// Declarations
{"ByRef", "lang.declarations"},
{"ByVal", "lang.declarations"},
{"Const", "lang.declarations"},
{"Declare", "lang.declarations"},
{"Dim", "lang.declarations"},
{"Option", "lang.declarations"},
{"ReDim", "lang.declarations"},
{"Shared", "lang.declarations"},
{"Static", "lang.declarations"},
{"Type", "lang.declarations"},
// Operators
{"And", "lang.operators"},
{"Like", "lang.operators"},
{"Mod", "lang.operators"},
{"Not", "lang.operators"},
{"Or", "lang.operators"},
{"Xor", "lang.operators"},
// Conditionals
{"Case", "lang.conditionals"},
{"Else", "lang.conditionals"},
{"ElseIf", "lang.conditionals"},
{"If", "lang.conditionals"},
{"Select", "lang.conditionals"},
{"Then", "lang.conditionals"},
// Loops
{"Do", "lang.loops"},
{"For", "lang.loops"},
{"Loop", "lang.loops"},
{"Next", "lang.loops"},
{"Step", "lang.loops"},
{"Until", "lang.loops"},
{"Wend", "lang.loops"},
{"While", "lang.loops"},
// Procedures
{"Call", "lang.procedures"},
{"Def", "lang.procedures"},
{"End", "lang.procedures"},
{"Function", "lang.procedures"},
{"Sub", "lang.procedures"},
// Flow control
{"Exit", "lang.flow"},
{"GoSub", "lang.flow"},
{"GoTo", "lang.flow"},
{"On", "lang.flow"},
{"Resume", "lang.flow"},
{"Return", "lang.flow"},
// I/O statements
{"Data", "lang.io"},
{"Input", "lang.io"},
{"Print", "lang.io"},
{"Read", "lang.io"},
{"Rem", "lang.io"},
{"Write", "lang.io"},
// Misc statements
{"DoEvents", "lang.misc"},
{"Err", "lang.misc"},
{"Error", "lang.misc"},
{"Error$", "lang.misc"},
{"Load", "lang.misc"},
{"Shell", "lang.misc"},
{"Sleep", "lang.misc"},
{"Unload", "lang.misc"},
// Sound, joysticks and frames
{"Beep", "lang.sound"},
{"FrameWait", "lang.sound"},
{"Play", "lang.sound"},
{"Sound", "lang.sound"},
{"Stick", "lang.sound"},
{"Strig", "lang.sound"},
// Console and graphics
{"Circle", "lang.screen"},
{"Cls", "lang.screen"},
{"Color", "lang.screen"},
{"CsrLin", "lang.screen"},
{"Draw", "lang.screen"},
{"FullScreen", "lang.screen"},
{"InKey$", "lang.screen"},
{"Locate", "lang.screen"},
{"Paint", "lang.screen"},
{"Palette", "lang.screen"},
{"PCopy", "lang.screen"},
{"Pen", "lang.screen"},
{"PMap", "lang.screen"},
{"Point", "lang.screen"},
{"Pos", "lang.screen"},
{"PReset", "lang.screen"},
{"PSet", "lang.screen"},
{"Screen", "lang.screen"},
{"VarPtr$", "lang.screen"},
{"View", "lang.screen"},
{"Width", "lang.screen"},
{"Window", "lang.screen"},
// File I/O
{"Close", "lang.fileio"},
{"Eof", "lang.func.fileio"},
{"FileAttr", "lang.func.fileio"},
{"FreeFile", "lang.func.fileio"},
{"Loc", "lang.func.fileio"},
{"Lof", "lang.func.fileio"},
{"Open", "lang.fileio"},
{"Reset", "lang.fileio"},
{"Seek", "lang.func.fileio"},
// String functions
{"Asc", "lang.func.string"},
{"Chr", "lang.func.string"},
{"Chr$", "lang.func.string"},
{"Environ", "lang.func.string"},
{"Environ$", "lang.func.string"},
{"Format", "lang.func.string"},
{"Format$", "lang.func.string"},
{"InStr", "lang.func.string"},
{"LCase", "lang.func.string"},
{"LCase$", "lang.func.string"},
{"LTrim", "lang.func.string"},
{"LTrim$", "lang.func.string"},
{"Left", "lang.func.string"},
{"Left$", "lang.func.string"},
{"Len", "lang.func.string"},
{"Mid", "lang.func.string"},
{"Mid$", "lang.func.string"},
{"RTrim", "lang.func.string"},
{"RTrim$", "lang.func.string"},
{"Right", "lang.func.string"},
{"Right$", "lang.func.string"},
{"Spc", "lang.func.string"},
{"Space", "lang.func.string"},
{"Space$", "lang.func.string"},
{"String$", "lang.func.string"},
{"Tab", "lang.func.string"},
{"Trim", "lang.func.string"},
{"Trim$", "lang.func.string"},
{"UCase", "lang.func.string"},
{"UCase$", "lang.func.string"},
// Math functions
{"Abs", "lang.func.math"},
{"Atn", "lang.func.math"},
{"Cos", "lang.func.math"},
{"Exp", "lang.func.math"},
{"Fix", "lang.func.math"},
{"Int", "lang.func.math"},
{"Log", "lang.func.math"},
{"Randomize", "lang.func.math"},
{"Rnd", "lang.func.math"},
{"Sgn", "lang.func.math"},
{"Sin", "lang.func.math"},
{"Sqr", "lang.func.math"},
{"Tan", "lang.func.math"},
{"Timer", "lang.func.math"},
// Conversion functions
{"CBool", "lang.func.conversion"},
{"CDbl", "lang.func.conversion"},
{"CInt", "lang.func.conversion"},
{"CLng", "lang.func.conversion"},
{"CSng", "lang.func.conversion"},
{"CStr", "lang.func.conversion"},
{"Hex", "lang.func.conversion"},
{"Hex$", "lang.func.conversion"},
{"Str", "lang.func.conversion"},
{"Str$", "lang.func.conversion"},
{"Val", "lang.func.conversion"},
// Misc functions
{"InputBox", "lang.func.misc"},
{"InputBox$", "lang.func.misc"},
{"LoadPicture", "lang.func.misc"},
{"MsgBox", "lang.func.misc"},
// SQL functions
{"SQLAffected", "lang.sql"},
{"SQLClose", "lang.sql"},
{"SQLEof", "lang.sql"},
{"SQLError", "lang.sql"},
{"SQLError$", "lang.sql"},
{"SQLExec", "lang.sql"},
{"SQLField", "lang.sql"},
{"SQLField$", "lang.sql"},
{"SQLFieldCount", "lang.sql"},
{"SQLFieldDbl", "lang.sql"},
{"SQLFieldInt", "lang.sql"},
{"SQLFreeResult", "lang.sql"},
{"SQLNext", "lang.sql"},
{"SQLOpen", "lang.sql"},
{"SQLQuery", "lang.sql"},
// App object
{"App", "lang.app"},
// INI functions
{"IniRead", "lang.ini"},
{"IniWrite", "lang.ini"},
// Constants
{"False", "lang.constants"},
{"True", "lang.constants"},
{"vbCancel", "lang.constants"},
{"vbCritical", "lang.constants"},
{"vbModal", "lang.constants"},
{"vbOK", "lang.constants"},
{"vbOKCancel", "lang.constants"},
{"vbYesNo", "lang.constants"},
// Variants
{"Array", "lang.variants"},
{"CVar", "lang.variants"},
{"Empty", "lang.variants"},
{"IsArray", "lang.variants"},
{"IsEmpty", "lang.variants"},
{"IsMissing", "lang.procedures"},
{"IsNull", "lang.variants"},
{"IsNumeric", "lang.variants"},
{"IsObject", "lang.variants"},
{"Null", "lang.variants"},
{"TypeName", "lang.variants"},
{"VarType", "lang.variants"},
{"Variant", "lang.variants"},
// Objects and class modules
{"Class_Initialize", "lang.classes"},
{"Class_Terminate", "lang.classes"},
{"Event", "lang.events"},
{"Friend", "lang.classes"},
{"Implements", "lang.interfaces"},
{"Is", "lang.classes"},
{"New", "lang.classes"},
{"Nothing", "lang.classes"},
{"Private", "lang.classes"},
{"Property", "lang.classes"},
{"Public", "lang.classes"},
{"RaiseEvent", "lang.events"},
{"Set", "lang.classes"},
{"TypeOf", "lang.classes"},
{"With", "lang.classes"},
{"WithEvents", "lang.events"},
// Collections
{"Collection", "lang.collection"},
{"Each", "lang.collection"},
// Form/control statements
{"Me", "lang.forms"},
};
#define HELP_MAP_COUNT DVX_ARRAY_LEN(sHelpMap)
// ============================================================
// Module state
// ============================================================
static DxeAppContextT *sCtx = NULL;
static char sIdeHelpFile[DVX_MAX_PATH]; // IDE help file (restored after program run)
static AppContextT *sAc = NULL;
static PrefsHandleT *sPrefs = NULL;
static WindowT *sWin = NULL; // Main toolbar window
static WindowT *sCodeWin = NULL; // Code editor window
static WindowT *sOutWin = NULL; // Output window
static WindowT *sImmWin = NULL; // Immediate window
static WidgetT *sEditor = NULL;
static WidgetT *sOutput = NULL;
static WidgetT *sImmediate = NULL;
static WidgetT *sObjDropdown = NULL;
static WidgetT *sEvtDropdown = NULL;
static WidgetT *sToolbar = NULL;
static WidgetT *sStatusBar = NULL;
static WidgetT *sStatus = NULL;
static WidgetT *sTbRun = NULL;
static WidgetT *sTbStop = NULL;
static WidgetT *sTbDebug = NULL;
static WidgetT *sTbStepInto = NULL;
static WidgetT *sTbStepOver = NULL;
static WidgetT *sTbStepOut = NULL;
static WidgetT *sTbRunToCur = NULL;
static WidgetT *sTbCode = NULL;
static WidgetT *sTbDesign = NULL;
static BasVmT *sVm = NULL; // VM instance (non-NULL while running)
static BasModuleT *sCachedModule = NULL; // Last compiled module (for Ctrl+F5)
static DsgnStateT sDesigner;
static WindowT *sFormWin = NULL; // Form designer window (separate)
static WindowT *sToolboxWin = NULL;
static WindowT *sPropsWin = NULL;
static WindowT *sProjectWin = NULL;
static PrjStateT sProject;
static WindowT *sLastFocusWin = NULL; // last focused non-toolbar window
static char sOutputBuf[IDE_MAX_OUTPUT];
static int32_t sOutputLen = 0;
// Procedure view state -- the editor shows one procedure at a time.
// Each procedure is stored in its own malloc'd buffer. The editor
// swaps directly between buffers with no splicing needed.
//
// The canonical text of a file is joinProcArrays(sGeneralBuf, sProcBufs):
// the (General) section, a blank line, then each procedure separated by
// one blank line. Everything that reads line numbers (sProcTable,
// breakpoints, the compiler's source map) works in that layout, and
// compileProject normalizes every file into it, so there is exactly one
// line-number space.
static char *sGeneralBuf = NULL; // (General) section: module-level code
static char **sProcBufs = NULL; // stb_ds array: one buffer per procedure
static char *sFullSourceCache = NULL; // last joinProcBufs() result (owned here)
static int32_t sCurProcIdx = IDE_SECTION_NONE; // which buffer is in the editor (or IDE_SECTION_GENERAL / _NONE)
static int32_t sEditorFileIdx = -1; // which project file owns sProcBufs (-1=none)
static int32_t sDesignerFileIdx = -1; // which project file owns sDesigner.form (-1=none)
static int32_t sEditorLineCount = 0; // line count for breakpoint adjustment on edit
static char *sEditorPrevText = NULL; // editor text before the latest edit (malloc'd)
static bool sEditorTruncated = false; // section exceeds the editor: shown read-only
static char sSkeletonName[IDE_FULL_NAME_BUF] = ""; // untouched generated event Sub
// Find/Replace state
static char sFindText[IDE_FIND_TEXT_BUF] = "";
static char sReplaceText[IDE_FIND_TEXT_BUF] = "";
// Find/Replace dialog state (modeless)
static WindowT *sFindWin = NULL;
static WidgetT *sFindInput = NULL;
static WidgetT *sReplInput = NULL;
static WidgetT *sReplCheck = NULL;
static WidgetT *sBtnReplace = NULL;
static WidgetT *sBtnReplAll = NULL;
static WidgetT *sCaseCheck = NULL;
static WidgetT *sScopeGroup = NULL; // radio group indexed by FindScopeE
static WidgetT *sDirGroup = NULL; // radio group indexed by FindDirE
static IdeProcEntryT *sProcTable = NULL; // stb_ds dynamic array (rebuilt by joinProcBufs)
static const char **sObjItems = NULL; // stb_ds dynamic array of owned (strdup'd) names
static const char **sEvtItems = NULL; // stb_ds dynamic array of owned (strdup'd) labels
static IdeWithEventsT *sWithEvents = NULL; // stb_ds: the editor file's WithEvents variables (updateDropdowns)
static bool sDropdownNavSuppressed = false;
static bool sStopRequested = false;
static bool sOutputToLog = false;
static bool sOutputPending = false; // sOutputBuf not yet shown
static char sLogLine[IDE_LOG_LINE_BUF]; // PRINT text not yet logged
static int32_t sLogLineLen = 0;
// Recent files list (stored in dvxbasic.ini [recent] section)
// stb_ds dynamic array of strdup'd paths. Capped at CMD_RECENT_MAX by the menu
// command-ID range.
static char **sRecentFiles = NULL;
static MenuT *sFileMenu = NULL;
static int32_t sFileMenuBase = 0; // item count before recent files
static IdeDebugStateE sDbgState = DbgIdleE;
static IdeBreakTitleT *sBreakTitles = NULL; // stb_ds: captions tagged " [break]"
static IdeBreakpointT *sBreakpoints = NULL; // stb_ds array
static int32_t *sVmBreakpoints = NULL; // stb_ds array of concat line numbers (built at compile time)
static int32_t sDbgCurrentLine = -1; // line where paused (-1 = none)
static BasFormRtT *sDbgFormRt = NULL; // form runtime for debug session
static BasModuleT *sDbgModule = NULL; // module for debug session
static bool sDbgBreakOnStart = false; // break at first statement
static bool sDbgEnabled = false; // true = debug mode (breakpoints active)
static WindowT *sLocalsWin = NULL; // Locals window
static WidgetT *sLocalsList = NULL; // Locals ListView widget
static WindowT *sCallStackWin = NULL; // Call stack window
static WidgetT *sCallStackList = NULL; // Call stack ListView widget
static WindowT *sWatchWin = NULL; // Watch window
static WidgetT *sWatchList = NULL; // Watch ListView widget
static WidgetT *sWatchInput = NULL; // Watch expression input
static char **sWatchExprs = NULL; // stb_ds dynamic array of strdup'd watch expressions
static WindowT *sBreakpointWin = NULL; // Breakpoints window
static WidgetT *sBreakpointList = NULL; // Breakpoints ListView widget
// Per-refresh display rows for the debug ListViews
static IdeListRowsT sBpRows;
static IdeListRowsT sLocalsRows;
static IdeListRowsT sCallRows;
static IdeListRowsT sWatchRows;
// ============================================================
// Syntax highlighting tables (shared by several functions)
// ============================================================
static SyntaxMapEntryT *sSyntaxMap = NULL;
// Color entry names for the Colors tab (matches TEXT_SYNTAX_* indices)
static const char *sSyntaxColorNames[TEXT_SYNTAX_MAX] = {
[TEXT_SYNTAX_DEFAULT] = "Default Text",
[TEXT_SYNTAX_KEYWORD] = "Keywords",
[TEXT_SYNTAX_STRING] = "Strings",
[TEXT_SYNTAX_COMMENT] = "Comments",
[TEXT_SYNTAX_NUMBER] = "Numbers",
[TEXT_SYNTAX_OPERATOR] = "Operators",
[TEXT_SYNTAX_TYPE] = "Types",
};
static IdePrefsDlgT sPrefsDlg;
// Watch-expression scratch buffer (used by evalWatchExpr + watchPrintCallback)
static char sWatchPrintBuf[IDE_VALUE_BUF];
static int32_t sWatchPrintLen;
// ============================================================
// Event table for the Object/Event dropdowns and handler skeletons
// ============================================================
//
// Expanded from the master BAS_EVENT_LIST in compiler/basEvents.h so the
// dropdowns, the generated parameter lists and the runtime dispatcher
// can never disagree.
static const BasEventInfoT sEventTable[] = { BAS_EVENT_LIST(BAS_EVENT_ROW) };
#define IDE_EVENT_COUNT DVX_ARRAY_LEN(sEventTable)
// ============================================================
// App descriptor
// ============================================================
SHELL_APP_DESCRIPTOR(
.name = "DVX BASIC",
.hasMainLoop = false,
.multiInstance = false,
.stackSize = SHELL_STACK_DEFAULT,
.priority = 0
);
// activateFailed -- the switch did not happen: when the skeleton the
// editor showed was dropped on the way out, show the outgoing file's
// (General) so the editor is never left bound to no section. Returns
// false for activateFile to pass on.
static bool activateFailed(void) {
if (sCurProcIdx == IDE_SECTION_NONE && sEditorFileIdx >= 0) {
updateDropdowns();
showProc(IDE_SECTION_GENERAL);
}
return false;
}
// activateFile -- make fileIdx the active file and show it in the given
// view. Returns false (leaving the current file active) when the
// outgoing file cannot be stashed or the incoming one cannot be loaded.
static bool activateFile(int32_t fileIdx, IdeViewModeE view) {
if (fileIdx < 0 || fileIdx >= prjFileCount(&sProject)) {
return false;
}
PrjFileT *target = &sProject.files[fileIdx];
// Resolve ViewAutoE
if (view == ViewAutoE) {
view = target->kind == PrjKindFormE ? ViewDesignE : ViewCodeE;
}
// If already active, just ensure the right view is showing
if (fileIdx == sProject.activeFileIdx) {
if (view == ViewDesignE) {
switchToDesign();
} else {
showCodeView(fileIdx);
}
return true;
}
// PHASE 1: Stash the outgoing file. The editor is being rebound, so an
// untouched event skeleton is dropped first. A failed stash keeps the
// current file active rather than throwing its edits away.
saveCurProc(true);
if (!stashCurrentFile()) {
return activateFailed();
}
// PHASE 2: Load the incoming file
if (target->kind == PrjKindFormE) {
// A form already in the designer keeps its live (possibly unsaved) state
if ((fileIdx != sDesignerFileIdx || !sDesigner.form) && !loadDesignerFile(fileIdx)) {
return activateFailed();
}
sProject.activeFileIdx = fileIdx;
if (view == ViewDesignE) {
switchToDesign();
// The editor must never stay bound to the previous file: an open
// code window now shows this form's code, otherwise the stale
// proc buffers are released so nothing can be edited into limbo.
if (sCodeWin) {
loadFormCodeIntoEditor();
} else {
freeProcBufs();
}
} else {
loadFormCodeIntoEditor();
}
} else {
bool missing = false;
char *owned = NULL;
const char *source = projectFileText(fileIdx, &owned, &missing);
if (!source && !missing) {
reportUnreadable(target->path);
return activateFailed();
}
if (!sCodeWin) {
showCodeWindow();
}
if (sCodeWin) {
dvxRaiseWindow(sAc, sCodeWin);
}
// Only a file that does not exist yet starts out empty (and unsaved)
if (!source) {
target->modified = true;
}
sProject.activeFileIdx = fileIdx;
loadModuleIntoEditor(fileIdx, source ? source : "");
free(owned);
}
updateProjectMenuState();
updateDirtyIndicators();
return true;
}
// activeIsForm -- true when the active project file is a .frm
static bool activeIsForm(void) {
return sProject.activeFileIdx >= 0 && sProject.activeFileIdx < prjFileCount(&sProject) && sProject.files[sProject.activeFileIdx].kind == PrjKindFormE;
}
// Adds path to the open project (or activates it when already listed).
// Returns false when the file lives outside the project directory --
// PrjFileT.path is project-relative, so such a file could never be
// read back and the next save would silently create an empty copy --
// or when it exists but cannot be loaded.
static bool addFileToProject(const char *path) {
const char *fileName = platformPathBaseName(path);
char dir[DVX_MAX_PATH];
snprintf(dir, sizeof(dir), "%s", path);
char *sep = platformPathDirEnd(dir);
if (sep) {
*sep = '\0';
} else {
dir[0] = '.';
dir[1] = '\0';
}
if (strcasecmp(dir, sProject.projectDir) != 0) {
ideErrorBox("Files must be located in the project directory.");
return false;
}
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (strcasecmp(sProject.files[i].path, fileName) == 0) {
return activateFile(i, ViewAutoE);
}
}
bool wasDirty = sProject.dirty;
prjAddFile(&sProject, fileName, prjKindForPath(path));
// A file that exists but cannot be loaded is not kept: its empty
// stand-in would overwrite the real file on the next save.
if (!activateFile(prjFileCount(&sProject) - 1, ViewAutoE)) {
prjRemoveFile(&sProject, prjFileCount(&sProject) - 1);
sProject.dirty = wasDirty;
return false;
}
invalidateCompiled();
prjRebuildTree(&sProject);
return true;
}
// anchorCodeLine -- pin whole-file line codeLine of the editor's file to
// the section holding it. The layout is the stored buffers with section
// cur replaced by the edited text: its edLines lines start at cur's
// start, and every later section was moved by delta while it was edited
// (starts: procStartLines of the stored buffers).
static void anchorCodeLine(IdeLineAnchorT *a, int32_t codeLine, int32_t cur, int32_t edLines, int32_t delta, const int32_t *starts) {
int32_t curStart = cur == IDE_SECTION_GENERAL ? 1 : starts[cur];
a->edLine = IDE_NO_LINE;
a->section = NULL;
a->offset = IDE_NO_LINE;
if (codeLine >= curStart && codeLine < curStart + edLines) {
a->edLine = codeLine - curStart;
return;
}
if (codeLine >= curStart + edLines) {
codeLine -= delta;
}
if (cur != IDE_SECTION_GENERAL && codeLine >= 1 && codeLine <= sectionLineCount(sGeneralBuf)) {
a->offset = codeLine - 1;
return;
}
for (int32_t p = 0; p < (int32_t)arrlen(sProcBufs); p++) {
if (p != cur && codeLine >= starts[p] && codeLine < starts[p] + sectionLineCount(sProcBufs[p])) {
a->section = sProcBufs[p];
a->offset = codeLine - starts[p];
return;
}
}
}
// anchorEditedLine -- pin a line of the edited text (a->edLine) to where
// splitProcs sent it: a proc buffer, or (General) at genBase plus its
// line in the General piece. A line that was not stored (a discarded
// skeleton's, whose procs[] entry is NULL) is gone.
static void anchorEditedLine(IdeLineAnchorT *a, const IdeLineDestT *map, char **procs, int32_t genBase) {
a->section = NULL;
a->offset = IDE_NO_LINE;
if (a->edLine < 0 || a->edLine >= (int32_t)arrlen(map)) {
return;
}
const IdeLineDestT *d = &map[a->edLine];
if (d->piece == IDE_SECTION_GENERAL) {
a->offset = genBase + d->line;
} else if (procs[d->piece]) {
a->section = procs[d->piece];
a->offset = d->line;
}
}
// anchorLine -- whole-file line of an anchor in the current layout
// (starts: procStartLines of the current buffers), or IDE_NO_LINE when
// its line no longer exists
static int32_t anchorLine(const IdeLineAnchorT *a, const int32_t *starts) {
if (a->offset < 0) {
return IDE_NO_LINE;
}
if (!a->section) {
return a->offset < sectionLineCount(sGeneralBuf) ? a->offset + 1 : IDE_NO_LINE;
}
for (int32_t p = 0; p < (int32_t)arrlen(sProcBufs); p++) {
if (sProcBufs[p] == a->section) {
return a->offset < sectionLineCount(a->section) ? starts[p] + a->offset : IDE_NO_LINE;
}
}
return IDE_NO_LINE;
}
// anyFileModified -- whether any project file (or the designer's form)
// has unsaved edits; the one rule for Save All, the title and the exit
// prompt (which also counts the .dbp itself)
static bool anyFileModified(void) {
bool modified = sDesigner.form && sDesigner.form->dirty;
for (int32_t i = 0; i < prjFileCount(&sProject) && !modified; i++) {
modified = sProject.files[i].modified;
}
return modified;
}
// appendCompileFile -- append project file fileIdx's compile text (text,
// len bytes: its canonical layout, a form's code section only) to ps the
// way basBuildConcatProject does: a form's code wrapped in BEGINFORM with
// its controls (ctrlList, see basFrmControlList), a class module's code
// after its header wrapped in BEGINCLASS, a module in BEGINMODULE. Fills
// entry's line fields; false with ps->error set on failure.
static bool appendCompileFile(BasProjectSourceT *ps, int32_t fileIdx, const char *text, int32_t len, const char *ctrlList, BasSourceMapT *entry) {
PrjFileT *file = &sProject.files[fileIdx];
const char *name = "";
BasBuildWrapE wrap = BAS_BUILD_WRAP_MODULE;
int32_t codePos = 0;
char className[BAS_MAX_IDENT];
entry->firstFileLine = 1;
if (file->kind == PrjKindFormE) {
name = file->formName;
wrap = BAS_BUILD_WRAP_FORM;
} else if (file->kind == PrjKindClassE) {
if (!prjClassName(&sProject, fileIdx, text, className, (int32_t)sizeof(className))) {
snprintf(ps->error, sizeof(ps->error), "No class name for %s", file->path);
return false;
}
codePos = prjClassCodePos(text, len, &entry->firstFileLine);
name = className;
wrap = BAS_BUILD_WRAP_CLASS;
}
return basBuildAppendFile(ps, text + codePos, len - codePos, wrap, name, ctrlList, &entry->startLine, &entry->lineCount);
}
// appendDroppingLines -- append text to a NUL-terminated buffer of cap
// bytes holding len bytes, dropping whole leading lines while it would
// not fit so the newest text always survives (an oversize chunk keeps
// its tail). Returns the new length.
static int32_t appendDroppingLines(char *buf, int32_t cap, int32_t len, const char *text, int32_t textLen) {
if (textLen > cap - 1) {
text += textLen - (cap - 1);
textLen = cap - 1;
}
int32_t drop = 0;
int32_t keep = len;
while (keep + textLen > cap - 1) {
const char *nl = memchr(buf + drop, '\n', (size_t)keep);
if (!nl) {
drop += keep;
keep = 0;
break;
}
int32_t cut = (int32_t)(nl + 1 - (buf + drop));
drop += cut;
keep -= cut;
}
memmove(buf, buf + drop, (size_t)keep);
memcpy(buf + keep, text, (size_t)textLen);
keep += textLen;
buf[keep] = '\0';
return keep;
}
static void applySyntaxColors(void) {
if (!sEditor) {
return;
}
wgtTextAreaSetSyntaxColors(sEditor, sPrefsDlg.syntaxColors, TEXT_SYNTAX_MAX);
}
static void basicColorize(const char *line, int32_t lineLen, uint8_t *colors, void *ctx) {
(void)ctx;
int32_t i = 0;
while (i < lineLen) {
char ch = line[i];
// Comment: ' (REM is handled with the identifiers)
if (ch == '\'') {
while (i < lineLen) {
colors[i++] = TEXT_SYNTAX_COMMENT;
}
return;
}
// String literal
if (ch == '"') {
colors[i++] = TEXT_SYNTAX_STRING;
while (i < lineLen && line[i] != '"') {
colors[i++] = TEXT_SYNTAX_STRING;
}
if (i < lineLen) {
colors[i++] = TEXT_SYNTAX_STRING;
}
continue;
}
// Number
if (isdigit((unsigned char)ch) || (ch == '.' && i + 1 < lineLen && isdigit((unsigned char)line[i + 1]))) {
while (i < lineLen && (isdigit((unsigned char)line[i]) || line[i] == '.')) {
colors[i++] = TEXT_SYNTAX_NUMBER;
}
continue;
}
// Date literal #...#, colored as a number (the compiler's rule:
// other '#'s are file numbers)
double serial;
int32_t dateLen = (ch == '#') ? basLexerDateLiteralLen(line + i, lineLen - i, &serial) : 0;
if (dateLen > 0) {
memset(colors + i, TEXT_SYNTAX_NUMBER, (size_t)dateLen);
i += dateLen;
continue;
}
// Identifier or keyword
if (isalpha((unsigned char)ch) || ch == '_') {
int32_t start = i;
while (i < lineLen && basIsIdentChar(line[i])) {
i++;
}
// A type suffix (Dir$, Len%) is colored with its word but is
// not part of the keyword lookup.
int32_t wordLen = i - start;
if (i < lineLen && basIsTypeSuffixChar(line[i])) {
i++;
}
if (isRemAt(line, start, lineLen)) {
for (int32_t j = start; j < lineLen; j++) {
colors[j] = TEXT_SYNTAX_COMMENT;
}
return;
}
uint8_t c = classifyWord(line + start, wordLen, start > 0 && line[start - 1] == '.');
for (int32_t j = start; j < i; j++) {
colors[j] = c;
}
continue;
}
// Operators
if (ch == '=' || ch == '<' || ch == '>' || ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '\\' || ch == '&') {
colors[i++] = TEXT_SYNTAX_OPERATOR;
continue;
}
// Default (whitespace, parens, etc.)
colors[i++] = TEXT_SYNTAX_DEFAULT;
}
}
// buildSnippetVm -- compile a one-line snippet and return a VM ready to
// run it. When paused in the debugger, the paused VM's variables are
// added to the snippet's symbol table (as globals) and their current
// values copied in, so expressions can reference them by name. When
// captureName is given, *outCaptureIdx receives the global slot of that
// snippet variable (-1 when it does not exist). On failure returns NULL
// and copies the error text into errBuf.
static BasVmT *buildSnippetVm(const char *src, BasModuleT **outMod, char *errBuf, int32_t errBufSize, const char *captureName, int32_t *outCaptureIdx) {
*outMod = NULL;
errBuf[0] = '\0';
BasCompilerT *compiler = basCompilerCreate(src, (int32_t)strlen(src));
if (!compiler) {
snprintf(errBuf, errBufSize, "Out of memory");
return NULL;
}
// Track which debug vars we added and their assigned global indices
int32_t varMap[BAS_VM_MAX_GLOBALS]; // maps temp global idx -> debug var idx
int32_t varMapCount = 0;
bool paused = (sDbgState == DbgPausedE && sVm && sDbgModule && sDbgModule->debugVars);
if (paused) {
int32_t curProcIdx = vmCurProcIdx();
for (int32_t i = 0; i < sDbgModule->debugVarCount && varMapCount < BAS_VM_MAX_GLOBALS; i++) {
const BasDebugVarT *dv = &sDbgModule->debugVars[i];
if (!debugVarVisible(dv, curProcIdx) || isMangledDebugName(dv->name)) {
continue;
}
// The snippet's globals, in order: slot varMapCount
if (basCompilerDeclareGlobal(compiler, dv->name, dv->dataType)) {
varMap[varMapCount] = i;
varMapCount++;
}
}
}
if (!basCompile(compiler)) {
snprintf(errBuf, errBufSize, "%s", basCompilerError(compiler));
basCompilerDestroy(compiler);
return NULL;
}
if (captureName) {
*outCaptureIdx = basCompilerGlobalSlot(compiler, captureName);
}
BasModuleT *mod = basCompilerBuildModule(compiler);
basCompilerDestroy(compiler);
if (!mod) {
snprintf(errBuf, errBufSize, "Failed to build module");
return NULL;
}
BasVmT *vm = basVmCreate();
if (!vm) {
basModuleFree(mod);
snprintf(errBuf, errBufSize, "Out of memory");
return NULL;
}
basVmLoadModule(vm, mod);
// Copy values from the paused VM into the temp VM's globals
for (int32_t g = 0; g < varMapCount; g++) {
BasValueT *slot = getDebugVarSlot(&sDbgModule->debugVars[varMap[g]]);
if (slot) {
vm->globals[g] = basValCopy(*slot);
}
}
*outMod = mod;
return vm;
}
// ============================================================
// buildVmBreakpoints -- convert IDE breakpoints to VM concat line numbers
// ============================================================
//
// Called after compilation when the source map is fresh. Converts
// each (fileIdx, codeLine) pair to a concatenated source line number
// that matches OP_LINE values in the compiled bytecode.
static void buildVmBreakpoints(void) {
arrfree(sVmBreakpoints);
sVmBreakpoints = NULL;
for (int32_t i = 0; i < (int32_t)arrlen(sBreakpoints); i++) {
int32_t concatLine = prjMapFileLine(&sProject, sBreakpoints[i].fileIdx, sBreakpoints[i].codeLine);
if (concatLine > 0) {
arrput(sVmBreakpoints, concatLine);
}
}
}
static void buildWindow(void) {
// ---- Main toolbar window (top of screen) ----
sWin = dvxCreateWindow(sAc, IDE_MAIN_TITLE, 0, 0, sAc->display.width, IDE_TOOLBAR_INIT_H, true);
if (!sWin) {
return;
}
sWin->onClose = onClose;
sWin->onMenu = onMenu;
// Menu bar
MenuBarT *menuBar = wmAddMenuBar(sWin);
sFileMenu = wmAddMenu(menuBar, "&File");
MenuT *fileMenu = sFileMenu;
wmAddMenuItem(fileMenu, "New &Project...", CMD_PRJ_NEW);
wmAddMenuItem(fileMenu, "&Open Project...", CMD_PRJ_OPEN);
wmAddMenuItem(fileMenu, "Save Projec&t", CMD_PRJ_SAVE);
wmAddMenuItem(fileMenu, "&Close Project", CMD_PRJ_CLOSE);
wmAddMenuSeparator(fileMenu);
wmAddMenuItem(fileMenu, "Project Propert&ies...", CMD_PRJ_PROPS);
wmAddMenuSeparator(fileMenu);
wmAddMenuItem(fileMenu, "&Add File...\tCtrl+O", CMD_OPEN);
wmAddMenuItem(fileMenu, "&New Class Module", CMD_PRJ_NEW_CLASS);
wmAddMenuItem(fileMenu, "&Save File\tCtrl+S", CMD_SAVE);
wmAddMenuItem(fileMenu, "Save A&ll", CMD_SAVE_ALL);
wmAddMenuSeparator(fileMenu);
wmAddMenuItem(fileMenu, "&Make Executable...", CMD_MAKE_EXE);
wmAddMenuSeparator(fileMenu);
wmAddMenuItem(fileMenu, "R&ename File...", CMD_PRJ_RENAME);
wmAddMenuItem(fileMenu, "&Remove File", CMD_PRJ_REMOVE);
wmAddMenuSeparator(fileMenu);
wmAddMenuItem(fileMenu, "E&xit", CMD_EXIT);
sFileMenuBase = sFileMenu->itemCount;
MenuT *editMenu = wmAddMenu(menuBar, "&Edit");
wmAddMenuItem(editMenu, "Cu&t\tCtrl+X", CMD_CUT);
wmAddMenuItem(editMenu, "&Copy\tCtrl+C", CMD_COPY);
wmAddMenuItem(editMenu, "&Paste\tCtrl+V", CMD_PASTE);
wmAddMenuSeparator(editMenu);
wmAddMenuItem(editMenu, "Select &All\tCtrl+A", CMD_SELECT_ALL);
wmAddMenuSeparator(editMenu);
wmAddMenuItem(editMenu, "&Delete\tDel", CMD_DELETE);
wmAddMenuSeparator(editMenu);
wmAddMenuItem(editMenu, "&Find...\tCtrl+F", CMD_FIND);
wmAddMenuItem(editMenu, "Find &Next\tF3", CMD_FIND_NEXT);
wmAddMenuItem(editMenu, "&Replace...\tCtrl+H", CMD_REPLACE);
MenuT *runMenu = wmAddMenu(menuBar, "&Run");
wmAddMenuItem(runMenu, "&Run\tF5", CMD_RUN);
wmAddMenuItem(runMenu, "&Debug\tShift+F5", CMD_DEBUG);
wmAddMenuItem(runMenu, "Run &Without Recompile\tCtrl+F5", CMD_RUN_NOCMP);
wmAddMenuItem(runMenu, "&Stop\tEsc", CMD_STOP);
wmAddMenuSeparator(runMenu);
wmAddMenuItem(runMenu, "Step &Into\tF8", CMD_STEP_INTO);
wmAddMenuItem(runMenu, "Step &Over\tShift+F8", CMD_STEP_OVER);
wmAddMenuItem(runMenu, "Step Ou&t\tCtrl+Shift+F8", CMD_STEP_OUT);
wmAddMenuItem(runMenu, "Run to &Cursor\tCtrl+F8", CMD_RUN_TO_CURSOR);
wmAddMenuSeparator(runMenu);
wmAddMenuCheckItem(runMenu, "Output Window to &Log", CMD_OUTPUT_TO_LOG, false);
wmAddMenuSeparator(runMenu);
wmAddMenuItem(runMenu, "Toggle &Breakpoint\tF9", CMD_TOGGLE_BP);
wmAddMenuSeparator(runMenu);
wmAddMenuItem(runMenu, "Cl&ear Output", CMD_CLEAR);
wmAddMenuSeparator(runMenu);
wmAddMenuCheckItem(runMenu, "S&ave on Run", CMD_SAVE_ON_RUN, true);
MenuT *viewMenu = wmAddMenu(menuBar, "&View");
wmAddMenuItem(viewMenu, "&Code\tF7", CMD_VIEW_CODE);
wmAddMenuItem(viewMenu, "&Designer\tShift+F7", CMD_VIEW_DESIGN);
wmAddMenuSeparator(viewMenu);
wmAddMenuCheckItem(viewMenu, "&Toolbar", CMD_VIEW_TOOLBAR, true);
wmAddMenuCheckItem(viewMenu, "&Status Bar", CMD_VIEW_STATUS, true);
wmAddMenuSeparator(viewMenu);
wmAddMenuItem(viewMenu, "&Menu Editor...\tCtrl+E", CMD_MENU_EDITOR);
MenuT *winMenu = wmAddMenu(menuBar, "&Window");
wmAddMenuItem(winMenu, "&Code Editor", CMD_WIN_CODE);
wmAddMenuItem(winMenu, "&Output", CMD_WIN_OUTPUT);
wmAddMenuItem(winMenu, "&Immediate", CMD_WIN_IMM);
wmAddMenuItem(winMenu, "&Locals", CMD_WIN_LOCALS);
wmAddMenuItem(winMenu, "Call &Stack", CMD_WIN_CALLSTACK);
wmAddMenuItem(winMenu, "&Watch", CMD_WIN_WATCH);
wmAddMenuItem(winMenu, "&Breakpoints", CMD_WIN_BREAKPOINTS);
wmAddMenuSeparator(winMenu);
wmAddMenuItem(winMenu, "&Project Explorer", CMD_WIN_PROJECT);
wmAddMenuItem(winMenu, "&Toolbox", CMD_WIN_TOOLBOX);
wmAddMenuItem(winMenu, "P&roperties", CMD_WIN_PROPS);
MenuT *toolsMenu = wmAddMenu(menuBar, "&Tools");
wmAddMenuItem(toolsMenu, "&Preferences...", CMD_PREFERENCES);
wmAddMenuSeparator(toolsMenu);
wmAddMenuCheckItem(toolsMenu, "Debug &Layout", CMD_DEBUG_LAYOUT, false);
MenuT *helpMenu = wmAddMenu(menuBar, "&Help");
wmAddMenuItem(helpMenu, "&DVX BASIC Help\tF1", CMD_HELP_CONTENTS);
wmAddMenuItem(helpMenu, "DVX &API Reference", CMD_HELP_API);
wmAddMenuSeparator(helpMenu);
wmAddMenuItem(helpMenu, "A&bout DVX BASIC...", CMD_HELP_ABOUT);
AccelTableT *accel = dvxCreateAccelTable();
dvxAddAccel(accel, 'O', ACCEL_CTRL, CMD_OPEN);
dvxAddAccel(accel, 'S', ACCEL_CTRL, CMD_SAVE);
dvxAddAccel(accel, KEY_F5, 0, CMD_RUN);
dvxAddAccel(accel, KEY_F5, ACCEL_SHIFT, CMD_DEBUG);
dvxAddAccel(accel, KEY_F5, ACCEL_CTRL, CMD_RUN_NOCMP);
dvxAddAccel(accel, KEY_F7, 0, CMD_VIEW_CODE);
dvxAddAccel(accel, KEY_F7, ACCEL_SHIFT, CMD_VIEW_DESIGN);
dvxAddAccel(accel, KEY_ESCAPE, 0, CMD_STOP);
dvxAddAccel(accel, 'F', ACCEL_CTRL, CMD_FIND);
dvxAddAccel(accel, 'H', ACCEL_CTRL, CMD_REPLACE);
dvxAddAccel(accel, KEY_F3, 0, CMD_FIND_NEXT);
dvxAddAccel(accel, 'E', ACCEL_CTRL, CMD_MENU_EDITOR);
dvxAddAccel(accel, KEY_F8, 0, CMD_STEP_INTO);
dvxAddAccel(accel, KEY_F8, ACCEL_SHIFT, CMD_STEP_OVER);
dvxAddAccel(accel, KEY_F8, ACCEL_CTRL | ACCEL_SHIFT, CMD_STEP_OUT);
dvxAddAccel(accel, KEY_F8, ACCEL_CTRL, CMD_RUN_TO_CURSOR);
dvxAddAccel(accel, KEY_F9, 0, CMD_TOGGLE_BP);
sWin->accelTable = accel;
WidgetT *tbRoot = wgtInitWindow(sAc, sWin);
sToolbar = wgtToolbar(tbRoot);
WidgetT *tb = sToolbar;
// File group
WidgetT *tbOpen = loadTbIcon(tb, "tb_open", "Open");
tbOpen->onClick = onTbOpen;
// Button opens the project; Ctrl+O is bound to Add File, so the tooltip
// must not advertise a shortcut the button doesn't perform.
wgtSetTooltip(tbOpen, "Open Project...");
WidgetT *tbSave = loadTbIcon(tb, "tb_save", "Save");
tbSave->onClick = onTbSave;
wgtSetTooltip(tbSave, "Save (Ctrl+S)");
WidgetT *sep1 = wgtVSeparator(tb);
sep1->minW = wgtPixels(IDE_TOOLBAR_SEP_W);
// Run group
sTbRun = loadTbIcon(tb, "tb_run", "Run");
sTbRun->onClick = onTbRun;
wgtSetTooltip(sTbRun, "Run (F5)");
sTbStop = loadTbIcon(tb, "tb_stop", "Stop");
sTbStop->onClick = onTbStop;
wgtSetTooltip(sTbStop, "Stop (Esc)");
WidgetT *sep2 = wgtVSeparator(tb);
sep2->minW = wgtPixels(IDE_TOOLBAR_SEP_W);
// Debug group
sTbDebug = loadTbIcon(tb, "tb_debug", "Debug");
sTbDebug->onClick = onTbDebug;
wgtSetTooltip(sTbDebug, "Debug (Shift+F5)");
sTbStepInto = loadTbIcon(tb, "tb_stepin", "Into");
sTbStepInto->onClick = onTbStepInto;
wgtSetTooltip(sTbStepInto, "Step Into (F8)");
sTbStepOver = loadTbIcon(tb, "tb_stepov", "Over");
sTbStepOver->onClick = onTbStepOver;
wgtSetTooltip(sTbStepOver, "Step Over (Shift+F8)");
sTbStepOut = loadTbIcon(tb, "tb_stepou", "Out");
sTbStepOut->onClick = onTbStepOut;
wgtSetTooltip(sTbStepOut, "Step Out (Ctrl+Shift+F8)");
sTbRunToCur = loadTbIcon(tb, "tb_runtoc", "Cursor");
sTbRunToCur->onClick = onTbRunToCur;
wgtSetTooltip(sTbRunToCur, "Run to Cursor (Ctrl+F8)");
WidgetT *sep3 = wgtVSeparator(tb);
sep3->minW = wgtPixels(IDE_TOOLBAR_SEP_W);
// View group
sTbCode = loadTbIcon(tb, "tb_code", "Code");
sTbCode->onClick = onTbCode;
wgtSetTooltip(sTbCode, "Code View (F7)");
sTbDesign = loadTbIcon(tb, "tb_design", "Design");
sTbDesign->onClick = onTbDesign;
wgtSetTooltip(sTbDesign, "Design View (Shift+F7)");
sStatusBar = wgtStatusBar(tbRoot);
WidgetT *statusBar = sStatusBar;
sStatus = wgtLabel(statusBar, "");
sStatus->weight = WGT_WEIGHT_FILL;
// Fit height to content, keeping full screen width
dvxFitWindowH(sAc, sWin);
// Initialize designer (form window created on demand)
dsgnInit(&sDesigner, sAc);
sDesigner.projectDir = sProject.projectDir;
showOutputWindow();
showImmediateWindow();
dvxRaiseWindow(sAc, sWin);
}
// classEventsOf -- the Events class module className declares (none when
// the project has no such class), appended to *events
static void classEventsOf(const char *className, IdeClassEventT **events) {
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (sProject.files[i].kind != PrjKindClassE) {
continue;
}
bool missing = false;
char *owned = NULL;
const char *text = (i == sEditorFileIdx) ? getFullSource() : projectFileText(i, &owned, &missing);
char name[BAS_MAX_IDENT];
bool match = text && prjClassName(&sProject, i, text, name, (int32_t)sizeof(name)) && strcasecmp(name, className) == 0;
if (match) {
scanClassEvents(text, events);
}
free(owned);
if (match) {
return;
}
}
}
// classFollowsFile -- whether class module fileIdx (whose text is given)
// is named after its file: it has no Attribute VB_Name, or one equal to
// the file's base name (as File > New Class Module writes it)
static bool classFollowsFile(int32_t fileIdx, const char *text) {
char attrName[BAS_MAX_IDENT];
char fileName[BAS_MAX_IDENT];
basExtractClassName("", 0, sProject.files[fileIdx].path, fileName, (int32_t)sizeof(fileName));
return !basExtractClassName(text, (int32_t)strlen(text), NULL, attrName, (int32_t)sizeof(attrName)) || strcasecmp(attrName, fileName) == 0;
}
// classifyWord -- the syntax color of a word. afterDot: it names a
// member (obj.Width), where only reserved words keep their color.
static uint8_t classifyWord(const char *word, int32_t wordLen, bool afterDot) {
char upper[IDE_WORD_BUF];
if (wordLen <= 0 || wordLen >= IDE_WORD_BUF) {
return TEXT_SYNTAX_DEFAULT;
}
for (int32_t i = 0; i < wordLen; i++) {
upper[i] = (char)toupper((unsigned char)word[i]);
}
upper[wordLen] = '\0';
initSyntaxMap();
int32_t idx = shgeti(sSyntaxMap, upper);
if (idx < 0 || (afterDot && (sSyntaxMap[idx].value & IDE_SYNTAX_UNRESERVED))) {
return TEXT_SYNTAX_DEFAULT;
}
return sSyntaxMap[idx].value & (uint8_t)~IDE_SYNTAX_UNRESERVED;
}
// classNameUsed -- true when a project file is named fileName or a form
// or class module of the project is called name
static bool classNameUsed(const char *name, const char *fileName) {
bool used = false;
for (int32_t i = 0; i < prjFileCount(&sProject) && !used; i++) {
PrjFileT *file = &sProject.files[i];
used = strcasecmp(file->path, fileName) == 0 || (file->kind == PrjKindFormE && strcasecmp(file->formName, name) == 0);
if (!used && file->kind == PrjKindClassE) {
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(i, &owned, &missing);
char other[BAS_MAX_IDENT];
used = prjClassName(&sProject, i, text, other, (int32_t)sizeof(other)) && strcasecmp(other, name) == 0;
free(owned);
}
}
return used;
}
// cleanupFormWin -- release designer-related state without destroying
// the form window itself (the caller handles that).
static void cleanupFormWin(void) {
sFormWin = NULL;
sDesigner.formWin = NULL;
// Null out widget pointers -- the widgets were destroyed with the window.
// Without this, dsgnCreateWidgets skips controls that have non-NULL
// widget pointers, resulting in an empty form on the second open.
if (sDesigner.form) {
int32_t count = (int32_t)arrlen(sDesigner.form->controls);
for (int32_t i = 0; i < count; i++) {
sDesigner.form->controls[i]->widget = NULL;
}
sDesigner.form->contentBox = NULL;
}
if (sToolboxWin) {
tbxDestroy(sAc, sToolboxWin);
sToolboxWin = NULL;
}
if (sPropsWin) {
prpDestroy(sAc, sPropsWin);
sPropsWin = NULL;
}
}
static void clearAllBreakpoints(void) {
arrsetlen(sBreakpoints, 0);
// A live VM still points at sVmBreakpoints; detach before freeing.
if (sVm) {
basVmSetBreakpoints(sVm, NULL, 0);
}
arrfree(sVmBreakpoints);
sVmBreakpoints = NULL;
updateBreakpointWindow();
}
static void clearOutput(void) {
sOutputBuf[0] = '\0';
sOutputLen = 0;
sOutputPending = false;
setOutputText("");
}
// clearVmStepState -- cancel any pending step/run-to-cursor request
static void clearVmStepState(void) {
if (!sVm) {
return;
}
sVm->debugBreak = false;
sVm->stepOverDepth = -1;
sVm->stepOutDepth = -1;
sVm->runToCursorLine = -1;
}
static void closeFindDialog(void) {
if (sFindWin) {
dvxDestroyWindow(sAc, sFindWin);
sFindWin = NULL;
sFindInput = NULL;
sReplInput = NULL;
sReplCheck = NULL;
sBtnReplace = NULL;
sBtnReplAll = NULL;
sCaseCheck = NULL;
sScopeGroup = NULL;
sDirGroup = NULL;
}
}
// closeProject -- callers prompt for unsaved edits first (promptAndSave),
// which saves on Yes. Nothing is written here, so Don't Save discards
// changes to the .dbp as well as to the files.
static void closeProject(void) {
if (!hasProject()) {
return;
}
closeFindDialog();
closeProjectUi();
invalidateCompiled();
prjClose(&sProject);
updateMainTitle();
setStatus("Project closed.");
updateProjectMenuState();
}
// closeProjectUi -- destroy every per-project window and buffer. Safe to
// call when nothing is open (every step checks its own state).
static void closeProjectUi(void) {
designerRelease();
// Toolbox/properties can exist without a form window (Window menu)
if (sToolboxWin) {
tbxDestroy(sAc, sToolboxWin);
sToolboxWin = NULL;
}
if (sPropsWin) {
prpDestroy(sAc, sPropsWin);
sPropsWin = NULL;
}
if (sCodeWin) {
dvxDestroyWindow(sAc, sCodeWin);
sCodeWin = NULL;
sEditor = NULL;
sObjDropdown = NULL;
sEvtDropdown = NULL;
}
freeProcBufs();
clearAllBreakpoints();
if (sProjectWin) {
prjDestroyWindow(sAc, sProjectWin);
sProjectWin = NULL;
}
}
// Sort event names: implemented (no brackets) first, then unimplemented
// ([brackets]), alphabetically within each group.
static int cmpEvtPtrs(const void *a, const void *b) {
const char *sa = *(const char **)a;
const char *sb = *(const char **)b;
bool aImpl = (sa[0] != '[');
bool bImpl = (sb[0] != '[');
if (aImpl != bImpl) {
return aImpl ? -1 : 1;
}
// Skip brackets for alphabetical comparison
if (sa[0] == '[') {
sa++;
}
if (sb[0] == '[') {
sb++;
}
return strcasecmp(sa, sb);
}
static int cmpStrPtrs(const void *a, const void *b) {
const char *sa = *(const char **)a;
const char *sb = *(const char **)b;
return strcasecmp(sa, sb);
}
static void compileAndRun(void) {
// A stopped program that has not unwound yet still runs sCachedModule
if (sVm) {
return;
}
if (compileProject()) {
runModule(sCachedModule);
}
}
static bool compileProject(void) {
// Save all dirty files before compiling if Save on Run is enabled
if (sWin && sWin->menuBar && wmMenuItemIsChecked(sWin->menuBar, CMD_SAVE_ON_RUN)) {
saveAllModified();
}
// Stash editor/designer state into the project buffers (the compile
// source) before going busy: a stash failure shows a dialog, and no
// dialog can be answered while the busy state swallows input.
if (hasProject() && !stashCurrentFile()) {
setStatus("Compilation cancelled.");
return false;
}
clearOutput();
setStatus("Compiling...");
dvxSetBusy(sAc, true);
dvxUpdate(sAc);
// Build source: either concatenate project files or use editor contents
BasProjectSourceT project;
IdeValidatorCtxT validatorCtx;
const char *src = NULL;
int32_t srcLen = 0;
memset(&project, 0, sizeof(project));
memset(&validatorCtx, 0, sizeof(validatorCtx));
if (hasProject() && prjFileCount(&sProject) > 0) {
// Concatenate all files (each normalized to the canonical proc
// layout) with the same BEGINFORM/ENDFORM wrapping bascomp and
// basrun use, recording where each file lands for the source map.
// The one parse of each .frm also builds the name -> widget-type
// map the validator below checks CtrlName.Member against.
arrfree(sProject.sourceMap);
sProject.sourceMap = NULL;
// One pass per file kind in compile order: .bas modules first (so
// CONST declarations are available), then .cls class modules,
// then .frm code sections (see basBuildConcatProject).
for (int32_t kind = 0; kind < PrjKindCountE; kind++) {
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (sProject.files[i].kind != kind) {
continue;
}
char *ctrlList = NULL;
char *fileSrc = loadCompileSource(i, &validatorCtx, &ctrlList);
if (!fileSrc) {
sOutputLen = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, 0, "COMPILE ERROR:\nCannot read %s (missing or larger than %d bytes).\n", sProject.files[i].path, (int)IDE_MAX_SOURCE);
showCompileError("Compilation failed: cannot read file.");
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
return false;
}
int32_t fileLen = (int32_t)strlen(fileSrc);
// BEGINFORM/ENDFORM directives plus a trailing newline
if (project.sourceLen + fileLen + IDE_SOURCE_MARGIN >= IDE_MAX_SOURCE) {
sOutputLen = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, 0, "COMPILE ERROR:\nProject source exceeds %d bytes at %s.\n", (int)IDE_MAX_SOURCE, sProject.files[i].path);
showCompileError("Compilation failed: source too large.");
free(fileSrc);
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
return false;
}
// startLine is recorded AFTER the injected BEGINFORM /
// BEGINCLASS so the source map lines match what the editor
// shows.
BasSourceMapT mapEntry;
memset(&mapEntry, 0, sizeof(mapEntry));
snprintf(mapEntry.path, sizeof(mapEntry.path), "%s", sProject.files[i].path);
bool ok = appendCompileFile(&project, i, fileSrc, fileLen, ctrlList, &mapEntry);
free(fileSrc);
free(ctrlList);
if (!ok) {
setStatus(project.error);
dvxSetBusy(sAc, false);
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
return false;
}
arrput(sProject.sourceMap, mapEntry);
dvxUpdate(sAc);
}
}
src = project.source;
srcLen = project.sourceLen;
} else {
// No project files -- compile the full source
src = getFullSource();
if (!src || *src == '\0') {
setStatus("No source code to compile.");
dvxSetBusy(sAc, false);
return false;
}
srcLen = (int32_t)strlen(src);
}
// Reject unknown widget types up front -- the .frm parse records
// any `Begin <Type> <Name>` whose type isn't registered by a .wgt
// DXE. Those would silently drop the control at runtime and
// produce a misleading "control not found" error on first access.
if (arrlen(validatorCtx.badTypes) > 0) {
int32_t n = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, 0, "COMPILE ERROR:\nUnknown widget type(s) in .frm files:\n");
for (int32_t i = 0; i < (int32_t)arrlen(validatorCtx.badTypes) && n < IDE_MAX_OUTPUT - IDE_OUTPUT_LINE_RESERVE; i++) {
IdeBadTypeT *b = &validatorCtx.badTypes[i];
n = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, n, " Form '%s' control '%s': type '%s' is not registered.\n", b->formName, b->ctrlName, b->typeName);
}
n = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, n, "\nDVX uses VB6-style widget names (e.g. SpinButton, OptionButton, HScrollBar, CheckBox, DropDown).\n");
sOutputLen = n;
showCompileError("Compilation failed: unknown widget type.");
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
return false;
}
BasCompilerT *compiler = basCompilerCreate(src, srcLen);
if (!compiler) {
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
setStatus("Out of memory.");
dvxSetBusy(sAc, false);
return false;
}
basCompilerSetOptionExplicit(compiler, sProject.optionExplicit);
// The validator lets the compiler reject CtrlName.Member typos at compile
// time; it falls back silently for dynamically-created controls (not
// in the map).
BasCtrlValidatorT validator;
validator.lookupCtrlType = validatorLookupCtrlType;
validator.isMethodValid = validatorIsMethodValid;
validator.isPropValid = validatorIsPropValid;
validator.ctx = &validatorCtx;
validatorCtx.compiler = compiler;
basCompilerSetValidator(compiler, &validator);
if (!basCompile(compiler)) {
// Navigation may raise dialogs (a form that cannot be stashed)
dvxSetBusy(sAc, false);
// Translate global error line to local file/line for display
int32_t errFileIdx = -1;
int32_t errLocalLine = basCompilerErrorLine(compiler);
const char *errFile = "";
if (basCompilerErrorLine(compiler) > 0 && prjFileCount(&sProject) > 0) {
prjMapLine(&sProject, basCompilerErrorLine(compiler), &errFileIdx, &errLocalLine);
if (errFileIdx >= 0 && errFileIdx < prjFileCount(&sProject)) {
errFile = sProject.files[errFileIdx].path;
}
}
// Navigate to the error location; the proc it lands in names it
char procName[IDE_FULL_NAME_BUF] = {0};
int32_t procLine = errLocalLine;
if (basCompilerErrorLine(compiler) > 0 && errFileIdx >= 0) {
int32_t procIdx = navigateToCodeLine(errFileIdx, errLocalLine, false);
// The caret goes to the column the error is at, when known
if (basCompilerErrorCol(compiler) > 0 && sEditor) {
wgtTextAreaSetCursor(sEditor, wgtTextAreaGetCursorLine(sEditor), basCompilerErrorCol(compiler));
}
if (procIdx >= 0 && procIdx < (int32_t)arrlen(sProcTable)) {
snprintf(procName, sizeof(procName), "%s.%s", sProcTable[procIdx].objName, sProcTable[procIdx].evtName);
procLine = wgtTextAreaGetCursorLine(sEditor);
}
}
// Strip the "Line N, Col M: " prefix from the compiler's error
const char *msg = basCompilerError(compiler);
if (kwMatch(msg, KW_LINE_PREFIX)) {
while (*msg && *msg != ':') {
msg++;
}
if (*msg == ':') {
msg++;
}
msg = dvxSkipWs(msg);
}
// Show the error with procedure name and proc-relative line
if (procName[0]) {
sOutputLen = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, 0, "COMPILE ERROR:\n%s line %d: %s\n", procName, (int)procLine, msg);
} else {
sOutputLen = emitClamped(sOutputBuf, IDE_MAX_OUTPUT, 0, "COMPILE ERROR:\n%s line %d: %s\n", errFile, (int)errLocalLine, msg);
}
showCompileError("Compilation failed.");
basCompilerDestroy(compiler);
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
return false;
}
basBuildFreeProject(&project);
validatorFree(&validatorCtx);
BasModuleT *mod = basCompilerBuildModule(compiler);
basCompilerDestroy(compiler);
if (!mod) {
setStatus("Failed to build module.");
dvxSetBusy(sAc, false);
return false;
}
dvxSetBusy(sAc, false);
// Cache the compiled module for Ctrl+F5
if (sCachedModule) {
basModuleFree(sCachedModule);
}
sCachedModule = mod;
// Update Object/Event dropdowns
updateDropdowns();
return true;
}
static int32_t countLines(const char *text) {
if (!text || !text[0]) {
return 1;
}
int32_t n = 1;
for (const char *p = text; *p; p++) {
if (*p == '\n') {
n++;
}
}
return n;
}
// createEventSubSkeleton -- append an empty "Sub Obj_Evt ... End Sub" to
// the proc buffers and show it in the editor. Not marked dirty yet;
// if the user adds no code it is discarded once the editor leaves it.
static void createEventSubSkeleton(const char *objName, const char *evtName) {
char subName[IDE_SKELETON_BUF];
char skeleton[IDE_SKELETON_BUF];
char classParams[IDE_EVENT_PARAMS_BUF];
const char *params = getEventParams(evtName);
const IdeWithEventsT *withEvents = findWithEvents(objName);
// A WithEvents variable's handler takes its class Event's parameters
if (withEvents) {
IdeClassEventT *events = NULL;
classEventsOf(withEvents->className, &events);
classParams[0] = '\0';
for (int32_t i = 0; i < (int32_t)arrlen(events); i++) {
if (strcasecmp(events[i].name, evtName) == 0) {
snprintf(classParams, sizeof(classParams), "%s", events[i].params);
}
}
arrfree(events);
params = classParams;
}
snprintf(subName, sizeof(subName), "%s" BAS_EVENT_HANDLER_SEP "%s", objName, evtName);
// Control-array handlers take a leading Index argument
if (isCtrlArrayInDesigner(objName)) {
snprintf(skeleton, sizeof(skeleton), "Sub %s (Index As Integer%s%s)\n\nEnd Sub\n", subName, params[0] ? ", " : "", params);
} else {
snprintf(skeleton, sizeof(skeleton), "Sub %s (%s)\n\nEnd Sub\n", subName, params);
}
char *buf = strdup(skeleton);
if (!buf) {
return;
}
arrput(sProcBufs, buf);
// Show the new procedure (it's the last one); showProc stashes the
// outgoing editor text and adjusts the index if that discarded an
// earlier empty skeleton. Then refresh sProcTable so breakpoints
// and line translation know about the new proc.
showProc((int32_t)arrlen(sProcBufs) - 1);
joinProcBufs();
snprintf(sSkeletonName, sizeof(sSkeletonName), "%s", subName);
}
// currentObjName -- the object picked in the code window's Object
// dropdown ("" when none)
static void currentObjName(char *out, int32_t outSize) {
int32_t objIdx = sObjDropdown ? wgtDropdownGetSelected(sObjDropdown) : -1;
snprintf(out, (size_t)outSize, "%s", (objIdx >= 0 && objIdx < (int32_t)arrlen(sObjItems)) ? sObjItems[objIdx] : "");
}
static uint32_t debugLineDecorator(int32_t lineNum, uint32_t *gutterColor, void *ctx) {
AppContextT *ac = (AppContextT *)ctx;
// Convert editor line to file code line
int32_t codeLine = editorLineToCodeLine(lineNum);
int32_t fileIdx = sEditorFileIdx;
// Breakpoint: red gutter dot
for (int32_t i = 0; i < (int32_t)arrlen(sBreakpoints); i++) {
if (sBreakpoints[i].fileIdx == fileIdx && sBreakpoints[i].codeLine == codeLine) {
*gutterColor = packColor(&ac->display, IDE_BP_GUTTER_R, IDE_BP_GUTTER_G, IDE_BP_GUTTER_B);
break;
}
}
// Current debug line: yellow background (sDbgCurrentLine is editor-local)
if (sDbgState == DbgPausedE && lineNum == sDbgCurrentLine) {
return packColor(&ac->display, IDE_DBG_LINE_R, IDE_DBG_LINE_G, IDE_DBG_LINE_B);
}
return 0;
}
// debugNavigateToLine -- show the paused (or failing) statement. The
// file and line come from the source map; the procedure is picked by
// line range in that file once it is active.
static void debugNavigateToLine(int32_t concatLine) {
if (concatLine <= 0) {
return;
}
int32_t fileIdx = -1;
int32_t localLine = concatLine;
// prjMapLine returns a line relative to the code section (startLine in
// the source map is recorded AFTER the injected BEGINFORM directive).
prjMapLine(&sProject, concatLine, &fileIdx, &localLine);
navigateToCodeLine(fileIdx, localLine, true);
}
// debugResume -- common tail of every continue/step command: the caller
// has already configured the VM's step state.
static void debugResume(const char *status) {
sDbgCurrentLine = -1;
sDbgState = DbgRunningE;
debugSetBreakTitles(false);
if (sVm) {
sVm->debugPaused = false;
sVm->running = true;
}
if (sEditor) {
wgtInvalidatePaint(sEditor);
}
updateProjectMenuState();
setStatus(status);
}
// debugSetBreakTitles -- tag every running form's caption with " [break]"
// while paused, and put the saved captions back on resume.
static void debugSetBreakTitles(bool paused) {
if (!paused) {
for (int32_t t = 0; t < (int32_t)arrlen(sBreakTitles); t++) {
for (int32_t i = 0; sDbgFormRt && i < (int32_t)arrlen(sDbgFormRt->forms); i++) {
BasFormT *form = sDbgFormRt->forms[i];
if (form == sBreakTitles[t].form && form->window) {
dvxSetTitle(sAc, form->window, sBreakTitles[t].title);
}
}
}
arrsetlen(sBreakTitles, 0);
return;
}
if (!sDbgFormRt || arrlen(sBreakTitles) > 0) {
return;
}
for (int32_t i = 0; i < (int32_t)arrlen(sDbgFormRt->forms); i++) {
BasFormT *form = sDbgFormRt->forms[i];
if (!form->window) {
continue;
}
IdeBreakTitleT saved;
char tagged[MAX_TITLE_LEN];
saved.form = form;
snprintf(saved.title, sizeof(saved.title), "%s", form->window->title);
arrput(sBreakTitles, saved);
snprintf(tagged, sizeof(tagged), "%s%s", saved.title, IDE_BREAK_TAG);
dvxSetTitle(sAc, form->window, tagged);
}
}
static void debugStartOrResume(int32_t cmd) {
if (sDbgState == DbgPausedE && sVm) {
// Already paused -- apply the appropriate step command and resume
switch (cmd) {
case CMD_STEP_INTO:
basVmStepInto(sVm);
break;
case CMD_STEP_OVER:
basVmStepOver(sVm);
break;
case CMD_STEP_OUT:
basVmStepOut(sVm);
break;
case CMD_RUN_TO_CURSOR:
if (sEditor) {
basVmRunToCursor(sVm, localToConcatLine(wgtTextAreaGetCursorLine(sEditor)));
}
break;
default:
break;
}
debugResume("Running...");
return;
}
if (sDbgState == DbgIdleE) {
// Not running -- compile and start in debug mode.
sDbgEnabled = true;
sDbgBreakOnStart = true;
compileAndRun();
sDbgBreakOnStart = false;
}
}
// debugStop -- request the running program to stop. runModule's loops and
// doEventsCallback observe sStopRequested and unwind; until runModule has
// returned the state stays DbgStoppingE, so nothing can start a new run
// or free the module the unwinding VM is still executing.
static void debugStop(void) {
sStopRequested = true;
// Nothing may pause the VM again while it unwinds
clearVmStepState();
if (sVm) {
sVm->running = false;
sVm->debugPaused = false;
basVmSetBreakpoints(sVm, NULL, 0);
}
debugSetBreakTitles(false);
sDbgState = sVm ? DbgStoppingE : DbgIdleE;
sDbgCurrentLine = -1;
sDbgEnabled = false;
if (sEditor) {
wgtInvalidatePaint(sEditor);
}
updateProjectMenuState();
}
static void debugUpdateWindows(void) {
// Auto-show debug windows if not already open
if (!sLocalsWin) {
showLocalsWindow();
} else if (!sLocalsWin->visible) {
dvxShowWindow(sAc, sLocalsWin);
}
if (!sCallStackWin) {
showCallStackWindow();
} else if (!sCallStackWin->visible) {
dvxShowWindow(sAc, sCallStackWin);
}
updateLocalsWindow();
updateCallStackWindow();
updateWatchWindow();
}
// debugVarVisible -- whether a debug variable is in scope where the VM is
// paused: locals of the current proc, module variables, the variables of the
// form whose code is running (form variables of different forms share
// slot numbers, so the form must match) and the member variables of the
// object a class procedure runs for.
static bool debugVarVisible(const BasDebugVarT *dv, int32_t curProcIdx) {
if (dv->scope == SCOPE_MEMBER) {
return memberVarSlot(dv) != NULL;
}
// Locals and a procedure's SHARED / STATIC names belong to that
// procedure; inside a procedure a module variable shows only when it
// is DIM SHARED (QBasic scope).
if (dv->procIndex >= 0) {
if (dv->procIndex != curProcIdx) {
return false;
}
} else if (curProcIdx >= 0 && !dv->shared) {
return false;
}
if (dv->scope != SCOPE_FORM) {
return true;
}
if (!sVm->currentFormVars) {
return false;
}
if (!dv->formName[0]) {
return true;
}
return sVm->currentForm && strcasecmp(dv->formName, ((const BasFormT *)sVm->currentForm)->name) == 0;
}
// dedupeBreakpoints -- drop a breakpoint that lands on the same line of
// the same file as an earlier one (edits can join lines). Returns true
// if any was dropped.
static bool dedupeBreakpoints(void) {
bool changed = false;
for (int32_t i = (int32_t)arrlen(sBreakpoints) - 1; i > 0; i--) {
for (int32_t j = 0; j < i; j++) {
if (sBreakpoints[j].fileIdx == sBreakpoints[i].fileIdx && sBreakpoints[j].codeLine == sBreakpoints[i].codeLine) {
arrdel(sBreakpoints, i);
changed = true;
break;
}
}
}
return changed;
}
// deleteSelectedControl -- remove the designer's selected control and
// refresh the properties panel / form window when something changed.
static void deleteSelectedControl(void) {
if (!sDesigner.form || sDesigner.selectedIdx < 0) {
return;
}
int32_t prevCount = (int32_t)arrlen(sDesigner.form->controls);
dsgnOnKey(&sDesigner, KEY_DELETE);
int32_t newCount = (int32_t)arrlen(sDesigner.form->controls);
if (newCount != prevCount) {
sDesigner.form->dirty = true;
prpRebuildTree(&sDesigner);
prpRefresh(&sDesigner);
if (sFormWin) {
dvxInvalidateWindow(sAc, sFormWin);
}
updateDirtyIndicators();
}
}
// designerEditCmd -- an Edit menu command applied to the designer's
// selected control
static void designerEditCmd(int32_t cmd) {
switch (cmd) {
case CMD_CUT:
dsgnCopySelected();
deleteSelectedControl();
break;
case CMD_COPY:
dsgnCopySelected();
break;
case CMD_PASTE:
dsgnPasteControl();
break;
case CMD_DELETE:
deleteSelectedControl();
break;
default:
break;
}
}
// designerRelease -- close the designer window and unload its form
static void designerRelease(void) {
teardownFormWin();
dsgnFree(&sDesigner);
sDesignerFileIdx = -1;
}
static bool doEventsCallback(void *ctx) {
(void)ctx;
// Stop if IDE window was closed, DVX is shutting down, or the user
// pressed Stop (the VM's own pause spin only exits on false here).
if (!sWin || !sAc->running || sStopRequested) {
return false;
}
idePump();
return sWin != NULL && sAc->running && !sStopRequested;
}
static void dsgnCopySelected(void) {
if (!sDesigner.form || sDesigner.selectedIdx < 0) {
return;
}
int32_t count = (int32_t)arrlen(sDesigner.form->controls);
if (sDesigner.selectedIdx >= count) {
return;
}
// Serialize the selected control to FRM text with the same writer the
// .frm saver uses, into a heap buffer sized for all of its lines.
const DsgnControlT *ctrl = sDesigner.form->controls[sDesigner.selectedIdx];
int32_t bufSize = dsgnEmitControlSize(ctrl);
char *buf = (char *)malloc((size_t)bufSize);
if (!buf) {
return;
}
int32_t pos = dsgnEmitControl(ctrl, buf, bufSize, 0, 0);
if (pos >= 0) {
dvxClipboardCopy(buf, pos);
} else {
setStatus("A property value of this control is too long to copy.");
}
free(buf);
}
// dsgnPasteControl -- paste a control copied with dsgnCopySelected. The
// clipboard block is read by the designer's own .frm loader, so every
// property (position, Visible, Enabled, HelpTopic, quoted text) comes
// back exactly as a saved form would.
static void dsgnPasteControl(void) {
if (!sDesigner.form || !sDesigner.form->contentBox) {
return;
}
int32_t clipLen = 0;
const char *clip = dvxClipboardGet(&clipLen);
if (!clip || clipLen <= 0 || !kwMatch(dvxSkipWs(clip), FRM_BEGIN_TAG)) {
return;
}
DsgnControlT *ctrl = pasteParseControl(clip, clipLen);
if (!ctrl) {
return;
}
// A control with the same name exists: continue its control array,
// offer to start one, or rename the paste
char newName[DSGN_MAX_NAME];
int32_t newIndex = DSGN_NO_INDEX;
bool nameExists = false;
int32_t highIdx = DSGN_NO_INDEX;
int32_t existCount = (int32_t)arrlen(sDesigner.form->controls);
for (int32_t i = 0; i < existCount; i++) {
if (strcasecmp(sDesigner.form->controls[i]->name, ctrl->name) == 0) {
nameExists = true;
if (sDesigner.form->controls[i]->index > highIdx) {
highIdx = sDesigner.form->controls[i]->index;
}
}
}
if (nameExists && highIdx != DSGN_NO_INDEX) {
snprintf(newName, sizeof(newName), "%s", ctrl->name);
newIndex = highIdx + 1;
} else if (nameExists && dvxMessageBox(sAc, "Paste", "A control with this name already exists.\nCreate a control array?", MB_YESNO | MB_ICONQUESTION) == ID_YES) {
// Convert existing control (and its children's parent link) to index 0
for (int32_t i = 0; i < existCount; i++) {
if (strcasecmp(sDesigner.form->controls[i]->name, ctrl->name) == 0) {
dsgnMakeArrayMember(sDesigner.form, sDesigner.form->controls[i], 0);
break;
}
}
snprintf(newName, sizeof(newName), "%s", ctrl->name);
newIndex = 1;
} else {
dsgnAutoName(&sDesigner, ctrl->typeName, newName, sizeof(newName));
}
snprintf(ctrl->name, sizeof(ctrl->name), "%s", newName);
ctrl->index = newIndex;
ctrl->parentName[0] = '\0';
ctrl->parentIndex = DSGN_NO_INDEX;
arrput(sDesigner.form->controls, ctrl);
dsgnOptionSelected(sDesigner.form, ctrl);
dsgnCreateControlWidget(sDesigner.form, ctrl, sDesigner.form->contentBox);
sDesigner.selectedIdx = (int32_t)arrlen(sDesigner.form->controls) - 1;
sDesigner.form->dirty = true;
prpRebuildTree(&sDesigner);
prpRefresh(&sDesigner);
if (sFormWin) {
dvxInvalidateWindow(sAc, sFormWin);
}
updateDirtyIndicators();
}
// editCmdKey -- the Ctrl key a text window handles for an Edit command
static int32_t editCmdKey(int32_t cmd) {
switch (cmd) {
case CMD_CUT:
return KEY_CTRL_X;
case CMD_COPY:
return KEY_CTRL_C;
case CMD_PASTE:
return KEY_CTRL_V;
case CMD_SELECT_ALL:
return KEY_CTRL_A;
default:
return 0;
}
}
// Converts a 1-based editor line (within the current proc's buffer) to its
// 1-based line in the file's full code. For (General)/no-proc context
// (sCurProcIdx out of range) the editor line is the code line.
static int32_t editorLineToCodeLine(int32_t editorLine) {
if (sCurProcIdx >= 0 && sCurProcIdx < (int32_t)arrlen(sProcTable)) {
return sProcTable[sCurProcIdx].lineNum + editorLine - 1;
}
return editorLine;
}
// editorSetText -- replace the editor text as a load, not a user edit, and
// resync everything derived from it. A section longer than the editor
// holds is shown read-only (and never stored back) instead of being
// silently truncated. caretLine: a 1-based line to put the caret at
// (start of line, nothing selected), IDE_CARET_KEEP for its current line
// number, or IDE_CARET_LOAD.
static void editorSetText(const char *text, int32_t caretLine) {
if (!sEditor) {
return;
}
if (caretLine == IDE_CARET_KEEP) {
caretLine = wgtTextAreaGetCursorLine(sEditor);
}
void (*savedOnChange)(WidgetT *) = sEditor->onChange;
sEditor->onChange = NULL;
wgtSetText(sEditor, text);
sEditor->onChange = savedOnChange;
sEditorTruncated = strlen(text) >= IDE_MAX_SOURCE;
sEditor->readOnly = sEditorTruncated;
if (sEditorTruncated) {
setStatus("This section is too large to edit and is shown read-only.");
}
editorSnapshot(countLines(wgtGetText(sEditor)));
if (caretLine > IDE_CARET_LOAD) {
wgtTextAreaSetCursor(sEditor, caretLine, 1);
}
}
// editorSnapshot -- remember the editor's line count (lineCount, the
// caller has it) and, while the editor's file has breakpoints, its text:
// the base the next edit's breakpoint shift is computed against. With
// no breakpoints no per-keystroke copy is made; adding one snapshots.
static void editorSnapshot(int32_t lineCount) {
sEditorLineCount = lineCount;
bool hasBreakpoints = false;
for (int32_t i = 0; i < (int32_t)arrlen(sBreakpoints) && !hasBreakpoints; i++) {
hasBreakpoints = sBreakpoints[i].fileIdx == sEditorFileIdx;
}
if (!hasBreakpoints) {
free(sEditorPrevText);
sEditorPrevText = NULL;
return;
}
const char *text = wgtGetText(sEditor);
size_t len = text ? strlen(text) : 0;
char *copy = (char *)realloc(sEditorPrevText, len + 1);
if (!copy) {
free(sEditorPrevText);
sEditorPrevText = NULL;
return;
}
memcpy(copy, text ? text : "", len);
copy[len] = '\0';
sEditorPrevText = copy;
}
// Auto-create an implicit project when opening a file without one.
// Derives project name and directory from the file path. Also adds
// a matching .frm file if one exists alongside the .bas.
static void ensureProject(const char *filePath) {
if (hasProject()) {
return;
}
// Derive directory and base name from path
char dir[DVX_MAX_PATH];
char baseName[PRJ_MAX_NAME];
snprintf(dir, sizeof(dir), "%s", filePath);
char *sep = platformPathDirEnd(dir);
const char *fileName = filePath;
if (sep) {
fileName = sep + 1;
*sep = '\0';
} else {
dir[0] = '.';
dir[1] = '\0';
}
// Strip extension for project name
// Length-clamped memcpy instead of strncpy/snprintf because
// GCC warns about both when source (DVX_MAX_PATH) exceeds
// the buffer (PRJ_MAX_NAME), even though truncation is safe.
int32_t nl = (int32_t)strlen(fileName);
if (nl >= PRJ_MAX_NAME) {
nl = PRJ_MAX_NAME - 1;
}
memcpy(baseName, fileName, nl);
baseName[nl] = '\0';
char *dot = strrchr(baseName, '.');
if (dot) {
*dot = '\0';
}
prjNew(&sProject, baseName, dir, sPrefs);
PrjFileKindE kind = prjKindForPath(filePath);
prjAddFile(&sProject, fileName, kind);
// If it's a .bas, check for a matching .frm and add it too. Only the
// file-name part's extension is replaced (a directory may contain dots).
if (kind == PrjKindModuleE) {
char frmPath[DVX_MAX_PATH];
int32_t baseOff = (int32_t)(platformPathBaseName(filePath) - filePath);
snprintf(frmPath, sizeof(frmPath), "%s", filePath);
char *frmDot = strrchr(frmPath + baseOff, '.');
int32_t stemLen = frmDot ? (int32_t)(frmDot - frmPath) : (int32_t)strlen(frmPath);
if (stemLen + (int32_t)sizeof(PRJ_FRM_EXT) <= (int32_t)sizeof(frmPath)) {
snprintf(frmPath + stemLen, sizeof(frmPath) - stemLen, "%s", PRJ_FRM_EXT);
if (prjPathExists(frmPath)) {
prjAddFile(&sProject, platformPathBaseName(frmPath), PrjKindFormE);
}
}
}
sProject.dirty = false;
sProject.activeFileIdx = -1;
prjLoadAllFiles(&sProject, sAc);
updateMainTitle();
setStatus("Project created.");
updateProjectMenuState();
}
// ensureProjectWindow -- create the Project Explorer if needed (wired to
// the shared menu/accelerator handlers), otherwise refresh its tree.
static void ensureProjectWindow(bool raise) {
if (sProjectWin) {
prjRebuildTree(&sProject);
} else {
sProjectWin = prjCreateWindow(sAc, &sProject, onPrjFileDblClick, updateProjectMenuState);
if (!sProjectWin) {
return;
}
sProjectWin->y = toolbarBottom() + IDE_PROJECT_WIN_OFFSET;
sProjectWin->onClose = onProjectWinClose;
sProjectWin->onMenu = onMenu;
sProjectWin->accelTable = sWin ? sWin->accelTable : NULL;
}
if (raise) {
dvxRaiseWindow(sAc, sProjectWin);
}
}
// evaluateImmediate -- compile and execute a single line from the
// Immediate window. If the line doesn't start with a statement keyword,
// wrap it in PRINT so expressions produce visible output.
static void evaluateImmediate(const char *expr) {
if (!expr || *expr == '\0') {
return;
}
// Try assignment first when paused
if (immTryAssign(expr)) {
return;
}
char wrapped[IDE_IMM_WRAP_BUF];
// If it already starts with a statement keyword, use as-is
if (kwMatch(expr, KW_PRINT) || kwMatch(expr, KW_DIM) || kwMatch(expr, KW_LET)) {
snprintf(wrapped, sizeof(wrapped), "%s", expr);
} else {
snprintf(wrapped, sizeof(wrapped), "%s %s", KW_PRINT, expr);
}
BasModuleT *mod = NULL;
char err[IDE_VALUE_BUF];
BasVmT *vm = buildSnippetVm(wrapped, &mod, err, sizeof(err), NULL, NULL);
if (!vm) {
immPrintCallback(NULL, "Error: ", false);
immPrintCallback(NULL, err, true);
return;
}
basVmSetPrintCallback(vm, immPrintCallback, NULL);
immReportSnippetResult(vm, runSnippetVm(vm));
basVmDestroy(vm);
basModuleFree(mod);
}
// evalWatchExpr -- compile and evaluate an expression using the paused VM's
// state. Used as a fallback when lookupWatchVar can't handle the
// expression. Returns the printed result in outBuf.
static bool evalWatchExpr(const char *expr, char *outBuf, int32_t outBufSize) {
if (sDbgState != DbgPausedE || !sVm || !sDbgModule || !sDbgModule->debugVars) {
return false;
}
char wrapped[IDE_IMM_WRAP_BUF];
snprintf(wrapped, sizeof(wrapped), "%s %s", KW_PRINT, expr);
BasModuleT *mod = NULL;
char err[IDE_VALUE_BUF];
BasVmT *tvm = buildSnippetVm(wrapped, &mod, err, sizeof(err), NULL, NULL);
if (!tvm) {
return false;
}
// Set up capture callback
sWatchPrintBuf[0] = '\0';
sWatchPrintLen = 0;
basVmSetPrintCallback(tvm, watchPrintCallback, NULL);
// Run
runSnippetVm(tvm);
// Strip trailing newline
if (sWatchPrintLen > 0 && sWatchPrintBuf[sWatchPrintLen - 1] == '\n') {
sWatchPrintBuf[--sWatchPrintLen] = '\0';
}
snprintf(outBuf, outBufSize, "%s", sWatchPrintBuf);
basVmDestroy(tvm);
basModuleFree(mod);
return sWatchPrintLen > 0;
}
// evtItemAdd -- append an owned Event dropdown label; bracketed marks an
// event that has no code yet
static void evtItemAdd(const char *name, bool bracketed) {
char label[BAS_MAX_IDENT + sizeof("[]") - 1];
snprintf(label, sizeof(label), bracketed ? "[%s]" : "%s", name);
char *copy = strdup(label);
if (copy) {
arrput(sEvtItems, copy);
}
}
// evtItemsReset -- empty the Event dropdown labels (they are owned)
static void evtItemsReset(void) {
for (int32_t i = 0; i < (int32_t)arrlen(sEvtItems); i++) {
free((void *)sEvtItems[i]);
}
arrsetlen(sEvtItems, 0);
}
// evtLabelMatches -- compare an Event dropdown label against an event
// name, ignoring the [] brackets that mark unimplemented events.
static bool evtLabelMatches(const char *label, const char *evtName) {
if (label[0] == '[') {
size_t nameLen = strlen(evtName);
return strncasecmp(label + 1, evtName, nameLen) == 0 && label[nameLen + 1] == ']' && label[nameLen + 2] == '\0';
}
return strcasecmp(label, evtName) == 0;
}
// fileCodeContains -- true if the code of project file fileIdx (a .frm's
// code section, not its layout) contains needle
static bool fileCodeContains(int32_t fileIdx, const char *needle, int32_t needleLen, bool caseSensitive) {
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(fileIdx, &owned, &missing);
IdeFrmScanT scan;
scan.validator = NULL;
scan.code = NULL;
if (text && sProject.files[fileIdx].kind == PrjKindFormE) {
frmScan(text, &scan);
text = scan.code;
}
bool found = procBufContains(text, needle, needleLen, caseSensitive);
free(scan.code);
free(owned);
return found;
}
// findDebugVar -- find a debug variable by name, respecting scope
static const BasDebugVarT *findDebugVar(const char *name) {
if (!sVm || !sDbgModule || !sDbgModule->debugVars) {
return NULL;
}
int32_t curProcIdx = vmCurProcIdx();
for (int32_t i = 0; i < sDbgModule->debugVarCount; i++) {
const BasDebugVarT *dv = &sDbgModule->debugVars[i];
if (strcasecmp(dv->name, name) == 0 && debugVarVisible(dv, curProcIdx)) {
return dv;
}
}
return NULL;
}
// findDialogBuild -- build the Find / Replace widgets into sFindWin.
// Returns false if any widget could not be made.
static bool findDialogBuild(bool showReplace) {
// Radio order is the FindScopeE / FindDirE order
static const char *scopeNames[ScopeCountE] = {
[ScopeFuncE] = "Function",
[ScopeObjE] = "Object",
[ScopeFileE] = "File",
[ScopeProjE] = "Project"
};
static const char *dirNames[FindDirCountE] = {
[FindDirFwdE] = "Forward",
[FindDirBackE] = "Backward"
};
WidgetT *root = wgtInitWindow(sAc, sFindWin);
WidgetT *findRow = root ? wgtHBox(root) : NULL;
sFindInput = (findRow && wgtLabel(findRow, "Find:")) ? wgtTextInput(findRow, IDE_FIND_TEXT_BUF) : NULL;
WidgetT *replRow = sFindInput ? wgtHBox(root) : NULL;
sReplCheck = replRow ? wgtCheckbox(replRow, "Replace:") : NULL;
sReplInput = sReplCheck ? wgtTextInput(replRow, IDE_FIND_TEXT_BUF) : NULL;
// Options row: scope + direction + case
WidgetT *optRow = sReplInput ? wgtHBox(root) : NULL;
WidgetT *scopeFrame = optRow ? wgtFrame(optRow, "Scope") : NULL;
WidgetT *scopeBox = scopeFrame ? wgtVBox(scopeFrame) : NULL;
sScopeGroup = scopeBox ? wgtRadioGroup(scopeBox) : NULL;
WidgetT *dirFrame = sScopeGroup ? wgtFrame(optRow, "Direction") : NULL;
WidgetT *dirBox = dirFrame ? wgtVBox(dirFrame) : NULL;
sDirGroup = dirBox ? wgtRadioGroup(dirBox) : NULL;
WidgetT *caseBox = sDirGroup ? wgtVBox(optRow) : NULL;
sCaseCheck = caseBox ? wgtCheckbox(caseBox, "Match Case") : NULL;
// Buttons
WidgetT *btnRow = sCaseCheck ? wgtHBox(root) : NULL;
WidgetT *btnFind = btnRow ? wgtButton(btnRow, "Find Next") : NULL;
sBtnReplace = btnFind ? wgtButton(btnRow, "Replace") : NULL;
sBtnReplAll = sBtnReplace ? wgtButton(btnRow, "Replace All") : NULL;
WidgetT *btnClose = sBtnReplAll ? wgtButton(btnRow, "Close") : NULL;
if (!btnClose) {
return false;
}
for (int32_t i = 0; i < ScopeCountE; i++) {
if (!wgtRadio(sScopeGroup, scopeNames[i])) {
return false;
}
}
for (int32_t i = 0; i < FindDirCountE; i++) {
if (!wgtRadio(sDirGroup, dirNames[i])) {
return false;
}
}
root->spacing = wgtPixels(IDE_FIND_ROOT_SPACING);
findRow->spacing = wgtPixels(IDE_WIDGET_SPACING);
sFindInput->weight = WGT_WEIGHT_FILL;
replRow->spacing = wgtPixels(IDE_WIDGET_SPACING);
sReplCheck->onChange = onReplCheckChange;
sReplInput->weight = WGT_WEIGHT_FILL;
optRow->spacing = wgtPixels(IDE_WIDGET_SPACING_LG);
btnRow->spacing = wgtPixels(IDE_WIDGET_SPACING);
btnRow->align = AlignEndE;
btnFind->onClick = onFindNext;
sBtnReplace->onClick = onReplace;
sBtnReplAll->onClick = onReplaceAll;
btnClose->onClick = onFindCloseBtn;
wgtSetText(sFindInput, sFindText);
wgtCheckboxSetChecked(sReplCheck, showReplace);
wgtSetText(sReplInput, sReplaceText);
wgtRadioGroupSetSelected(sScopeGroup, ScopeProjE);
wgtRadioGroupSetSelected(sDirGroup, FindDirFwdE);
return true;
}
// findInEditorSections -- search the editor file's sections (General plus
// every proc) other than fromIdx, in scan order away from it: forward
// visits the procs after it, General, then the procs before it; backward
// mirrors that. fromIdx IDE_SECTION_NONE scans every section from the start (forward)
// or the end (backward). objFilter limits the scan to one object's
// sections (NULL = all). The first match is shown and selected.
static bool findInEditorSections(int32_t fromIdx, const char *needle, bool caseSensitive, bool forward, const char *objFilter) {
int32_t needleLen = (int32_t)strlen(needle);
int32_t total = (int32_t)arrlen(sProcBufs) + 1; // General plus every proc
int32_t curPos = fromIdx + 1; // scan position of fromIdx
int32_t count = total - 1;
if (fromIdx < IDE_SECTION_GENERAL) {
curPos = forward ? -1 : total;
count = total;
}
for (int32_t k = 1; k <= count; k++) {
int32_t pos = forward ? curPos + k : curPos - k;
pos = (pos % total + total) % total;
int32_t p = pos - 1; // -1 = General
const char *text = (p < 0) ? sGeneralBuf : sProcBufs[p];
if (sectionInScope(p, objFilter) && procBufContains(text, needle, needleLen, caseSensitive)) {
return showProcAndFind(p, needle, caseSensitive, forward);
}
}
return false;
}
// findInProject -- Find Next within scope, starting at the editor's
// selection: the rest of the shown section, the file's other sections
// (Function scope skips those; Object scope keeps the selected object's),
// then for Project scope the other files in order. Only a file whose
// code really matches is activated. Finally the shown section is
// searched again from its far end, so the search wraps to its origin.
static bool findInProject(const char *needle, bool caseSensitive, bool forward, FindScopeE scope) {
if (!needle || !needle[0] || !sEditor) {
return false;
}
int32_t needleLen = (int32_t)strlen(needle);
char objName[BAS_MAX_IDENT];
// The proc buffers and sProcTable must describe the current editor text
getFullSource();
currentObjName(objName, sizeof(objName));
if (wgtTextAreaFindNext(sEditor, needle, caseSensitive, forward)) {
return true;
}
if (scope != ScopeFuncE && findInEditorSections(sCurProcIdx, needle, caseSensitive, forward, scope == ScopeObjE ? objName : NULL)) {
return true;
}
int32_t fileCount = prjFileCount(&sProject);
// Leaving the file: the other files are searched in their project
// buffers, so the editor's and the designer's state go there first.
if (scope == ScopeProjE && fileCount > 1) {
int32_t step = forward ? 1 : -1;
int32_t startFile = sEditorFileIdx >= 0 ? sEditorFileIdx : sProject.activeFileIdx;
if (!stashCurrentFile()) {
return false;
}
for (int32_t k = 1; startFile >= 0 && k < fileCount; k++) {
int32_t fileIdx = ((startFile + step * k) % fileCount + fileCount) % fileCount;
if (!fileCodeContains(fileIdx, needle, needleLen, caseSensitive)) {
continue;
}
if (!activateFile(fileIdx, ViewCodeE)) {
return false;
}
return findInEditorSections(IDE_SECTION_NONE, needle, caseSensitive, forward, NULL);
}
}
// Wrap around within the shown section
if (!forward) {
wgtTextAreaCursorToEnd(sEditor);
return wgtTextAreaFindNext(sEditor, needle, caseSensitive, forward);
}
// Caret to the start without a selection: a forward search then finds
// a match that begins right there.
wgtTextAreaSetCursor(sEditor, 1, 1);
return wgtTextAreaFindNext(sEditor, needle, caseSensitive, forward);
}
// findMemberVarIdx -- member variable slot of class instance obj called
// name, from the debug variable table (-1 when there is none)
static int32_t findMemberVarIdx(const BasObjectT *obj, const char *name) {
const char *cls = objectClassName(obj);
for (int32_t i = 0; cls && i < sDbgModule->debugVarCount; i++) {
const BasDebugVarT *dv = &sDbgModule->debugVars[i];
if (dv->scope == SCOPE_MEMBER && strcasecmp(dv->formName, cls) == 0 && strcasecmp(dv->name, name) == 0 && dv->index < obj->fieldCount) {
return dv->index;
}
}
return -1;
}
// Case-insensitive strstr replacement (strcasestr is a GNU extension)
static const char *findSubstrNoCase(const char *haystack, const char *needle, int32_t needleLen) {
for (; *haystack; haystack++) {
if (strncasecmp(haystack, needle, needleLen) == 0) {
return haystack;
}
}
return NULL;
}
// findUdtFieldIdx -- field index within a UDT from the debug type table
static int32_t findUdtFieldIdx(int32_t typeId, const char *fieldName) {
for (int32_t t = 0; t < sDbgModule->debugUdtDefCount; t++) {
if (sDbgModule->debugUdtDefs[t].typeId != typeId) {
continue;
}
for (int32_t f = 0; f < sDbgModule->debugUdtDefs[t].fieldCount; f++) {
if (strcasecmp(sDbgModule->debugUdtDefs[t].fields[f].name, fieldName) == 0) {
return f;
}
}
return -1;
}
return -1;
}
// findWithEvents -- the WithEvents variable of the code window's file
// called name, NULL when there is none
static const IdeWithEventsT *findWithEvents(const char *name) {
for (int32_t i = 0; i < (int32_t)arrlen(sWithEvents); i++) {
if (strcasecmp(sWithEvents[i].name, name) == 0) {
return &sWithEvents[i];
}
}
return NULL;
}
// flushOutput -- show buffered program output in the Output pane,
// scrolled to the newest line
static void flushOutput(void) {
if (!sOutputPending) {
return;
}
sOutputPending = false;
setOutputText(sOutputBuf);
if (sOutput) {
wgtTextAreaGoToLine(sOutput, countLines(sOutputBuf));
}
}
static void formatValue(const BasValueT *v, char *buf, int32_t bufSize) {
switch (v->type) {
case BAS_TYPE_INTEGER:
case BAS_TYPE_BYTE:
snprintf(buf, bufSize, "%d", (int)v->intVal);
break;
case BAS_TYPE_CURRENCY: {
BasStringT *text = basValFormatString(*v);
snprintf(buf, bufSize, "%s", text->data);
basStringUnref(text);
break;
}
case BAS_TYPE_LONG:
snprintf(buf, bufSize, "%ld", (long)v->longVal);
break;
case BAS_TYPE_SINGLE:
snprintf(buf, bufSize, "%.6g", (double)v->sngVal);
break;
case BAS_TYPE_DOUBLE:
snprintf(buf, bufSize, "%.10g", v->dblVal);
break;
case BAS_TYPE_BOOLEAN:
snprintf(buf, bufSize, "%s", v->boolVal ? "True" : "False");
break;
case BAS_TYPE_DATE: {
BasStringT *text = basValFormatString(*v);
snprintf(buf, bufSize, "#%s#", text->data);
basStringUnref(text);
break;
}
case BAS_TYPE_STRING:
if (v->strVal) {
snprintf(buf, bufSize, "\"%.*s\"", (int)(bufSize - IDE_QUOTE_OVERHEAD), v->strVal->data);
} else {
snprintf(buf, bufSize, "\"\"");
}
break;
case BAS_TYPE_EMPTY:
snprintf(buf, bufSize, "Empty");
break;
case BAS_TYPE_NULL:
snprintf(buf, bufSize, "Null");
break;
case BAS_TYPE_MISSING:
snprintf(buf, bufSize, "Missing");
break;
case BAS_TYPE_OBJECT:
snprintf(buf, bufSize, "%s", v->objVal ? "<" IDE_OBJECT_TYPE ">" : "Nothing");
break;
case BAS_TYPE_INSTANCE:
if (v->instVal->classIdx == BAS_OBJ_COLLECTION) {
snprintf(buf, bufSize, IDE_COLLECTION_TYPE " (%d items)", (int)v->instVal->itemCount);
} else {
snprintf(buf, bufSize, "<%s>", instanceTypeName(v->instVal));
}
break;
case BAS_TYPE_ARRAY: {
BasArrayT *arr = v->arrVal;
if (!arr) {
snprintf(buf, bufSize, "(uninitialized)");
break;
}
// emitClamped clamps pos to bufSize-1 on truncation, so a
// multi-dim array can't push pos past bufSize and make a later
// 'bufSize - pos' go negative (huge size_t -> OOB write).
int32_t pos = emitClamped(buf, bufSize, 0, "%s(", typeNameStr(arr->elementType));
for (int32_t d = 0; d < arr->dims && pos < bufSize - IDE_ARRAY_DIM_RESERVE; d++) {
if (d > 0) {
pos = emitClamped(buf, bufSize, pos, ", ");
}
pos = emitClamped(buf, bufSize, pos, "%d To %d", (int)arr->lbound[d], (int)arr->ubound[d]);
}
emitClamped(buf, bufSize, pos, ") [%d]", (int)arr->totalElements);
break;
}
default:
snprintf(buf, bufSize, "...");
break;
}
}
// freeProcBufs -- release all procedure buffers
static void freeProcBufs(void) {
free(sGeneralBuf);
sGeneralBuf = NULL;
for (int32_t i = 0; i < (int32_t)arrlen(sProcBufs); i++) {
free(sProcBufs[i]);
}
arrfree(sProcBufs);
sProcBufs = NULL;
sCurProcIdx = IDE_SECTION_NONE;
sEditorFileIdx = -1;
sSkeletonName[0] = '\0';
arrsetlen(sProcTable, 0);
}
// frmScan -- one parse of .frm text: collects the code section into
// scan->code (malloc'd) and, when scan->validator is set, the form's
// controls for the compile-time member validator.
static void frmScan(const char *frmText, IdeFrmScanT *scan) {
FrmParserCbsT cbs;
memset(&cbs, 0, sizeof(cbs));
cbs.userData = scan;
cbs.onFormBegin = validatorOnFormBegin;
cbs.onCtrlBegin = validatorOnCtrlBegin;
cbs.onMenuBegin = validatorOnMenuBegin;
cbs.onFormEnd = frmScanOnFormEnd;
frmParse(frmText, (int32_t)strlen(frmText), &cbs);
}
// frmScanOnFormEnd -- capture the code after the form's End exactly as
// the designer loads it (dsgnCodeSection), so compiled line numbers
// match what the editor shows.
static void frmScanOnFormEnd(void *userData, const char *trailingSrc, int32_t trailingLen) {
IdeFrmScanT *scan = (IdeFrmScanT *)userData;
int32_t codeLen = 0;
const char *code = dsgnCodeSection(trailingSrc, trailingLen, &codeLen);
if (!code) {
return;
}
free(scan->code);
scan->code = (char *)malloc((size_t)codeLen + 1);
if (scan->code) {
memcpy(scan->code, code, (size_t)codeLen);
scan->code[codeLen] = '\0';
}
}
// generalAppend -- (General) text followed by text on new lines, as a
// malloc'd string (NULL when out of memory)
static char *generalAppend(const char *general, const char *text) {
int32_t genLen = general ? (int32_t)strlen(general) : 0;
int32_t addLen = (int32_t)strlen(text);
char *merged = (char *)malloc((size_t)genLen + (size_t)addLen + sizeof("\n"));
if (!merged) {
return NULL;
}
int32_t pos = 0;
if (genLen > 0) {
memcpy(merged, general, (size_t)genLen);
pos = genLen;
if (merged[pos - 1] != '\n') {
merged[pos++] = '\n';
}
}
memcpy(merged + pos, text, (size_t)addLen + 1);
return merged;
}
// getDebugVarSlot -- return a pointer to the actual BasValueT in the running VM
static BasValueT *getDebugVarSlot(const BasDebugVarT *dv) {
if (!sVm) {
return NULL;
}
if (dv->scope == SCOPE_LOCAL && sVm->callDepth > 0) {
BasCallFrameT *frame = &sVm->callStack[sVm->callDepth - 1];
// A frame only initializes and releases its own procedure's
// localCount slots; anything past them is stale. A ByRef
// parameter shows (and sets) the caller's variable.
if (dv->index >= 0 && dv->index < frame->localCount) {
return basValDeref(&frame->locals[dv->index]);
}
} else if (dv->scope == SCOPE_GLOBAL) {
if (dv->index >= 0 && dv->index < BAS_VM_MAX_GLOBALS) {
return &sVm->globals[dv->index];
}
} else if (dv->scope == SCOPE_FORM && sVm->currentFormVars) {
if (dv->index >= 0 && dv->index < sVm->currentFormVarCount) {
return &sVm->currentFormVars[dv->index];
}
} else if (dv->scope == SCOPE_MEMBER) {
return memberVarSlot(dv);
}
return NULL;
}
// Parameter list the runtime passes to a handler of evtName ("" when
// none, or for events not in the master table).
static const char *getEventParams(const char *evtName) {
for (int32_t i = 0; i < IDE_EVENT_COUNT; i++) {
if (strcasecmp(sEventTable[i].suffix, evtName) == 0) {
return sEventTable[i].params;
}
}
return "";
}
static bool getFindForward(void) {
return !sDirGroup || wgtRadioGroupGetSelected(sDirGroup) != FindDirBackE;
}
static bool getFindMatchCase(void) {
return sCaseCheck && wgtCheckboxIsChecked(sCaseCheck);
}
static FindScopeE getFindScope(void) {
int32_t idx = sScopeGroup ? wgtRadioGroupGetSelected(sScopeGroup) : ScopeProjE;
return (idx >= 0 && idx < ScopeCountE) ? (FindScopeE)idx : ScopeProjE;
}
// getFullSource -- save the editor and reassemble all buffers into one
// source string. Returns a pointer into an internal cache that is owned
// by joinProcBufs and freed on the next call. Callers must NOT free it;
// strdup it if the result must outlive the next call.
static const char *getFullSource(void) {
saveCurProc(false);
return joinProcBufs();
}
static WindowT *getLastFocusWin(void) {
if (sLastFocusWin && (sLastFocusWin == sCodeWin || sLastFocusWin == sOutWin || sLastFocusWin == sImmWin || sLastFocusWin == sFormWin)) {
return sLastFocusWin;
}
sLastFocusWin = NULL;
return NULL;
}
// handleEditCmd -- Edit menu. Cut/Copy/Paste/Select All/Delete act on the
// last focused content window: the designer's selected control, or the
// text of the code, output or immediate window.
static void handleEditCmd(int32_t cmd) {
switch (cmd) {
case CMD_CUT:
case CMD_COPY:
case CMD_PASTE:
case CMD_SELECT_ALL:
case CMD_DELETE: {
WindowT *target = getLastFocusWin();
if (target && target == sFormWin) {
designerEditCmd(cmd);
} else if (target && target->onKey) {
if (cmd == CMD_DELETE) {
target->onKey(target, KEY_DELETE, 0);
} else {
target->onKey(target, editCmdKey(cmd), ACCEL_CTRL);
}
}
break;
}
case CMD_FIND:
openFindDialog(false);
break;
case CMD_FIND_NEXT:
if (sFindText[0]) {
onFindNext(NULL);
} else {
openFindDialog(false);
}
break;
case CMD_REPLACE:
openFindDialog(true);
break;
default:
break;
}
}
// Accelerators bypass the menu enabled state, so anything that changes
// the project or the compiled module is gated on the program being idle.
static void handleFileCmd(int32_t cmd) {
bool isIdle = (sDbgState == DbgIdleE);
switch (cmd) {
case CMD_OPEN:
if (isIdle) {
loadFile();
}
break;
case CMD_SAVE:
saveFile();
break;
case CMD_SAVE_ALL:
if (saveAllModified()) {
setStatus("All files saved.");
}
break;
case CMD_MAKE_EXE:
if (isIdle) {
makeExecutable();
}
break;
case CMD_EXIT:
if (sWin) {
onClose(sWin);
}
break;
default:
// Recent files
if (isIdle && cmd >= CMD_RECENT_BASE && cmd < CMD_RECENT_BASE + CMD_RECENT_MAX) {
recentOpen(cmd - CMD_RECENT_BASE);
}
break;
}
}
static void handleProjectCmd(int32_t cmd) {
bool isIdle = (sDbgState == DbgIdleE);
switch (cmd) {
case CMD_PRJ_NEW:
if (isIdle) {
newProject();
}
break;
case CMD_PRJ_OPEN:
if (isIdle) {
openProject();
}
break;
case CMD_PRJ_SAVE:
if (hasProject() && saveProjectFile()) {
setStatus("Project saved.");
}
break;
case CMD_PRJ_CLOSE:
if (isIdle && promptAndSave()) {
closeProject();
}
break;
case CMD_PRJ_PROPS:
if (hasProject()) {
if (prjPropertiesDialog(sAc, &sProject, sCtx->appPath)) {
updateMainTitle();
if (sProjectWin) {
prjRebuildTree(&sProject);
}
}
}
break;
case CMD_PRJ_NEW_CLASS:
if (isIdle && hasProject()) {
newClassModule();
}
break;
case CMD_PRJ_RENAME: {
int32_t renIdx = prjGetSelectedFileIdx();
if (isIdle && renIdx >= 0 && renIdx < prjFileCount(&sProject)) {
renameProjectFile(renIdx);
}
break;
}
case CMD_PRJ_REMOVE: {
int32_t rmIdx = prjGetSelectedFileIdx();
if (!isIdle || rmIdx < 0 || rmIdx >= prjFileCount(&sProject)) {
break;
}
PrjFileT *rmFile = &sProject.files[rmIdx];
char rmMsg[IDE_MSG_BUF];
snprintf(rmMsg, sizeof(rmMsg), "Remove %s from the project?", rmFile->path);
if (dvxMessageBox(sAc, "Remove File", rmMsg, MB_YESNO | MB_ICONQUESTION) != ID_YES) {
break;
}
if ((rmIdx == sEditorFileIdx || rmIdx == sDesignerFileIdx) && !stashCurrentFile()) {
break;
}
if (rmFile->modified) {
int32_t result = dvxPromptSave(sAc, IDE_MAIN_TITLE);
if (result == DVX_SAVE_CANCEL) {
break;
}
if (result == DVX_SAVE_YES && !writeProjectFile(rmIdx)) {
break;
}
}
// Detach the editor/designer from the file before it goes away
if (rmIdx == sEditorFileIdx) {
freeProcBufs();
editorSetText("", IDE_CARET_LOAD);
} else if (sEditorFileIdx > rmIdx) {
sEditorFileIdx--;
}
if (rmIdx == sDesignerFileIdx) {
designerRelease();
} else if (sDesignerFileIdx > rmIdx) {
sDesignerFileIdx--;
}
removeBreakpointsForFile(rmIdx);
prjRemoveFile(&sProject, rmIdx); // adjusts activeFileIdx
invalidateCompiled();
updateDropdowns();
prjRebuildTree(&sProject);
updateProjectMenuState();
updateDirtyIndicators();
break;
}
default:
break;
}
}
static void handleRunCmd(int32_t cmd) {
switch (cmd) {
case CMD_RUN:
if (sDbgState == DbgPausedE) {
// Resume from breakpoint -- clear debug mode so it runs free
sDbgEnabled = false;
clearVmStepState();
if (sVm) {
basVmSetBreakpoints(sVm, NULL, 0);
}
debugResume("Running...");
} else if (sDbgState == DbgIdleE) {
sDbgEnabled = false;
compileAndRun();
}
break;
case CMD_DEBUG:
if (sDbgState == DbgPausedE) {
// Already debugging -- resume, run to next breakpoint
clearVmStepState();
debugResume("Debugging...");
} else if (sDbgState == DbgIdleE) {
// Start in debug mode with breakpoints
sDbgEnabled = true;
compileAndRun();
}
break;
case CMD_RUN_NOCMP:
if (sDbgState == DbgIdleE) {
runCached();
}
break;
case CMD_STOP:
if (sDbgState == DbgRunningE || sDbgState == DbgPausedE) {
debugStop();
setStatus("Program stopped.");
}
break;
case CMD_OUTPUT_TO_LOG:
if (sWin && sWin->menuBar) {
sOutputToLog = wmMenuItemIsChecked(sWin->menuBar, CMD_OUTPUT_TO_LOG);
prefsSetBool(sPrefs, PREF_SEC_RUN, PREF_KEY_OUTPUT_TO_LOG, sOutputToLog);
prefsSave(sPrefs);
}
break;
case CMD_STEP_INTO:
case CMD_STEP_OVER:
case CMD_STEP_OUT:
case CMD_RUN_TO_CURSOR:
debugStartOrResume(cmd);
break;
case CMD_TOGGLE_BP:
toggleBreakpoint();
break;
case CMD_CLEAR:
clearOutput();
break;
case CMD_SAVE_ON_RUN:
if (sWin && sWin->menuBar) {
bool save = wmMenuItemIsChecked(sWin->menuBar, CMD_SAVE_ON_RUN);
prefsSetBool(sPrefs, PREF_SEC_RUN, PREF_KEY_SAVE_ON_RUN, save);
prefsSave(sPrefs);
}
break;
default:
break;
}
}
static void handleViewCmd(int32_t cmd) {
switch (cmd) {
case CMD_VIEW_CODE: {
int32_t selFileIdx = prjGetSelectedFileIdx();
// The selected file, else the active one (reopening a closed
// code window with its code reloaded)
if (selFileIdx < 0 || selFileIdx >= prjFileCount(&sProject)) {
selFileIdx = sProject.activeFileIdx;
}
activateFile(selFileIdx, ViewCodeE);
break;
}
case CMD_VIEW_DESIGN: {
int32_t selFileIdx = prjGetSelectedFileIdx();
// The Shift+F7 accelerator bypasses the menu state: only a form
// opens in the designer.
if (selFileIdx >= 0 && selFileIdx < prjFileCount(&sProject) && sProject.files[selFileIdx].kind == PrjKindFormE) {
activateFile(selFileIdx, ViewDesignE);
} else if (activeIsForm()) {
switchToDesign();
} else {
setStatus("The active file is not a form.");
}
break;
}
case CMD_VIEW_TOOLBAR:
if (sToolbar && sWin->menuBar) {
bool show = wmMenuItemIsChecked(sWin->menuBar, CMD_VIEW_TOOLBAR);
sToolbar->visible = show;
dvxFitWindowH(sAc, sWin);
prefsSetBool(sPrefs, PREF_SEC_VIEW, PREF_KEY_TOOLBAR, show);
prefsSave(sPrefs);
}
break;
case CMD_VIEW_STATUS:
if (sStatusBar && sWin->menuBar) {
bool show = wmMenuItemIsChecked(sWin->menuBar, CMD_VIEW_STATUS);
sStatusBar->visible = show;
dvxFitWindowH(sAc, sWin);
prefsSetBool(sPrefs, PREF_SEC_VIEW, PREF_KEY_STATUSBAR, show);
prefsSave(sPrefs);
}
break;
case CMD_MENU_EDITOR: {
// Activate selected form if not already active
int32_t selMenuIdx = prjGetSelectedFileIdx();
if (selMenuIdx >= 0 && selMenuIdx != sProject.activeFileIdx && selMenuIdx < prjFileCount(&sProject) && sProject.files[selMenuIdx].kind == PrjKindFormE) {
activateFile(selMenuIdx, ViewDesignE);
}
if (!activeIsForm() || !sDesigner.form) {
setStatus("The active file is not a form.");
break;
}
// Snapshot old menu names for rename detection
char **oldNames = NULL;
int32_t oldCount = (int32_t)arrlen(sDesigner.form->menuItems);
for (int32_t mi = 0; mi < oldCount; mi++) {
arrput(oldNames, strdup(sDesigner.form->menuItems[mi].name));
}
if (mnuEditorDialog(sAc, sDesigner.form)) {
sDesigner.form->dirty = true;
renameMenuItemsInCode(oldNames, oldCount);
// Rebuild menu bar preview
if (sFormWin) {
wmDestroyMenuBar(sFormWin, &sAc->display);
dsgnBuildPreviewMenuBar(sFormWin, sDesigner.form);
dvxInvalidateWindow(sAc, sFormWin);
}
// Rebuild Object dropdown to reflect added/removed/renamed items
updateDropdowns();
updateDirtyIndicators();
}
for (int32_t mi = 0; mi < oldCount; mi++) {
free(oldNames[mi]);
}
arrfree(oldNames);
break;
}
default:
break;
}
}
static void handleWindowCmd(int32_t cmd) {
switch (cmd) {
case CMD_WIN_CODE:
// An active file reloads into a reopened window; otherwise an
// empty scratch editor.
if (sProject.activeFileIdx >= 0) {
showCodeView(sProject.activeFileIdx);
} else {
showCodeWindow();
if (sCodeWin) {
dvxRaiseWindow(sAc, sCodeWin);
}
}
break;
case CMD_WIN_OUTPUT:
showOutputWindow();
break;
case CMD_WIN_IMM:
showImmediateWindow();
break;
case CMD_WIN_LOCALS:
showLocalsWindow();
break;
case CMD_WIN_CALLSTACK:
showCallStackWindow();
break;
case CMD_WIN_WATCH:
showWatchWindow();
break;
case CMD_WIN_BREAKPOINTS:
showBreakpointWindow();
break;
case CMD_WIN_TOOLBOX:
if (!sToolboxWin) {
sToolboxWin = tbxCreate(sAc, &sDesigner, toolbarBottom());
if (sToolboxWin) {
sToolboxWin->onMenu = onMenu;
sToolboxWin->accelTable = sWin ? sWin->accelTable : NULL;
}
}
break;
case CMD_WIN_PROPS:
if (!sPropsWin) {
sPropsWin = prpCreate(sAc, &sDesigner);
if (sPropsWin) {
sPropsWin->y = toolbarBottom();
sPropsWin->onMenu = onMenu;
sPropsWin->accelTable = sWin ? sWin->accelTable : NULL;
}
}
break;
case CMD_WIN_PROJECT:
ensureProjectWindow(true);
break;
default:
break;
}
}
static bool hasProject(void) {
return sProject.projectPath[0] != '\0';
}
static bool hasUnsavedData(void) {
return anyFileModified() || sProject.dirty;
}
// Build control help topic from type name.
// Topic IDs in .bhs files follow the pattern ctrl.<lowercase(basName)>.
// Generated dynamically so third-party widgets get help automatically.
static void helpBuildCtrlTopic(const char *typeName, char *buf, int32_t bufSize) {
int32_t off = snprintf(buf, bufSize, "ctrl.");
for (int32_t i = 0; typeName[i] && off < bufSize - 1; i++) {
buf[off++] = tolower((unsigned char)typeName[i]);
}
buf[off] = '\0';
}
static const char *helpLookupKeyword(const char *word) {
for (int32_t i = 0; i < HELP_MAP_COUNT; i++) {
if (strcasecmp(sHelpMap[i].keyword, word) == 0) {
return sHelpMap[i].topic;
}
}
return NULL;
}
static void helpQueryHandler(void *ctx) {
(void)ctx;
sCtx->helpTopic[0] = '\0';
// Restore IDE help file (may have been swapped for a BASIC program's)
snprintf(sCtx->helpFile, sizeof(sCtx->helpFile), "%s", sIdeHelpFile);
// Determine which window is focused
WindowT *focusWin = NULL;
if (sAc->stack.focusedIdx >= 0 && sAc->stack.focusedIdx < sAc->stack.count) {
focusWin = sAc->stack.windows[sAc->stack.focusedIdx];
}
// Running BASIC program with a help file: its forms use the program's
// help (same rules as a compiled program)
if (sDbgFormRt && sDbgFormRt->helpFile[0] && basFormRtHelpTopic(sDbgFormRt, sCtx->helpTopic, sizeof(sCtx->helpTopic))) {
snprintf(sCtx->helpFile, sizeof(sCtx->helpFile), "%s", sDbgFormRt->helpFile);
return;
}
// Code editor / Immediate window: look up the word under the cursor
if ((focusWin == sCodeWin && sEditor) || (focusWin == sImmWin && sImmediate)) {
WidgetT *area = (focusWin == sCodeWin) ? sEditor : sImmediate;
char word[IDE_FULL_NAME_BUF];
if (wgtTextAreaGetWordAtCursor(area, word, sizeof(word)) > 0) {
const char *topic = helpLookupKeyword(word);
if (topic) {
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "%s", topic);
return;
}
}
// No keyword match -- open the window's own topic
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "%s", (focusWin == sCodeWin) ? "ide.editor" : "ide.immediate");
return;
}
// Form designer: help for the selected control type
if (focusWin == sFormWin && sDesigner.form) {
if (sDesigner.selectedIdx >= 0 && sDesigner.selectedIdx < arrlen(sDesigner.form->controls)) {
helpSetCtrlTopic(sDesigner.form->controls[sDesigner.selectedIdx]->typeName);
} else {
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "ctrl.form");
}
return;
}
// Toolbox: help for the active tool
if (focusWin == sToolboxWin) {
if (sDesigner.activeTool[0]) {
helpSetCtrlTopic(sDesigner.activeTool);
} else {
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "ide.toolbox");
}
return;
}
// Properties panel
if (focusWin == sPropsWin) {
if (sDesigner.form && sDesigner.selectedIdx >= 0 && sDesigner.selectedIdx < arrlen(sDesigner.form->controls)) {
helpSetCtrlTopic(sDesigner.form->controls[sDesigner.selectedIdx]->typeName);
} else {
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "ctrl.common.props");
}
return;
}
// Remaining windows map straight to a topic
const char *topic = "ide.overview";
if (focusWin == sOutWin) {
topic = "ide.output";
} else if (focusWin == sProjectWin) {
topic = "ide.project";
} else if (focusWin == sLocalsWin) {
topic = "ide.debug.locals";
} else if (focusWin == sCallStackWin) {
topic = "ide.debug.callstack";
} else if (focusWin == sWatchWin) {
topic = "ide.debug.watch";
} else if (focusWin == sBreakpointWin) {
topic = "ide.debug.breakpoints";
}
snprintf(sCtx->helpTopic, sizeof(sCtx->helpTopic), "%s", topic);
}
static void helpSetCtrlTopic(const char *typeName) {
helpBuildCtrlTopic(typeName, sCtx->helpTopic, sizeof(sCtx->helpTopic));
}
// ideErrorBox -- modal error message. The busy state swallows all input,
// so it is cleared first or the box could never be dismissed.
static void ideErrorBox(const char *msg) {
dvxSetBusy(sAc, false);
dvxErrorBox(sAc, NULL, msg);
}
// idePump -- one pass of the GUI event loop while a program runs, with
// its buffered output shown first
static void idePump(void) {
flushOutput();
dvxUpdate(sAc);
}
// ============================================================
// ideRenameInCode -- rename form/control references in all .bas files
// ============================================================
//
// Case-insensitive replacement of OldName followed by '.' or '_' with
// NewName followed by the same delimiter. This handles:
// ControlName.Property -> NewName.Property
// ControlName_Click -> NewName_Click (event handlers)
// FormName.ControlName.X -> NewFormName.ControlName.X
// Sub FormName_Load -> Sub NewFormName_Load
void ideRenameInCode(const char *oldName, const char *newName) {
if (!oldName || !newName || strcasecmp(oldName, newName) == 0) {
return;
}
// The editor may hold edits that are not in the proc buffers yet
saveCurProc(false);
// Rename in the per-procedure buffers (the code bound to the editor)
bool editorChanged = false;
bool shownChanged = false;
if (sGeneralBuf) {
char *replaced = renameInBuffer(sGeneralBuf, oldName, newName);
if (replaced) {
free(sGeneralBuf);
sGeneralBuf = replaced;
editorChanged = true;
shownChanged = sCurProcIdx == IDE_SECTION_GENERAL;
}
}
for (int32_t i = 0; i < (int32_t)arrlen(sProcBufs); i++) {
char *replaced = renameInBuffer(sProcBufs[i], oldName, newName);
if (replaced) {
free(sProcBufs[i]);
sProcBufs[i] = replaced;
editorChanged = true;
shownChanged = shownChanged || i == sCurProcIdx;
}
}
// Reload the editor only when the section it shows was renamed in
if (shownChanged) {
editorSetText(sCurProcIdx == IDE_SECTION_GENERAL ? (sGeneralBuf ? sGeneralBuf : "") : sProcBufs[sCurProcIdx], IDE_CARET_KEEP);
}
if (editorChanged && sEditorFileIdx >= 0 && sEditorFileIdx < prjFileCount(&sProject)) {
sProject.files[sEditorFileIdx].modified = true;
}
// Update form->code: from the renamed buffers when the editor holds
// the designer's code, otherwise directly -- with the code window
// closed the designer's copy of the code is the only one loaded.
if (sDesigner.form) {
if (sEditorFileIdx >= 0 && sEditorFileIdx == sDesignerFileIdx) {
stashFormCode();
sDesigner.form->dirty = true;
} else if (sDesigner.form->code) {
char *replaced = renameInBuffer(sDesigner.form->code, oldName, newName);
if (replaced) {
free(sDesigner.form->code);
sDesigner.form->code = replaced;
sDesigner.form->dirty = true;
}
}
// A renamed form: its project entry follows the designer
if (sDesignerFileIdx >= 0 && sDesignerFileIdx < prjFileCount(&sProject)) {
snprintf(sProject.files[sDesignerFileIdx].formName, sizeof(sProject.files[sDesignerFileIdx].formName), "%s", sDesigner.form->name);
}
}
// Rename in every other file's buffer (loading it first if needed)
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (i == sEditorFileIdx || i == sDesignerFileIdx) {
continue;
}
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(i, &owned, &missing);
char *replaced = renameInBuffer(text, oldName, newName);
free(owned);
if (replaced) {
free(sProject.files[i].buffer);
sProject.files[i].buffer = replaced;
sProject.files[i].modified = true;
}
}
// Refresh dropdowns to reflect renamed procedures
updateDropdowns();
}
// immEvalRhs -- evaluate the right-hand side of an Immediate-window
// assignment as a BASIC expression (it may use the paused program's
// variables) converted to the target's type. Reports any error in the
// Immediate window and returns false.
static bool immEvalRhs(const char *rhs, uint8_t targetType, BasValueT *outVal) {
char src[IDE_IMM_WRAP_BUF + BAS_MAX_IDENT * 2];
snprintf(src, sizeof(src), "%s %s AS %s: %s = %s", KW_DIM, IDE_IMM_RHS_VAR, typeNameStr(targetType), IDE_IMM_RHS_VAR, rhs);
BasModuleT *mod = NULL;
char err[IDE_VALUE_BUF];
int32_t idx = -1;
BasVmT *vm = buildSnippetVm(src, &mod, err, sizeof(err), IDE_IMM_RHS_VAR, &idx);
if (!vm) {
immPrintCallback(NULL, "Error: ", false);
immPrintCallback(NULL, err, true);
return false;
}
BasVmResultE result = runSnippetVm(vm);
bool ok = (result == BAS_VM_HALTED || result == BAS_VM_OK) && idx >= 0 && idx < BAS_VM_MAX_GLOBALS;
if (ok) {
*outVal = basValCopy(vm->globals[idx]);
} else {
immReportSnippetResult(vm, result);
}
basVmDestroy(vm);
basModuleFree(mod);
return ok;
}
// immPrintCallback -- append program output to the Immediate window.
// The window has a fixed capacity, so the oldest lines scroll off the
// top once output would take the room kept for typing (IDE_IMM_HEADROOM).
static void immPrintCallback(void *ctx, const char *text, bool newline) {
(void)ctx;
if (!sImmediate) {
return;
}
static char immBuf[IDE_MAX_IMM];
const char *cur = wgtGetText(sImmediate);
int32_t len = cur ? (int32_t)strlen(cur) : 0;
if (len > IDE_MAX_IMM - 1) {
len = IDE_MAX_IMM - 1;
}
memcpy(immBuf, cur ? cur : "", (size_t)len);
immBuf[len] = '\0';
if (text) {
len = appendDroppingLines(immBuf, IDE_MAX_IMM - IDE_IMM_HEADROOM, len, text, (int32_t)strlen(text));
}
if (newline) {
appendDroppingLines(immBuf, IDE_MAX_IMM - IDE_IMM_HEADROOM, len, "\n", 1);
}
wgtSetText(sImmediate, immBuf);
// Move cursor to end so user can keep typing
wgtTextAreaGoToLine(sImmediate, countLines(immBuf));
}
// immReportSnippetResult -- report a failed Immediate/Watch snippet run
static void immReportSnippetResult(BasVmT *vm, BasVmResultE result) {
if (result == BAS_VM_HALTED || result == BAS_VM_OK || result == BAS_VM_BREAKPOINT) {
return;
}
immPrintCallback(NULL, "Error: ", false);
immPrintCallback(NULL, result == BAS_VM_STEP_LIMIT ? "Statement did not finish; stopped." : basVmGetError(vm), true);
}
// immTryAssign -- handle "varName = expr" when paused at a breakpoint.
// Looks up the variable, evaluates the RHS expression, and writes the
// value back to the running VM. Returns true if handled as an assignment.
static bool immTryAssign(const char *expr) {
if (sDbgState != DbgPausedE || !sVm || !sDbgModule) {
return false;
}
// Skip leading whitespace
const char *p = dvxSkipWs(expr);
// Skip optional LET keyword
if (kwMatch(p, KW_LET)) {
p = dvxSkipWs(p + KW_LEN(KW_LET));
}
// Resolve the LHS to a live slot in the VM
const char *afterLhs = NULL;
BasValueT *slot = resolveVarPath(p, &afterLhs);
if (!slot || !afterLhs) {
return false;
}
// Build display name from LHS
char lhsName[IDE_VALUE_BUF];
int32_t lhsLen = (int32_t)(afterLhs - p);
if (lhsLen >= (int32_t)sizeof(lhsName)) {
lhsLen = (int32_t)sizeof(lhsName) - 1;
}
memcpy(lhsName, p, lhsLen);
lhsName[lhsLen] = '\0';
// Skip whitespace after LHS
p = dvxSkipWs(afterLhs);
// Must have '=' (but not '==')
if (*p != '=' || p[1] == '=') {
return false;
}
p = dvxSkipWs(p + 1); // skip '='
if (*p == '\0') {
return false;
}
// Only scalars can be assigned; the RHS is evaluated as an expression
BasValueT newVal;
bool scalar = slot->type == BAS_TYPE_INTEGER || slot->type == BAS_TYPE_LONG || slot->type == BAS_TYPE_SINGLE || slot->type == BAS_TYPE_DOUBLE || slot->type == BAS_TYPE_STRING || slot->type == BAS_TYPE_BOOLEAN || slot->type == BAS_TYPE_DATE || slot->type == BAS_TYPE_BYTE || slot->type == BAS_TYPE_CURRENCY;
if (!scalar) {
immPrintCallback(NULL, "Cannot assign to this variable type", true);
return true;
}
if (!immEvalRhs(p, slot->type, &newVal)) {
return true;
}
// Write the value directly to the slot
basValRelease(slot);
*slot = newVal; // transfer ownership -- don't release newVal
// Show confirmation
char confirm[IDE_VALUE_BUF];
snprintf(confirm, sizeof(confirm), "%s = ", lhsName);
immPrintCallback(NULL, confirm, false);
formatValue(slot, confirm, sizeof(confirm));
immPrintCallback(NULL, confirm, true);
// Update debug windows to reflect the change
updateLocalsWindow();
updateWatchWindow();
return true;
}
// Hash-based keyword/type lookup using stb_ds.
// Key = uppercase word, value = TEXT_SYNTAX_KEYWORD or TEXT_SYNTAX_TYPE.
// Built once on first use, then O(1) per lookup.
static void initSyntaxMap(void) {
if (sSyntaxMap) {
return;
}
sh_new_arena(sSyntaxMap);
// Pull the canonical keyword list from the lexer -- one source of truth.
int32_t n = basLexerKeywordCount();
for (int32_t i = 0; i < n; i++) {
const char *kw = basLexerKeywordAt(i);
// Skip dollar-suffixed aliases (DIR$, CURDIR$, etc.) -- the
// unsuffixed form is already in the list and the colorizer
// strips the $ before lookup.
if (kw[strlen(kw) - 1] == '$') {
continue;
}
BasKeywordClassE cls = basLexerKeywordClass(i);
uint8_t color = (cls == BAS_KW_CLASS_TYPE || cls == BAS_KW_CLASS_LITERAL) ? TEXT_SYNTAX_TYPE : TEXT_SYNTAX_KEYWORD;
shput(sSyntaxMap, kw, basLexerKeywordReserved(i) ? color : (uint8_t)(color | IDE_SYNTAX_UNRESERVED));
}
}
static bool inputCallback(void *ctx, const char *prompt, char *buf, int32_t bufSize) {
(void)ctx;
// The prompt, and everything printed before it, is visible while asking
if (prompt) {
outputAppend(prompt, (int32_t)strlen(prompt));
}
flushOutput();
return dvxInputBox(sAc, IDE_MAIN_TITLE, prompt ? prompt : "Enter value:", NULL, buf, bufSize);
}
// instanceTypeName -- what a class instance or Collection is, for the
// debugger: its class name, or "Collection"
static const char *instanceTypeName(const BasObjectT *obj) {
const char *cls = objectClassName(obj);
if (cls) {
return cls;
}
return obj->classIdx == BAS_OBJ_COLLECTION ? IDE_COLLECTION_TYPE : IDE_OBJECT_TYPE;
}
// invalidateCompiled -- the compiled module and source map describe the
// project's previous file list; drop them (a running program keeps the
// module it executes).
static void invalidateCompiled(void) {
if (!sVm && sCachedModule) {
basModuleFree(sCachedModule);
sCachedModule = NULL;
}
arrfree(sProject.sourceMap);
sProject.sourceMap = NULL;
updateProjectMenuState();
}
static bool isCtrlArrayInDesigner(const char *ctrlName) {
if (!sDesigner.form) {
return false;
}
int32_t count = (int32_t)arrlen(sDesigner.form->controls);
for (int32_t i = 0; i < count; i++) {
if (strcasecmp(sDesigner.form->controls[i]->name, ctrlName) == 0 && sDesigner.form->controls[i]->index >= 0) {
return true;
}
}
return false;
}
// Check if position i is inside a string literal or comment (' or REM).
// Scans from the start of the line containing i.
static bool isInStringOrComment(const char *src, int32_t i) {
// Find start of line
int32_t lineStart = i;
while (lineStart > 0 && src[lineStart - 1] != '\n') {
lineStart--;
}
const char *line = src + lineStart;
int32_t lineLen = (int32_t)strcspn(line, "\n");
bool inString = false;
for (int32_t j = 0; j < i - lineStart; j++) {
if (line[j] == '"') {
inString = !inString;
} else if (!inString && (line[j] == '\'' || isRemAt(line, j, lineLen))) {
// Rest of line is a comment
return true;
}
}
return inString;
}
// Internal mangled names (e.g. "DoCount$Count" for Static vars) have a $
// in the middle; string variable names end with $ and are fine.
static bool isMangledDebugName(const char *name) {
const char *dollar = strchr(name, '$');
return dollar && dollar[1] != '\0';
}
// isRemAt -- true if the word REM (a comment to end of line) starts at
// line[pos]: a whole word in any case. Shared by the colorizer, the
// rename scanner and breakpoint validation.
static bool isRemAt(const char *line, int32_t pos, int32_t lineLen) {
int32_t end = pos + KW_LEN(KW_REM);
if (end > lineLen || strncasecmp(line + pos, KW_REM, KW_LEN(KW_REM)) != 0) {
return false;
}
if (pos > 0 && basIsIdentChar(line[pos - 1])) {
return false;
}
return end == lineLen || !basIsIdentChar(line[end]);
}
static bool isReplaceEnabled(void) {
return sReplCheck && wgtCheckboxIsChecked(sReplCheck);
}
// joinProcArrays -- build the canonical file text from a (General)
// buffer and a proc array: General, one blank line, then each proc
// separated by one blank line. Returns a malloc'd string or NULL.
static char *joinProcArrays(const char *general, char **procs) {
int32_t totalLen = 0;
int32_t procCount = (int32_t)arrlen(procs);
if (general && general[0]) {
totalLen += (int32_t)strlen(general);
totalLen += 2; // newline + blank line separator
}
for (int32_t i = 0; i < procCount; i++) {
if (procs[i]) {
totalLen += (int32_t)strlen(procs[i]);
totalLen += 2; // newline + blank line between procedures
}
}
char *out = (char *)malloc(totalLen + 1);
if (!out) {
return NULL;
}
int32_t pos = 0;
if (general && general[0]) {
int32_t len = (int32_t)strlen(general);
memcpy(out + pos, general, len);
pos += len;
if (out[pos - 1] != '\n') {
out[pos++] = '\n';
}
out[pos++] = '\n';
}
for (int32_t i = 0; i < procCount; i++) {
if (procs[i]) {
int32_t len = (int32_t)strlen(procs[i]);
memcpy(out + pos, procs[i], len);
pos += len;
if (pos > 0 && out[pos - 1] != '\n') {
out[pos++] = '\n';
}
// Blank line between procedures
if (i < procCount - 1) {
out[pos++] = '\n';
}
}
}
out[pos] = '\0';
return out;
}
// joinProcBufs -- reassemble the editor's buffers into sFullSourceCache
// and rebuild sProcTable from the result so both always describe the
// same text. Does not save the editor first (see getFullSource).
static const char *joinProcBufs(void) {
free(sFullSourceCache);
sFullSourceCache = joinProcArrays(sGeneralBuf, sProcBufs);
rebuildProcTable();
return sFullSourceCache ? sFullSourceCache : "";
}
// kwMatch -- case-insensitive prefix test against a keyword tag
static bool kwMatch(const char *p, const char *kw) {
return strncasecmp(p, kw, strlen(kw)) == 0;
}
// lineCopy -- copy 1-based line `line` of text (without its newline) into
// out, truncated to fit. Returns the copied length.
static int32_t lineCopy(const char *text, int32_t line, char *out, int32_t outSize) {
const char *start = text + lineStartOffset(text, line);
int32_t len = (int32_t)strcspn(start, "\n");
if (len > outSize - 1) {
len = outSize - 1;
}
memcpy(out, start, (size_t)len);
out[len] = '\0';
return len;
}
// lineStartOffset -- byte offset where 1-based line `line` of text starts
// (the text's end when it has fewer lines)
static int32_t lineStartOffset(const char *text, int32_t line) {
const char *p = text;
for (int32_t ln = 1; *p && ln < line; ln++) {
p = skipLine(p);
}
return (int32_t)(p - text);
}
static void listRowsAdd(IdeListRowsT *rows, const char *text) {
char *copy = strdup(text);
if (copy) {
arrput(rows->strs, copy);
}
arrput(rows->cells, copy ? copy : "");
}
static void listRowsCommit(const IdeListRowsT *rows, WidgetT *list, int32_t rowCount) {
wgtListViewSetData(list, rowCount > 0 ? rows->cells : NULL, rowCount);
}
static void listRowsFree(IdeListRowsT *rows) {
listRowsReset(rows);
arrfree(rows->strs);
arrfree(rows->cells);
rows->strs = NULL;
rows->cells = NULL;
}
static void listRowsReset(IdeListRowsT *rows) {
for (int32_t i = 0; i < (int32_t)arrlen(rows->strs); i++) {
free(rows->strs[i]);
}
arrsetlen(rows->strs, 0);
arrsetlen(rows->cells, 0);
}
// loadCompileSource -- the code text of project file fileIdx, normalized
// to the canonical proc layout (malloc'd). Loaded buffers are
// authoritative; disk is only read for files never loaded. For a .frm
// the result is just its code section, *outCtrlList gets its controls for
// the BEGINFORM line (basFrmControlList, malloc'd; NULL for other files)
// and the same single parse adds them to validator (when non-NULL).
// Returns NULL when the file cannot be read.
static char *loadCompileSource(int32_t fileIdx, IdeValidatorCtxT *validator, char **outCtrlList) {
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(fileIdx, &owned, &missing);
if (!text) {
return NULL;
}
IdeFrmScanT scan;
const char *code = text;
scan.validator = validator;
scan.code = NULL;
*outCtrlList = NULL;
if (sProject.files[fileIdx].kind == PrjKindFormE) {
int32_t textLen = (int32_t)strlen(text);
frmScan(text, &scan);
// The controls the form declares (the list never outgrows the text)
*outCtrlList = (char *)malloc((size_t)textLen + 1);
if (!*outCtrlList || basFrmControlList(text, textLen, *outCtrlList, textLen + 1) < 0) {
free(*outCtrlList);
free(scan.code);
free(owned);
*outCtrlList = NULL;
return NULL;
}
// The designer's form: its code is exactly what the editor numbers
if (fileIdx == sDesignerFileIdx && sDesigner.form) {
code = sDesigner.form->code ? sDesigner.form->code : "";
} else {
code = scan.code ? scan.code : "";
}
}
char *packed = packProcLayout(code);
free(scan.code);
free(owned);
return packed;
}
// loadDesignerFile -- load form file fileIdx into the designer (a new,
// blank form named after the file when it does not exist yet). Returns
// false, keeping the current designer, when it exists but cannot be read.
static bool loadDesignerFile(int32_t fileIdx) {
PrjFileT *target = &sProject.files[fileIdx];
bool missing = false;
char *owned = NULL;
const char *frmSrc = projectFileText(fileIdx, &owned, &missing);
if (!frmSrc && !missing) {
reportUnreadable(target->path);
return false;
}
designerRelease();
if (frmSrc && frmSrc[0]) {
dsgnLoadFrm(&sDesigner, frmSrc, (int32_t)strlen(frmSrc));
} else {
// New blank form -- derive name from filename
char formName[BAS_MAX_IDENT];
const char *base = platformPathBaseName(target->path);
snprintf(formName, sizeof(formName), "%.*s", (int)strcspn(base, "."), base);
dsgnNewForm(&sDesigner, formName);
target->modified = true;
}
free(owned);
sDesignerFileIdx = fileIdx;
if (sDesigner.form) {
snprintf(target->formName, sizeof(target->formName), "%s", sDesigner.form->name);
}
return true;
}
static void loadFile(void) {
FileFilterT filters[] = {
{ "BASIC Files (*.bas)" },
{ "Form Files (*.frm)" },
{ "Class Modules (*.cls)" },
{ "All Files (*.*)" }
};
char path[DVX_MAX_PATH];
if (!dvxFileDialog(sAc, "Add File", FD_OPEN, NULL, filters, DVX_ARRAY_LEN(filters), path, sizeof(path))) {
return;
}
openSinglePath(path);
}
// loadFormCodeIntoEditor -- bind the editor to the designer form's code
// (whatever the editor held goes back to its own file first).
static void loadFormCodeIntoEditor(void) {
if (!sDesigner.form) {
return;
}
saveCurProc(true);
stashEditor();
parseProcs(sDesigner.form->code ? sDesigner.form->code : "");
sEditorFileIdx = sDesignerFileIdx;
if (!sCodeWin) {
showCodeWindow();
}
bool saved = sDropdownNavSuppressed;
sDropdownNavSuppressed = true;
updateDropdowns();
sDropdownNavSuppressed = saved;
showProc(IDE_SECTION_GENERAL);
}
// loadFrmFiles -- register every .frm listed in the current project with
// the form runtime. The text is the same the compile used (loaded
// buffers, disk only for never-loaded files). Registration only caches
// the text; the caller's basFormRtLoadAllForms then instantiates them,
// so a Form_Load that does "Load Form2" finds Form2's .frm regardless of
// project file order.
static void loadFrmFiles(BasFormRtT *rt) {
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (sProject.files[i].kind != PrjKindFormE) {
continue;
}
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(i, &owned, &missing);
char formName[BAS_MAX_IDENT];
if (text && basExtractFormName(text, formName, sizeof(formName))) {
basFormRtRegisterFrm(rt, formName, text, (int32_t)strlen(text));
}
free(owned);
}
}
// loadModuleIntoEditor -- bind the editor to .bas file fileIdx holding source
static void loadModuleIntoEditor(int32_t fileIdx, const char *source) {
parseProcs(source);
sEditorFileIdx = fileIdx;
updateDropdowns();
showProc(IDE_SECTION_GENERAL);
}
static WidgetT *loadTbIcon(WidgetT *parent, const char *resName, const char *fallbackText) {
int32_t iconW = 0;
int32_t iconH = 0;
int32_t iconPitch = 0;
uint8_t *data = dvxResLoadIcon(sAc, sCtx->appPath, resName, &iconW, &iconH, &iconPitch);
if (data) {
return wgtImageButton(parent, data, iconW, iconH, iconPitch);
}
// Fallback to text button if icon not found
return wgtButton(parent, fallbackText);
}
// Convert an editor-local line number to a full-source line number, or
// IDE_NO_LINE when that line was not compiled (e.g. a class module's
// header). The editor shows one procedure at a time (sCurProcIdx), so
// the procedure's starting line within the file's code is added, then
// the source map places the file's line in the concatenated source (its
// startLine already accounts for the injected BEGINFORM / BEGINCLASS).
static int32_t localToConcatLine(int32_t editorLine) {
int32_t fileLine = editorLineToCodeLine(editorLine);
// Editor text bound to no project file is compiled on its own
if (sEditorFileIdx < 0) {
return fileLine;
}
int32_t concatLine = prjMapFileLine(&sProject, sEditorFileIdx, fileLine);
return concatLine > 0 ? concatLine : IDE_NO_LINE;
}
// logFlushLine -- write the pending PRINT line to the log (Output to Log)
static void logFlushLine(void) {
sLogLine[sLogLineLen] = '\0';
dvxLog("BASIC: %s", sLogLine);
sLogLineLen = 0;
}
// lookupWatchVar -- evaluate a simple watch expression by reading the
// paused VM directly. Supports varName, varName(idx, ...), varName.field
// and varName(idx).field; anything else falls back to evalWatchExpr.
static bool lookupWatchVar(const char *expr, BasValueT *outVal) {
const char *end = NULL;
BasValueT *slot = resolveVarPath(dvxSkipWs(expr), &end);
if (!slot || !end || *dvxSkipWs(end) != '\0') {
return false;
}
*outVal = *slot;
return true;
}
static void makeExecutable(void) {
if (!hasProject()) {
setStatus("Save the project first.");
return;
}
// Compile (always recompile to ensure latest code)
if (!compileProject()) {
return;
}
// Ask for output path
FileFilterT filters[] = {
{ "DVX Applications (*.app)" },
{ "All Files (*.*)" }
};
char outPath[DVX_MAX_PATH];
outPath[0] = '\0';
if (!dvxFileDialog(sAc, "Make Executable", FD_SAVE, NULL, filters, DVX_ARRAY_LEN(filters), outPath, sizeof(outPath))) {
return;
}
// Ask debug or release
const char *modeItems[] = {
"Debug (include error info)",
"Release (smaller, no debug info)"
};
int32_t modeChoice = 0;
if (!dvxChoiceDialog(sAc, "Build Mode", "Select build mode:", modeItems, DVX_ARRAY_LEN(modeItems), 0, &modeChoice)) {
return;
}
bool release = (modeChoice == 1);
setStatus(release ? "Building release executable..." : "Building debug executable...");
dvxSetBusy(sAc, true);
dvxUpdate(sAc);
// Gather every .frm text (unsaved editor buffers win over disk).
char **frmSources = NULL; // stb_ds: owned form text
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (sProject.files[i].kind != PrjKindFormE) {
continue;
}
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(i, &owned, &missing);
char *frmSrc = owned ? owned : (text ? strdup(text) : NULL);
if (frmSrc) {
arrput(frmSources, frmSrc);
}
}
BasBuildSpecT spec;
memset(&spec, 0, sizeof(spec));
spec.projName = sProject.name;
spec.author = sProject.author;
spec.publisher = sProject.publisher;
spec.version = sProject.version;
spec.copyright = sProject.copyright;
spec.description = sProject.description;
spec.projectDir = sProject.projectDir;
spec.iconPath = sProject.iconPath;
spec.helpFile = sProject.helpFile;
spec.selfPath = sCtx->appPath;
spec.module = sCachedModule;
spec.frmSources = (const char *const *)frmSources;
spec.frmCount = (int32_t)arrlen(frmSources);
spec.release = release;
const char *failure = basBuildApp(outPath, &spec);
for (int32_t i = 0; i < (int32_t)arrlen(frmSources); i++) {
free(frmSources[i]);
}
arrfree(frmSources);
dvxSetBusy(sAc, false);
if (failure) {
setStatus(failure);
return;
}
char msg[IDE_MSG_BUF];
snprintf(msg, sizeof(msg), "Created %s (%s)", outPath, release ? "release" : "debug");
setStatus(msg);
}
// memberVarSlot -- member variable dv (SCOPE_MEMBER) of the object the
// innermost procedure runs for, or NULL when that procedure is not a
// procedure of dv's class
static BasValueT *memberVarSlot(const BasDebugVarT *dv) {
if (sVm->callDepth <= 0) {
return NULL;
}
const BasValueT *me = &sVm->callStack[sVm->callDepth - 1].me;
if (me->type != BAS_TYPE_INSTANCE) {
return NULL;
}
BasObjectT *obj = me->instVal;
const char *cls = objectClassName(obj);
if (!cls || strcasecmp(cls, dv->formName) != 0 || dv->index < 0 || dv->index >= obj->fieldCount) {
return NULL;
}
return &obj->fields[dv->index];
}
static void navigateToBreakpoint(int32_t bpIdx) {
if (bpIdx < 0 || bpIdx >= (int32_t)arrlen(sBreakpoints)) {
return;
}
navigateToCodeLine(sBreakpoints[bpIdx].fileIdx, sBreakpoints[bpIdx].codeLine, false);
}
// ============================================================
// navigateToCodeLine -- show a specific file/line in the code editor
// ============================================================
//
// fileIdx: project file index (-1 = the editor's current code)
// codeLine: 1-based line within the file's code section
// setDbgLine: if true, update sDbgCurrentLine for the debug decorator
//
// The procedure is the one whose line range holds codeLine (else the
// General section), found after the file is active. Returns the shown
// proc index (IDE_SECTION_GENERAL for General), or IDE_SECTION_NONE when
// the file could not be activated.
static int32_t navigateToCodeLine(int32_t fileIdx, int32_t codeLine, bool setDbgLine) {
if (fileIdx >= 0 && !activateFile(fileIdx, ViewCodeE)) {
return IDE_SECTION_NONE;
}
if (!sCodeWin) {
showCodeWindow();
}
if (sCodeWin && !sCodeWin->visible) {
dvxShowWindow(sAc, sCodeWin);
}
if (sCodeWin) {
dvxRaiseWindow(sAc, sCodeWin);
}
if (!sEditor) {
return IDE_SECTION_NONE;
}
// Line numbers refer to the current buffers; the editor-local line is
// taken before showProc, which may drop an untouched skeleton.
getFullSource();
int32_t procIdx = procIndexForCodeLine(codeLine);
int32_t editorLine = (procIdx >= 0) ? codeLine - sProcTable[procIdx].lineNum + 1 : codeLine;
if (procIdx != sCurProcIdx) {
showProc(procIdx);
}
// Update dropdowns to match
if (sCurProcIdx >= 0 && sCurProcIdx < (int32_t)arrlen(sProcTable)) {
selectDropdowns(sProcTable[sCurProcIdx].objName, sProcTable[sCurProcIdx].evtName);
} else if (sObjDropdown) {
wgtDropdownSetSelected(sObjDropdown, 0);
}
if (setDbgLine) {
sDbgCurrentLine = editorLine;
}
wgtTextAreaGoToLine(sEditor, editorLine);
wgtInvalidatePaint(sEditor);
return sCurProcIdx;
}
// navigateToEventSub -- open code editor at the default event sub for the
// selected control (or form).
static void navigateToEventSub(void) {
if (!sDesigner.form) {
return;
}
// Determine control name and default event
const char *ctrlName = NULL;
const char *eventName = NULL;
if (sDesigner.selectedIdx >= 0 && sDesigner.selectedIdx < (int32_t)arrlen(sDesigner.form->controls)) {
DsgnControlT *ctrl = sDesigner.form->controls[sDesigner.selectedIdx];
ctrlName = ctrl->name;
eventName = dsgnDefaultEvent(ctrl->typeName);
} else {
ctrlName = sDesigner.form->name;
eventName = dsgnDefaultEvent(IDE_FORM_TYPE_NAME);
}
navigateToNamedEventSub(ctrlName, eventName);
}
// navigateToNamedEventSub -- open the code editor at Ctrl_Event, creating
// the sub skeleton if it doesn't exist. Code is stored in the .frm
// file's code section (sDesigner.form->code).
static void navigateToNamedEventSub(const char *ctrlName, const char *eventName) {
if (!sDesigner.form || !ctrlName || !eventName) {
return;
}
// The designer may show a form while another file is active
if (sDesignerFileIdx >= 0 && sDesignerFileIdx != sProject.activeFileIdx && !activateFile(sDesignerFileIdx, ViewCodeE)) {
return;
}
// Load form code into editor (stashes existing code, parses procs,
// populates dropdowns without triggering navigation)
loadFormCodeIntoEditor();
if (!sEditor) {
return;
}
// Search for existing procedure
int32_t procCount = (int32_t)arrlen(sProcTable);
int32_t procIdx = -1;
for (int32_t i = 0; i < procCount; i++) {
if (strcasecmp(sProcTable[i].objName, ctrlName) == 0 && strcasecmp(sProcTable[i].evtName, eventName) == 0) {
procIdx = i;
break;
}
}
if (procIdx >= 0) {
showProc(procIdx);
} else {
createEventSubSkeleton(ctrlName, eventName);
}
if (sCodeWin) {
dvxRaiseWindow(sAc, sCodeWin);
}
setStatus("Code view.");
selectDropdowns(ctrlName, eventName);
}
// newClassModule -- add class module ClassN (the first N whose name no
// form or class of the project uses and whose file does not exist yet),
// holding the standard header, to the project and open it in the editor.
static void newClassModule(void) {
char name[BAS_MAX_IDENT];
char fileName[DVX_MAX_PATH];
char path[DVX_MAX_PATH * 2];
for (int32_t n = 1; ; n++) {
snprintf(name, sizeof(name), IDE_NEW_CLASS_FMT, (int)n);
snprintf(fileName, sizeof(fileName), "%s%s", name, BAS_CLS_EXT);
snprintf(path, sizeof(path), "%s" DVX_PATH_SEP "%s", sProject.projectDir, fileName);
if (!classNameUsed(name, fileName) && !prjPathExists(path)) {
break;
}
}
char text[sizeof(IDE_NEW_CLASS_TEXT) + BAS_MAX_IDENT];
snprintf(text, sizeof(text), IDE_NEW_CLASS_TEXT, name);
bool wasDirty = sProject.dirty;
int32_t idx = prjAddFile(&sProject, fileName, PrjKindClassE);
sProject.files[idx].buffer = strdup(text);
sProject.files[idx].modified = true;
if (!sProject.files[idx].buffer || !activateFile(idx, ViewCodeE)) {
prjRemoveFile(&sProject, idx);
sProject.dirty = wasDirty;
return;
}
invalidateCompiled();
prjRebuildTree(&sProject);
updateDirtyIndicators();
setStatus("Class module added.");
}
static void newProject(void) {
if (!promptAndSave()) {
return;
}
char name[PRJ_MAX_NAME];
if (!dvxInputBox(sAc, "New Project", "Project name:", "", name, sizeof(name))) {
return;
}
if (name[0] == '\0') {
return;
}
// Ask for directory via save dialog (file = name.dbp)
FileFilterT filters[] = {
{ "Project Files (*.dbp)" }
};
char dbpPath[DVX_MAX_PATH];
snprintf(dbpPath, sizeof(dbpPath), "%s%s", name, IDE_DBP_EXT);
if (!dvxFileDialog(sAc, "Save New Project", FD_SAVE, NULL, filters, 1, dbpPath, sizeof(dbpPath))) {
return;
}
closeProject();
// Derive directory from chosen path
char dir[DVX_MAX_PATH];
snprintf(dir, sizeof(dir), "%s", dbpPath);
char *sep = platformPathDirEnd(dir);
if (sep) {
*sep = '\0';
} else {
dir[0] = '.';
dir[1] = '\0';
}
prjNew(&sProject, name, dir, sPrefs);
snprintf(sProject.projectPath, sizeof(sProject.projectPath), "%s", dbpPath);
saveProjectFile();
ensureProjectWindow(false);
updateMainTitle();
setStatus("New project created.");
updateProjectMenuState();
}
// objectClassName -- the class module name of class instance obj in the
// running program, or NULL (a Collection)
static const char *objectClassName(const BasObjectT *obj) {
const BasModuleT *mod = sVm->module;
return (mod && obj->classIdx >= 0 && obj->classIdx < mod->classCount) ? mod->classes[obj->classIdx].name : NULL;
}
static void onBreakpointHit(void *ctx, int32_t line) {
(void)ctx;
// The VM fires this with line == -1 at end-of-sub after a breakpointed
// handler finishes; that is not a real pause point (every genuine pause --
// breakpoint or Step Into/Over/Out -- arrives with a positive line), so
// ignore it. Otherwise Continue would re-pause and require a second press.
// After Stop, a handler still run while runModule unwinds never pauses:
// the state stays Stopping and no debugger UI is driven.
if (line < 0 || sStopRequested || sDbgState == DbgStoppingE) {
return;
}
sDbgState = DbgPausedE;
if (sVm) {
sVm->debugPaused = true;
}
if (line > 0) {
sDbgCurrentLine = line;
debugNavigateToLine(line);
}
debugSetBreakTitles(true);
debugUpdateWindows();
updateProjectMenuState();
setStatus("Paused.");
}
static void onBreakpointListDblClick(WidgetT *w) {
(void)w;
if (!sBreakpointList) {
return;
}
int32_t sel = wgtListViewGetSelected(sBreakpointList);
navigateToBreakpoint(sel);
}
static void onBreakpointListKeyDown(WidgetT *w, int32_t keyCode, int32_t shift) {
(void)w;
(void)shift;
// Delete key
if (keyCode != KEY_DELETE && keyCode != KEY_ASCII_DEL) {
return;
}
if (!sBreakpointList || arrlen(sBreakpoints) == 0) {
return;
}
// Remove selected breakpoints in reverse order to preserve indices
for (int32_t i = (int32_t)arrlen(sBreakpoints) - 1; i >= 0; i--) {
if (wgtListViewIsItemSelected(sBreakpointList, i)) {
arrdel(sBreakpoints, i);
}
}
syncVmBreakpoints();
updateBreakpointWindow();
// Repaint editor to remove breakpoint dots
if (sEditor) {
wgtInvalidatePaint(sEditor);
}
}
static void onBreakpointWinClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onCallStackClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onClose(WindowT *win) {
if (!promptAndSave()) {
return;
}
// Stop any running program
debugStop();
// Prevent stale focus tracking during shutdown
sLastFocusWin = NULL;
// Null widget pointers first so nothing references destroyed widgets
sEditor = NULL;
sOutput = NULL;
sImmediate = NULL;
sObjDropdown = NULL;
sEvtDropdown = NULL;
sStatus = NULL;
sToolbar = NULL;
sStatusBar = NULL;
// Close the project (designer, code, project windows and buffers),
// then whatever can exist without one (toolbox/properties).
closeProject();
closeProjectUi();
if (sOutWin) {
dvxDestroyWindow(sAc, sOutWin);
sOutWin = NULL;
}
if (sImmWin) {
dvxDestroyWindow(sAc, sImmWin);
sImmWin = NULL;
}
if (sLocalsWin) {
dvxDestroyWindow(sAc, sLocalsWin);
sLocalsWin = NULL;
sLocalsList = NULL;
}
if (sCallStackWin) {
dvxDestroyWindow(sAc, sCallStackWin);
sCallStackWin = NULL;
sCallStackList = NULL;
}
if (sWatchWin) {
dvxDestroyWindow(sAc, sWatchWin);
sWatchWin = NULL;
sWatchList = NULL;
sWatchInput = NULL;
}
if (sBreakpointWin) {
dvxDestroyWindow(sAc, sBreakpointWin);
sBreakpointWin = NULL;
sBreakpointList = NULL;
}
// win itself is destroyed last, below, once nothing refers to it
sWin = NULL;
// A running program is still executing sCachedModule (this close
// arrived through its event pump); runModule frees it on exit.
if (sCachedModule && !sVm) {
basModuleFree(sCachedModule);
sCachedModule = NULL;
}
arrfree(sProcTable);
sProcTable = NULL;
for (int32_t i = 0; i < (int32_t)arrlen(sObjItems); i++) {
free((void *)sObjItems[i]);
}
evtItemsReset();
arrfree(sObjItems);
arrfree(sEvtItems);
arrfree(sWithEvents);
sObjItems = NULL;
sEvtItems = NULL;
sWithEvents = NULL;
listRowsFree(&sBpRows);
listRowsFree(&sLocalsRows);
listRowsFree(&sCallRows);
listRowsFree(&sWatchRows);
for (int32_t i = 0; i < (int32_t)arrlen(sWatchExprs); i++) {
free(sWatchExprs[i]);
}
arrfree(sWatchExprs);
sWatchExprs = NULL;
for (int32_t i = 0; i < (int32_t)arrlen(sRecentFiles); i++) {
free(sRecentFiles[i]);
}
arrfree(sRecentFiles);
sRecentFiles = NULL;
arrfree(sBreakpoints);
sBreakpoints = NULL;
arrfree(sVmBreakpoints);
sVmBreakpoints = NULL;
arrfree(sBreakTitles);
sBreakTitles = NULL;
free(sFullSourceCache);
sFullSourceCache = NULL;
free(sEditorPrevText);
sEditorPrevText = NULL;
shfree(sSyntaxMap);
sSyntaxMap = NULL;
prefsClose(sPrefs);
sPrefs = NULL;
// The accelerator table is shared by every IDE window; all of them
// are gone by now, so release it before the main window goes.
dvxFreeAccelTable(win->accelTable);
win->accelTable = NULL;
dvxDestroyWindow(sAc, win);
}
static void onCodeWinClose(WindowT *win) {
// Stash code back before the window is destroyed: a module's text to
// its project buffer, a form's to its code. The proc buffers stay,
// but no section is shown any more (a reopened editor starts empty).
saveCurProc(true);
stashEditor();
dvxDestroyWindow(sAc, win);
sCodeWin = NULL;
sEditor = NULL;
sObjDropdown = NULL;
sEvtDropdown = NULL;
sCurProcIdx = IDE_SECTION_NONE;
if (sLastFocusWin == win) {
sLastFocusWin = NULL;
}
updateProjectMenuState();
}
// Preferences Colors tab: Change... (or a double-click on the list) picks
// a new color for the selected entry in the color dialog.
static void onColorChange(WidgetT *w) {
(void)w;
int32_t idx = wgtListBoxGetSelected(sPrefsDlg.colorList);
if (idx < 0 || idx >= TEXT_SYNTAX_MAX) {
return;
}
if (dvxColorDialog(sAc, sSyntaxColorNames[idx], &sPrefsDlg.syntaxColors[idx])) {
prefsUpdateColorSwatch();
}
}
static void onColorListChange(WidgetT *w) {
(void)w;
prefsUpdateColorSwatch();
}
static void onContentFocus(WindowT *win) {
sLastFocusWin = win;
}
static void onEditorChange(WidgetT *w) {
(void)w;
if (!sEditor) {
return;
}
// Breakpoints follow lines that moved; the snapshot is kept current on
// every edit so each diff covers exactly one change.
const char *text = wgtGetText(sEditor);
int32_t lines = countLines(text);
int32_t delta = lines - sEditorLineCount;
if (delta != 0 && sEditorPrevText) {
shiftBreakpointsForEdit(sEditorPrevText, text, delta);
}
editorSnapshot(lines);
// Mark the file the editor is bound to as modified; the indicators
// only need a refresh when that is news.
if (sEditorFileIdx >= 0 && sEditorFileIdx < prjFileCount(&sProject)) {
PrjFileT *file = &sProject.files[sEditorFileIdx];
bool wasModified = file->modified;
file->modified = true;
// Only mark form dirty when editing the form's code, not a .bas file
if (sEditorFileIdx == sDesignerFileIdx && sDesigner.form) {
sDesigner.form->dirty = true;
}
if (!wasModified) {
updateDirtyIndicators();
}
}
}
// onEvtDropdownChange -- navigate to the selected procedure when the
// event dropdown changes.
static void onEvtDropdownChange(WidgetT *w) {
(void)w;
if (sDropdownNavSuppressed) {
return;
}
if (!sObjDropdown || !sEvtDropdown || !sEditor) {
return;
}
int32_t objIdx = wgtDropdownGetSelected(sObjDropdown);
int32_t evtIdx = wgtDropdownGetSelected(sEvtDropdown);
if (objIdx < 0 || objIdx >= (int32_t)arrlen(sObjItems) || evtIdx < 0 || evtIdx >= (int32_t)arrlen(sEvtItems)) {
return;
}
const char *selObj = sObjItems[objIdx];
const char *selEvt = sEvtItems[evtIdx];
// (Global) shows the General module-level section
if (strcasecmp(selEvt, IDE_GLOBAL_SECTION) == 0) {
showProc(IDE_SECTION_GENERAL);
return;
}
// Strip brackets if present (unimplemented event)
char evtName[BAS_MAX_IDENT];
if (selEvt[0] == '[') {
snprintf(evtName, sizeof(evtName), "%s", selEvt + 1);
int32_t len = (int32_t)strlen(evtName);
if (len > 0 && evtName[len - 1] == ']') {
evtName[len - 1] = '\0';
}
} else {
snprintf(evtName, sizeof(evtName), "%s", selEvt);
}
// Search for an existing proc matching object + event
int32_t procCount = (int32_t)arrlen(sProcTable);
for (int32_t i = 0; i < procCount; i++) {
if (strcasecmp(sProcTable[i].objName, selObj) == 0 && strcasecmp(sProcTable[i].evtName, evtName) == 0) {
showProc(i);
return;
}
}
// (General) lists existing procedures only; a stale entry has no
// event to generate a handler for.
if (strcasecmp(selObj, IDE_GENERAL_SECTION) == 0) {
showProc(IDE_SECTION_GENERAL);
return;
}
createEventSubSkeleton(selObj, evtName);
}
static void onFindClose(WindowT *win) {
(void)win;
closeFindDialog();
}
static void onFindCloseBtn(WidgetT *w) {
(void)w;
closeFindDialog();
}
static void onFindNext(WidgetT *w) {
(void)w;
// The dialog's text wins; with the dialog closed (F3), the last
// search is repeated.
if (sFindInput) {
const char *needle = wgtGetText(sFindInput);
if (!needle || !needle[0]) {
return;
}
snprintf(sFindText, sizeof(sFindText), "%s", needle);
}
if (sFindText[0] && !findInProject(sFindText, getFindMatchCase(), getFindForward(), getFindScope())) {
setStatus("Not found.");
}
}
// onFormWinClose -- shell callback when user clicks X on the form window.
static void onFormWinClose(WindowT *win) {
dvxDestroyWindow(sAc, win);
cleanupFormWin();
}
static int32_t onFormWinCursorQuery(WindowT *win, int32_t x, int32_t y) {
(void)win;
if (!sDesigner.form) {
return 0;
}
// Crosshair when placing a new control
if (sDesigner.activeTool[0] != '\0') {
return CURSOR_CROSSHAIR;
}
if (!sDesigner.form->controls) {
return 0;
}
int32_t count = (int32_t)arrlen(sDesigner.form->controls);
if (sDesigner.selectedIdx < 0 || sDesigner.selectedIdx >= count) {
return 0;
}
DsgnControlT *ctrl = sDesigner.form->controls[sDesigner.selectedIdx];
if (!ctrl->widget || !ctrl->widget->visible || ctrl->widget->w <= 0 || ctrl->widget->h <= 0) {
return 0;
}
int32_t cx = ctrl->widget->x;
int32_t cy = ctrl->widget->y;
int32_t cw = ctrl->widget->w;
int32_t ch = ctrl->widget->h;
int32_t hs = DSGN_HANDLE_SIZE;
// SE handle (check first -- overlaps with E and S)
if (x >= cx + cw - hs/2 && x < cx + cw + hs/2 && y >= cy + ch - hs/2 && y < cy + ch + hs/2) {
return CURSOR_RESIZE_DIAG_NWSE;
}
// E handle (right edge center)
if (x >= cx + cw - hs/2 && x < cx + cw + hs/2 && y >= cy + ch/2 - hs/2 && y < cy + ch/2 + hs/2) {
return CURSOR_RESIZE_H;
}
// S handle (bottom center)
if (x >= cx + cw/2 - hs/2 && x < cx + cw/2 + hs/2 && y >= cy + ch - hs/2 && y < cy + ch + hs/2) {
return CURSOR_RESIZE_V;
}
return 0;
}
static void onFormWinKey(WindowT *win, int32_t key, int32_t mod) {
// Ctrl+X/C/V and Del act on the selected control, like the Edit menu
if ((mod & ACCEL_CTRL) && (key == KEY_CTRL_X || key == KEY_CTRL_C || key == KEY_CTRL_V)) {
designerEditCmd(key == KEY_CTRL_X ? CMD_CUT : (key == KEY_CTRL_C ? CMD_COPY : CMD_PASTE));
return;
}
if (key == KEY_DELETE && sDesigner.selectedIdx >= 0) {
designerEditCmd(CMD_DELETE);
return;
}
// Forward unhandled keys to the widget system
widgetOnKey(win, key, mod);
}
// onFormWinMenu -- menu click on the designer form preview.
// Designer menu items use IDs starting at DSGN_MENU_ID_BASE.
// Clicking one navigates to the menu item's Click event code.
// Other IDs (from shared accel table) fall through to onMenu.
static void onFormWinMenu(WindowT *win, int32_t menuId) {
if (sDesigner.form && menuId >= DSGN_MENU_ID_BASE) {
int32_t idx = menuId - DSGN_MENU_ID_BASE;
int32_t menuCount = (int32_t)arrlen(sDesigner.form->menuItems);
if (idx >= 0 && idx < menuCount) {
const char *name = sDesigner.form->menuItems[idx].name;
if (name[0]) {
navigateToNamedEventSub(name, IDE_MENU_EVENT);
return;
}
}
}
onMenu(win, menuId);
}
// onFormWinMouse -- handle mouse events on the form designer window.
// Coordinates are relative to the window's client area (content box origin).
static void onFormWinMouse(WindowT *win, int32_t x, int32_t y, int32_t buttons) {
(void)win;
static int32_t lastButtons = 0;
bool wasDown = (lastButtons & MOUSE_LEFT) != 0;
bool isDown = (buttons & MOUSE_LEFT) != 0;
if (!sDesigner.form || !sFormWin) {
lastButtons = buttons;
return;
}
bool dirtyBefore = sDesigner.form->dirty;
if (isDown && !wasDown) {
// A click in the designer makes it the Edit menu's target
sLastFocusWin = sFormWin;
// Detect double-click using the system-wide setting
int32_t clicks = multiClickDetect(x, y);
int32_t prevCount = (int32_t)arrlen(sDesigner.form->controls);
bool wasDirty = sDesigner.form->dirty;
dsgnOnMouse(&sDesigner, x, y, false);
int32_t newCount = (int32_t)arrlen(sDesigner.form->controls);
bool nowDirty = sDesigner.form->dirty;
if (newCount != prevCount || (nowDirty && !wasDirty)) {
prpRebuildTree(&sDesigner);
}
prpRefresh(&sDesigner);
dvxInvalidateWindow(sAc, sFormWin);
if (clicks >= 2 && sDesigner.activeTool[0] == '\0') {
navigateToEventSub();
}
} else if (isDown && wasDown) {
// Drag
dsgnOnMouse(&sDesigner, x, y, true);
prpRefresh(&sDesigner);
dvxInvalidateWindow(sAc, sFormWin);
} else if (!isDown && wasDown) {
// Release
dsgnOnMouse(&sDesigner, x, y, false);
prpRefresh(&sDesigner);
dvxInvalidateWindow(sAc, sFormWin);
}
lastButtons = buttons;
// Plain moves change nothing; only a change of dirty state is news
if (sDesigner.form && sDesigner.form->dirty && !dirtyBefore) {
updateDirtyIndicators();
}
}
// onFormWinPaint -- draw selection handles after widgets have painted.
static void onFormWinPaint(WindowT *win, RectT *dirtyArea) {
if (!win) {
return;
}
// Force measure + relayout only on structural changes (control
// add/remove/resize). Selection clicks just need repaint + overlay.
if (win->paintNeeded >= PAINT_FULL && win->widgetRoot) {
widgetCalcMinSizeTree(win->widgetRoot, &sAc->font);
win->widgetRoot->w = 0; // force layout pass
}
// Designer always needs full repaint (handles must be erased/redrawn)
win->paintNeeded = PAINT_FULL;
widgetOnPaint(win, dirtyArea);
// Then draw selection handles on top
dsgnPaintOverlay(&sDesigner);
}
// onFormWinResize -- update form dimensions when the design window is
// resized; only a real size change makes the form dirty.
static void onFormWinResize(WindowT *win, int32_t newW, int32_t newH) {
// Let the widget system handle the layout recalculation
widgetOnResize(win, newW, newH);
// Store the outer window dimensions (win->w/h), not the content
// dimensions (newW/newH), since dvxResizeWindow takes outer dims.
if (sDesigner.form && (sDesigner.form->width != win->w || sDesigner.form->height != win->h)) {
bool wasDirty = sDesigner.form->dirty;
sDesigner.form->width = win->w;
sDesigner.form->height = win->h;
sDesigner.form->dirty = true;
prpRefresh(&sDesigner);
if (!wasDirty) {
updateDirtyIndicators();
}
}
}
static void onGutterClick(WidgetT *w, int32_t lineNum) {
(void)w;
toggleBreakpointLine(lineNum);
}
// onImmediateKeyDown -- Enter in the Immediate window evaluates the line
// it was pressed on. The textarea has already split that line at the
// caret, so the statement is the line above the caret joined with the
// part the split moved down (empty when Enter was pressed at the end).
// A full window cannot take the newline, so nothing was split: the user
// is told instead of evaluating the wrong lines.
static void onImmediateKeyDown(WidgetT *w, int32_t keyCode, int32_t shift) {
(void)w;
(void)shift;
if (keyCode != KEY_ENTER || !sImmediate) {
return;
}
const char *text = wgtGetText(sImmediate);
int32_t caretLine = wgtTextAreaGetCursorLine(sImmediate);
// The statement is on the line above the caret; there is none on line 1
if (!text || caretLine <= 1) {
return;
}
if ((int32_t)strlen(text) >= IDE_MAX_IMM - 1) {
setStatus("The Immediate window is full; delete some text and press Enter again.");
return;
}
char expr[IDE_IMM_LINE_BUF];
int32_t len = lineCopy(text, caretLine - 1, expr, (int32_t)sizeof(expr));
lineCopy(text, caretLine, expr + len, (int32_t)sizeof(expr) - len);
if (*dvxSkipWs(expr) != '\0') {
evaluateImmediate(expr);
}
}
// The IDE keeps sImmWin/sImmediate for its whole lifetime; destroying
// the window here would leave them dangling.
static void onImmWinClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onLocalsClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onMenu(WindowT *win, int32_t menuId) {
(void)win;
handleFileCmd(menuId);
handleEditCmd(menuId);
handleRunCmd(menuId);
handleViewCmd(menuId);
handleWindowCmd(menuId);
handleProjectCmd(menuId);
if (menuId == CMD_PREFERENCES) {
showPreferencesDialog();
}
if (menuId == CMD_DEBUG_LAYOUT && sWin && sWin->menuBar) {
wgtSetDebugLayout(sAc, wmMenuItemIsChecked(sWin->menuBar, CMD_DEBUG_LAYOUT));
}
if (menuId == CMD_HELP_CONTENTS) {
shellOpenHelp(sAc, sIdeHelpFile);
}
if (menuId == CMD_HELP_API) {
shellOpenHelp(sAc, DVX_SYSTEM_HELP_FILE_LITERAL);
}
if (menuId == CMD_HELP_ABOUT) {
dvxMessageBox(sAc, "About DVX BASIC",
"DVX BASIC 1.0\n"
"Visual BASIC Development Environment\n"
"for the DVX GUI System\n"
"\n"
"Copyright 2026 Scott Duensing",
MB_OK | MB_ICONINFO);
}
}
// onObjDropdownChange -- update the Event dropdown when the Object
// selection changes.
static void onObjDropdownChange(WidgetT *w) {
(void)w;
if (!sObjDropdown || !sEvtDropdown) {
return;
}
int32_t objIdx = wgtDropdownGetSelected(sObjDropdown);
if (objIdx < 0 || objIdx >= (int32_t)arrlen(sObjItems)) {
return;
}
const char *selObj = sObjItems[objIdx];
// A WithEvents variable's events are its class's. Read first: reading
// the editor's own class rebuilds sProcTable, which the list of events
// with code below points into.
const IdeWithEventsT *withEvents = findWithEvents(selObj);
IdeClassEventT *classEvents = NULL;
if (withEvents) {
classEventsOf(withEvents->className, &classEvents);
}
// Collect which events already have code
evtItemsReset();
int32_t procCount = (int32_t)arrlen(sProcTable);
const char **existingEvts = NULL; // stb_ds temp array
for (int32_t i = 0; i < procCount; i++) {
if (strcasecmp(sProcTable[i].objName, selObj) == 0) {
arrput(existingEvts, sProcTable[i].evtName);
}
}
if (strcasecmp(selObj, IDE_GENERAL_SECTION) == 0) {
// Always include (Global) to access module-level code
evtItemAdd(IDE_GLOBAL_SECTION, false);
for (int32_t i = 0; i < (int32_t)arrlen(existingEvts); i++) {
evtItemAdd(existingEvts[i], false);
}
arrfree(existingEvts);
arrfree(classEvents);
int32_t evtCount = (int32_t)arrlen(sEvtItems);
// Sort procs after (Global)
if (evtCount > 2) {
qsort(sEvtItems + 1, evtCount - 1, sizeof(const char *), cmpStrPtrs);
}
wgtDropdownSetItems(sEvtDropdown, sEvtItems, evtCount);
wgtDropdownSetSelected(sEvtDropdown, 0);
onEvtDropdownChange(sEvtDropdown);
return;
}
// Check if this is a form name
bool isForm = false;
if (sDesigner.form && strcasecmp(selObj, sDesigner.form->name) == 0) {
isForm = true;
}
// Check if this is a menu item (only event is Click)
bool isMenuItem = false;
if (!isForm && sDesigner.form) {
for (int32_t i = 0; i < (int32_t)arrlen(sDesigner.form->menuItems); i++) {
if (strcasecmp(sDesigner.form->menuItems[i].name, selObj) == 0) {
isMenuItem = true;
break;
}
}
}
// The control's type and widget interface (its own events)
const WgtIfaceT *iface = NULL;
const char *ctrlType = NULL;
if (!isForm && !isMenuItem && sDesigner.form) {
for (int32_t i = 0; i < (int32_t)arrlen(sDesigner.form->controls); i++) {
if (strcasecmp(sDesigner.form->controls[i]->name, selObj) == 0) {
const char *wgtName = wgtFindByBasName(sDesigner.form->controls[i]->typeName);
ctrlType = sDesigner.form->controls[i]->typeName;
if (wgtName) {
iface = wgtGetIface(wgtName);
}
break;
}
}
}
// Standard events for this kind of object, from the master table
// (NULL-terminated stb_ds temp array); a WithEvents variable's are its
// class's Events
const char **availEvents = NULL;
if (withEvents) {
for (int32_t i = 0; i < (int32_t)arrlen(classEvents); i++) {
arrput(availEvents, classEvents[i].name);
}
} else if (isMenuItem) {
arrput(availEvents, IDE_MENU_EVENT);
} else {
bool draws = (ctrlType != NULL && strcasecmp(ctrlType, BAS_PICTUREBOX_TYPE) == 0);
uint8_t scope = isForm ? BAS_EVT_SCOPE_FORM : (BAS_EVT_SCOPE_CTRL | (draws ? BAS_EVT_SCOPE_DRAW : 0));
for (int32_t i = 0; i < IDE_EVENT_COUNT; i++) {
if (sEventTable[i].scope & scope) {
arrput(availEvents, sEventTable[i].suffix);
}
}
}
arrput(availEvents, NULL);
// Build the event list: standard events + widget-specific events
// Add standard events (common or form)
for (int32_t i = 0; availEvents[i]; i++) {
bool hasCode = false;
for (int32_t j = 0; j < (int32_t)arrlen(existingEvts); j++) {
if (strcasecmp(existingEvts[j], availEvents[i]) == 0) {
hasCode = true;
break;
}
}
evtItemAdd(availEvents[i], !hasCode);
}
// Add widget-specific events
if (iface) {
for (int32_t i = 0; i < iface->eventCount; i++) {
const char *evtName = iface->events[i].name;
// Skip if already in the standard list
bool alreadyListed = false;
for (int32_t j = 0; availEvents[j]; j++) {
if (strcasecmp(availEvents[j], evtName) == 0) {
alreadyListed = true;
break;
}
}
if (alreadyListed) {
continue;
}
bool hasCode = false;
for (int32_t j = 0; j < (int32_t)arrlen(existingEvts); j++) {
if (strcasecmp(existingEvts[j], evtName) == 0) {
hasCode = true;
break;
}
}
evtItemAdd(evtName, !hasCode);
}
}
// Add any existing events not in the standard/widget list (custom subs)
for (int32_t i = 0; i < (int32_t)arrlen(existingEvts); i++) {
bool alreadyListed = false;
int32_t evtCount = (int32_t)arrlen(sEvtItems);
for (int32_t j = 0; j < evtCount; j++) {
if (evtLabelMatches(sEvtItems[j], existingEvts[i])) {
alreadyListed = true;
break;
}
}
if (!alreadyListed) {
evtItemAdd(existingEvts[i], false);
}
}
arrfree(existingEvts);
arrfree(availEvents);
// The default event of a WithEvents variable: its class's first
const char *withEventsDefault = NULL;
char firstEvent[BAS_MAX_IDENT];
if (arrlen(classEvents) > 0) {
snprintf(firstEvent, sizeof(firstEvent), "%s", classEvents[0].name);
withEventsDefault = firstEvent;
}
arrfree(classEvents);
int32_t evtCount = (int32_t)arrlen(sEvtItems);
// Sort: implemented events first, then unimplemented, alphabetical within each
if (evtCount > 1) {
qsort(sEvtItems, evtCount, sizeof(const char *), cmpEvtPtrs);
}
wgtDropdownSetItems(sEvtDropdown, sEvtItems, evtCount);
if (evtCount > 0) {
// Find the first implemented event (no brackets)
int32_t selectIdx = -1;
for (int32_t i = 0; i < evtCount; i++) {
if (sEvtItems[i][0] != '[') {
selectIdx = i;
break;
}
}
if (selectIdx >= 0) {
// Navigate to the first implemented event
wgtDropdownSetSelected(sEvtDropdown, selectIdx);
onEvtDropdownChange(sEvtDropdown);
} else {
// No implemented events -- find and select the default event
// for this widget type, which will create its skeleton
const char *defEvt = withEventsDefault;
if (isForm) {
defEvt = dsgnDefaultEvent(IDE_FORM_TYPE_NAME);
} else if (!withEvents && sDesigner.form) {
for (int32_t i = 0; i < (int32_t)arrlen(sDesigner.form->controls); i++) {
if (strcasecmp(sDesigner.form->controls[i]->name, selObj) == 0) {
defEvt = dsgnDefaultEvent(sDesigner.form->controls[i]->typeName);
break;
}
}
}
if (!defEvt) {
defEvt = IDE_FALLBACK_EVENT;
}
// Find the default event in the list (it will be bracketed)
for (int32_t i = 0; i < evtCount; i++) {
if (evtLabelMatches(sEvtItems[i], defEvt)) {
wgtDropdownSetSelected(sEvtDropdown, i);
onEvtDropdownChange(sEvtDropdown);
break;
}
}
}
}
}
// Hide (not destroy): sOutWin/sOutput stay bound for PRINT output.
static void onOutWinClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onPrefsCancel(WidgetT *w) {
(void)w;
sPrefsDlg.done = true;
}
// onPrefsClose -- the window's close box cancels; showPreferencesDialog
// destroys the window once its loop sees done.
static void onPrefsClose(WindowT *win) {
(void)win;
sPrefsDlg.done = true;
}
static void onPrefsOk(WidgetT *w) {
(void)w;
sPrefsDlg.accepted = true;
sPrefsDlg.done = true;
}
static void onPrjFileDblClick(int32_t fileIdx) {
activateFile(fileIdx, ViewAutoE);
}
static void onProjectWinClose(WindowT *win) {
prjDestroyWindow(sAc, win);
sProjectWin = NULL;
}
static void onReplace(WidgetT *w) {
(void)w;
if (!sEditor || !sFindInput || !sReplInput || !isReplaceEnabled()) {
return;
}
const char *needle = wgtGetText(sFindInput);
const char *repl = wgtGetText(sReplInput);
if (!needle || !needle[0]) {
return;
}
snprintf(sFindText, sizeof(sFindText), "%s", needle);
snprintf(sReplaceText, sizeof(sReplaceText), "%s", repl ? repl : "");
bool caseSens = getFindMatchCase();
bool forward = getFindForward();
// Single Replace always acts on the editor currently shown: if its
// selection matches the search term, splice in the replacement and
// advance to the next match; otherwise just find next. Find Next's
// own scope/direction handling (which may switch procs or files) is
// only reached when there is no matching selection to replace, so a
// cross-file single replace stays unambiguous -- consistent with how
// onReplaceAll treats each scope as a sequence of in-editor passes.
if (wgtTextAreaReplaceSelection(sEditor, sFindText, sReplaceText, caseSens, forward)) {
return;
}
onFindNext(w);
}
static void onReplaceAll(WidgetT *w) {
(void)w;
if (!sFindInput || !sReplInput || !isReplaceEnabled()) {
return;
}
const char *needle = wgtGetText(sFindInput);
const char *repl = wgtGetText(sReplInput);
if (!needle || !needle[0]) {
return;
}
snprintf(sFindText, sizeof(sFindText), "%s", needle);
snprintf(sReplaceText, sizeof(sReplaceText), "%s", repl ? repl : "");
bool caseSens = getFindMatchCase();
FindScopeE scope = getFindScope();
int32_t totalCount = 0;
if (scope == ScopeFuncE && sEditor) {
totalCount = wgtTextAreaReplaceAll(sEditor, sFindText, sReplaceText, caseSens);
} else if (scope == ScopeProjE) {
int32_t needleLen = (int32_t)strlen(sFindText);
// Every file is searched in its project buffer (stashCurrentFile
// also saves the editor into its sections first)
if (!stashCurrentFile()) {
return;
}
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
// Skip files whose code has no match at all
if (!fileCodeContains(i, sFindText, needleLen, caseSens)) {
continue;
}
if (!activateFile(i, ViewCodeE)) {
break;
}
totalCount += replaceInSections(NULL, caseSens);
}
} else if (scope == ScopeFileE && sEditor) {
totalCount = replaceInSections(NULL, caseSens);
} else if (scope == ScopeObjE && sEditor) {
char objName[BAS_MAX_IDENT];
currentObjName(objName, sizeof(objName));
if (objName[0]) {
totalCount = replaceInSections(objName, caseSens);
}
}
char statusBuf[BAS_MAX_IDENT];
snprintf(statusBuf, sizeof(statusBuf), "%d replacement(s) made.", (int)totalCount);
setStatus(statusBuf);
}
static void onReplCheckChange(WidgetT *w) {
(void)w;
bool show = isReplaceEnabled();
if (sReplInput) {
sReplInput->enabled = show;
}
if (sBtnReplace) {
sBtnReplace->enabled = show;
}
if (sBtnReplAll) {
sBtnReplAll->enabled = show;
}
if (sFindWin) {
dvxInvalidateWindow(sAc, sFindWin);
}
}
static void onTbCode(WidgetT *w) {
(void)w;
handleViewCmd(CMD_VIEW_CODE);
}
static void onTbDebug(WidgetT *w) {
(void)w;
handleRunCmd(CMD_DEBUG);
}
static void onTbDesign(WidgetT *w) {
(void)w;
handleViewCmd(CMD_VIEW_DESIGN);
}
static void onTbOpen(WidgetT *w) {
(void)w;
handleProjectCmd(CMD_PRJ_OPEN);
}
static void onTbRun(WidgetT *w) {
(void)w;
handleRunCmd(CMD_RUN);
}
static void onTbRunToCur(WidgetT *w) {
(void)w;
handleRunCmd(CMD_RUN_TO_CURSOR);
}
static void onTbSave(WidgetT *w) {
(void)w;
handleFileCmd(CMD_SAVE);
}
static void onTbStepInto(WidgetT *w) {
(void)w;
handleRunCmd(CMD_STEP_INTO);
}
static void onTbStepOut(WidgetT *w) {
(void)w;
handleRunCmd(CMD_STEP_OUT);
}
static void onTbStepOver(WidgetT *w) {
(void)w;
handleRunCmd(CMD_STEP_OVER);
}
static void onTbStop(WidgetT *w) {
(void)w;
handleRunCmd(CMD_STOP);
}
static void onWatchClose(WindowT *win) {
dvxHideWindow(sAc, win);
}
static void onWatchInputKeyDown(WidgetT *w, int32_t keyCode, int32_t shift) {
(void)w;
(void)shift;
if (keyCode != '\r' && keyCode != '\n') {
return;
}
if (!sWatchInput) {
return;
}
const char *text = wgtGetText(sWatchInput);
if (!text || !text[0]) {
return;
}
// Add to watch list
char *copy = strdup(text);
if (!copy) {
return;
}
arrput(sWatchExprs, copy);
updateWatchWindow();
// Clear input
wgtSetText(sWatchInput, "");
}
static void onWatchListDblClick(WidgetT *w) {
(void)w;
watchEditSelected();
}
static void onWatchListKeyDown(WidgetT *w, int32_t keyCode, int32_t shift) {
(void)w;
(void)shift;
// Enter -- edit selected item
if (keyCode == '\r' || keyCode == '\n') {
watchEditSelected();
return;
}
// Delete key (scancode 0x53 with extended flag)
if (keyCode != KEY_DELETE && keyCode != KEY_ASCII_DEL) {
return;
}
if (!sWatchList) {
return;
}
int32_t sel = wgtListViewGetSelected(sWatchList);
if (sel < 0 || sel >= (int32_t)arrlen(sWatchExprs)) {
return;
}
free(sWatchExprs[sel]);
arrdel(sWatchExprs, sel);
updateWatchWindow();
}
// openAnyPath -- open a project (.dbp) in place of the current one, or
// a .bas/.frm (see openSinglePath)
static void openAnyPath(const char *path) {
if (dvxHasExt(platformPathBaseName(path), IDE_DBP_EXT)) {
if (promptAndSave()) {
openProjectPath(path);
}
} else {
openSinglePath(path);
}
}
static void openFindDialog(bool showReplace) {
if (sFindWin) {
// Already open -- just toggle replace mode and raise
if (sReplCheck) {
wgtCheckboxSetChecked(sReplCheck, showReplace);
onReplCheckChange(sReplCheck);
}
dvxRaiseWindow(sAc, sFindWin);
return;
}
sFindWin = dvxCreateWindowCentered(sAc, "Find / Replace", IDE_FIND_WIN_W, IDE_FIND_WIN_H, false);
if (!sFindWin) {
return;
}
sFindWin->onClose = onFindClose;
sFindWin->onMenu = onMenu;
sFindWin->accelTable = sWin ? sWin->accelTable : NULL;
if (!findDialogBuild(showReplace)) {
closeFindDialog();
ideErrorBox("Not enough memory to open Find / Replace.");
return;
}
// Set initial replace enable state
onReplCheckChange(sReplCheck);
dvxFitWindow(sAc, sFindWin);
}
static void openProject(void) {
if (!promptAndSave()) {
return;
}
FileFilterT filters[] = {
{ "Project Files (*.dbp)" },
{ "All Files (*.*)" }
};
char path[DVX_MAX_PATH];
if (!dvxFileDialog(sAc, "Open Project", FD_OPEN, NULL, filters, DVX_ARRAY_LEN(filters), path, sizeof(path))) {
return;
}
openProjectPath(path);
}
// openProjectPath -- open a .dbp in place of the current project. The
// new project is loaded first; if that fails the current one stays open
// and the path is dropped from the Recent list.
static void openProjectPath(const char *path) {
PrjStateT *loaded = (PrjStateT *)malloc(sizeof(PrjStateT));
if (!loaded) {
ideErrorBox("Not enough memory to open the project.");
return;
}
prjInit(loaded);
// prjLoad fails for a missing .dbp, so a stale recent entry is
// rejected here instead of opening as a phantom empty project.
if (!prjLoad(loaded, path)) {
prjClose(loaded);
free(loaded);
ideErrorBox("Could not open project file.");
recentRemove(path);
return;
}
closeProject();
sProject = *loaded;
free(loaded);
prjLoadAllFiles(&sProject, sAc);
ensureProjectWindow(false);
updateMainTitle();
setStatus("Project loaded.");
updateProjectMenuState();
recentAdd(path);
}
// openSinglePath -- open a .bas/.cls/.frm: added to the current project, or
// used to create an implicit project when none is open.
static void openSinglePath(const char *path) {
if (hasProject()) {
if (addFileToProject(path)) {
recentAdd(path);
}
return;
}
if (!promptAndSave()) {
return;
}
ensureProject(path);
ensureProjectWindow(true);
updateProjectMenuState();
recentAdd(path);
}
// outputAppend -- add program/report text to the Output buffer, dropping
// the oldest lines when it is full so the newest text always shows
static void outputAppend(const char *text, int32_t len) {
sOutputLen = appendDroppingLines(sOutputBuf, IDE_MAX_OUTPUT, sOutputLen, text, len);
sOutputPending = true;
}
// outputLog -- with Output to Log on, log a compile or runtime report
static void outputLog(const char *text) {
if (sOutputToLog && text[0]) {
dvxLog("BASIC: %s", text);
}
}
// packProcLayout -- normalize source text to the canonical proc layout
// (see joinProcArrays). Returns a malloc'd string or NULL.
static char *packProcLayout(const char *source) {
char *general = NULL;
char **procs = NULL;
if (!splitProcs(source, &general, &procs, NULL)) {
return NULL;
}
char *packed = joinProcArrays(general, procs);
free(general);
for (int32_t i = 0; i < (int32_t)arrlen(procs); i++) {
free(procs[i]);
}
arrfree(procs);
return packed;
}
// parseIndexList -- parse "i1, i2, ...)" starting just after the '('.
// Returns the position after the closing ')' (or where parsing stopped).
static const char *parseIndexList(const char *p, int32_t *indices, int32_t *outCount) {
int32_t n = 0;
while (*p && *p != ')' && n < BAS_ARRAY_MAX_DIMS) {
const char *start = p;
p = dvxSkipWs(p);
indices[n++] = atoi(p);
// Skip past the number
if (*p == '-') {
p++;
}
while (*p >= '0' && *p <= '9') {
p++;
}
p = dvxSkipWs(p);
if (*p == ',') {
p++;
}
// Anything unparseable would otherwise spin forever
if (p == start) {
break;
}
}
if (*p == ')') {
p++;
}
*outCount = n;
return p;
}
// parseProcs -- split source into (General) + per-procedure buffers
static void parseProcs(const char *source) {
freeProcBufs();
// Out of memory: keep the text whole in (General) rather than lose it
if (!splitProcs(source ? source : "", &sGeneralBuf, &sProcBufs, NULL)) {
sGeneralBuf = strdup(source ? source : "");
}
}
// pasteParseControl -- parse one "Begin <Type> <Name> ... End" block with
// the designer's .frm loader by wrapping it in a scratch form. Returns
// the loaded control record (the caller owns it), or NULL.
static DsgnControlT *pasteParseControl(const char *clip, int32_t clipLen) {
static const char head[] = FRM_BEGIN_TAG IDE_FORM_TYPE_NAME " " IDE_PASTE_FORM "\n";
static const char tail[] = "\n" FRM_END_TAG "\n";
int32_t len = (int32_t)(sizeof(head) - 1) + clipLen + (int32_t)(sizeof(tail) - 1);
char *text = (char *)malloc((size_t)len + 1);
if (!text) {
return NULL;
}
memcpy(text, head, sizeof(head) - 1);
memcpy(text + sizeof(head) - 1, clip, (size_t)clipLen);
memcpy(text + sizeof(head) - 1 + clipLen, tail, sizeof(tail));
DsgnStateT tmp;
DsgnControlT *ctrl = NULL;
memset(&tmp, 0, sizeof(tmp));
if (dsgnLoadFrm(&tmp, text, len) && tmp.form && arrlen(tmp.form->controls) > 0) {
ctrl = tmp.form->controls[0];
arrdel(tmp.form->controls, 0);
}
dsgnFree(&tmp);
free(text);
return ctrl;
}
// pathExists -- true when a file can be opened for reading
// prefsBuild -- build the Preferences dialog's widgets into win and load
// the current settings. Returns false if any widget could not be made.
static bool prefsBuild(WindowT *win) {
WidgetT *root = wgtInitWindow(sAc, win);
WidgetT *tabs = root ? wgtTabControl(root) : NULL;
if (!tabs) {
return false;
}
root->spacing = wgtPixels(IDE_WIDGET_SPACING);
tabs->weight = WGT_WEIGHT_FILL;
// ======== General tab ========
WidgetT *generalPage = wgtTabPage(tabs, "General");
WidgetT *edFrame = generalPage ? wgtFrame(generalPage, "Editor") : NULL;
if (!edFrame) {
return false;
}
generalPage->spacing = wgtPixels(IDE_WIDGET_SPACING);
edFrame->spacing = wgtPixels(IDE_WIDGET_SPACING_SM);
sPrefsDlg.renameSkipComments = wgtCheckbox(edFrame, "Skip comments/strings when renaming");
sPrefsDlg.optionExplicit = wgtCheckbox(edFrame, "OPTION EXPLICIT default for new projects");
WidgetT *tabRow = wgtHBox(edFrame);
if (!sPrefsDlg.renameSkipComments || !sPrefsDlg.optionExplicit || !tabRow || !wgtLabel(tabRow, "Tab width:")) {
return false;
}
wgtCheckboxSetChecked(sPrefsDlg.renameSkipComments, prefsGetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_RENAME_SKIP, true));
wgtCheckboxSetChecked(sPrefsDlg.optionExplicit, prefsGetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_OPTION_EXPLICIT, false));
tabRow->spacing = wgtPixels(IDE_WIDGET_SPACING);
sPrefsDlg.tabWidthInput = wgtTextInput(tabRow, IDE_PREFS_TAB_INPUT_MAX);
sPrefsDlg.useSpaces = wgtCheckbox(edFrame, "Insert spaces instead of tabs");
if (!sPrefsDlg.tabWidthInput || !sPrefsDlg.useSpaces) {
return false;
}
char tabBuf[IDE_TAB_WIDTH_BUF];
snprintf(tabBuf, sizeof(tabBuf), "%d", (int)prefsGetInt(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_TAB_WIDTH, IDE_DEFAULT_TAB_WIDTH));
sPrefsDlg.tabWidthInput->maxW = wgtPixels(IDE_PREFS_TAB_INPUT_W);
wgtSetText(sPrefsDlg.tabWidthInput, tabBuf);
wgtCheckboxSetChecked(sPrefsDlg.useSpaces, prefsGetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_USE_SPACES, true));
// Project Defaults section
WidgetT *prjFrame = wgtFrame(generalPage, "New Project Defaults");
if (!prjFrame) {
return false;
}
prjFrame->spacing = wgtPixels(IDE_WIDGET_SPACING_SM);
prjFrame->weight = WGT_WEIGHT_FILL;
sPrefsDlg.defAuthor = prefsTextRow(prjFrame, "Author:", IDE_PREFS_TEXT_MAX, prefsGetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_AUTHOR, ""));
sPrefsDlg.defPublisher = prefsTextRow(prjFrame, "Publisher:", IDE_PREFS_TEXT_MAX, prefsGetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_PUBLISHER, ""));
sPrefsDlg.defVersion = prefsTextRow(prjFrame, "Version:", IDE_PREFS_VERSION_MAX, prefsGetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_VERSION, IDE_PREF_DEFAULT_VERSION));
sPrefsDlg.defCopyright = prefsTextRow(prjFrame, "Copyright:", IDE_PREFS_TEXT_MAX, prefsGetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_COPYRIGHT, ""));
// One line, as long as a project's [Project] Description can be: an
// INI value is a single line (see prjSingleLine).
sPrefsDlg.defDescription = prefsTextRow(prjFrame, "Description:", PRJ_MAX_DESC - 1, prefsGetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_DESCRIPTION, ""));
if (!sPrefsDlg.defAuthor || !sPrefsDlg.defPublisher || !sPrefsDlg.defVersion || !sPrefsDlg.defCopyright || !sPrefsDlg.defDescription) {
return false;
}
// ======== Colors tab ========
// Load current colors from prefs (or defaults)
for (int32_t i = 0; i < TEXT_SYNTAX_MAX; i++) {
char key[IDE_PREF_KEY_BUF];
snprintf(key, sizeof(key), PREF_KEY_COLOR_FMT, (int)i);
sPrefsDlg.syntaxColors[i] = (uint32_t)prefsGetInt(sPrefs, PREF_SEC_SYNTAX, key, (int32_t)textEditDefaultSyntaxRgb((uint8_t)i));
}
WidgetT *colorsPage = wgtTabPage(tabs, "Colors");
WidgetT *colorsHBox = colorsPage ? wgtHBox(colorsPage) : NULL;
// Left: color list. Right: swatch, values and Change...
sPrefsDlg.colorList = colorsHBox ? wgtListBox(colorsHBox) : NULL;
WidgetT *colorBox = sPrefsDlg.colorList ? wgtVBox(colorsHBox) : NULL;
WidgetT *caption = colorBox ? wgtLabel(colorBox, "Color:") : NULL;
sPrefsDlg.colorSwatch = caption ? wgtCanvas(colorBox, IDE_SWATCH_W, IDE_SWATCH_H) : NULL;
sPrefsDlg.lblR = sPrefsDlg.colorSwatch ? wgtLabel(colorBox, "") : NULL;
sPrefsDlg.lblG = sPrefsDlg.lblR ? wgtLabel(colorBox, "") : NULL;
sPrefsDlg.lblB = sPrefsDlg.lblG ? wgtLabel(colorBox, "") : NULL;
WidgetT *changeBtn = sPrefsDlg.lblB ? wgtButton(colorBox, "Change...") : NULL;
if (!changeBtn) {
return false;
}
colorsPage->spacing = wgtPixels(IDE_WIDGET_SPACING);
colorsHBox->spacing = wgtPixels(IDE_WIDGET_SPACING_LG);
colorsHBox->weight = WGT_WEIGHT_FILL;
sPrefsDlg.colorList->weight = WGT_WEIGHT_FILL;
sPrefsDlg.colorList->onChange = onColorListChange;
sPrefsDlg.colorList->onDblClick = onColorChange;
colorBox->spacing = wgtPixels(IDE_WIDGET_SPACING_SM);
colorBox->weight = WGT_WEIGHT_FILL;
changeBtn->onClick = onColorChange;
wgtListBoxSetItems(sPrefsDlg.colorList, sSyntaxColorNames, TEXT_SYNTAX_MAX);
// Start on the Keywords entry (the most commonly customized)
wgtListBoxSetSelected(sPrefsDlg.colorList, TEXT_SYNTAX_KEYWORD);
prefsUpdateColorSwatch();
wgtTabControlSetActive(tabs, 0);
// ---- OK / Cancel ----
WidgetT *btnRow = wgtHBox(root);
WidgetT *btnOk = btnRow ? wgtButton(btnRow, "OK") : NULL;
WidgetT *btnCancel = btnOk ? wgtButton(btnRow, "Cancel") : NULL;
if (!btnCancel) {
return false;
}
btnRow->spacing = wgtPixels(IDE_WIDGET_SPACING_LG);
btnRow->align = AlignEndE;
btnOk->minW = wgtPixels(IDE_PREFS_BUTTON_W);
btnOk->onClick = onPrefsOk;
btnCancel->minW = wgtPixels(IDE_PREFS_BUTTON_W);
btnCancel->onClick = onPrefsCancel;
return true;
}
// prefsSetChannelLabel -- "Channel value" under the Colors tab swatch
static void prefsSetChannelLabel(WidgetT *label, const char *channel, uint8_t value) {
char buf[IDE_RGB_LABEL_BUF];
snprintf(buf, sizeof(buf), "%s %d", channel, (int)value);
wgtSetText(label, buf);
}
// prefsTextRow -- "Caption: [input]" row holding value. Returns the input,
// NULL if a widget could not be made.
static WidgetT *prefsTextRow(WidgetT *parent, const char *caption, int32_t maxLen, const char *value) {
WidgetT *row = wgtHBox(parent);
WidgetT *label = row ? wgtLabel(row, caption) : NULL;
WidgetT *input = label ? wgtTextInput(row, maxLen) : NULL;
if (!input) {
return NULL;
}
row->spacing = wgtPixels(IDE_WIDGET_SPACING);
label->minW = wgtPixels(IDE_PREFS_LABEL_W);
input->weight = WGT_WEIGHT_FILL;
wgtSetText(input, value);
return input;
}
// Shows the selected syntax color in the swatch and as numbers.
static void prefsUpdateColorSwatch(void) {
int32_t idx = wgtListBoxGetSelected(sPrefsDlg.colorList);
if (idx < 0 || idx >= TEXT_SYNTAX_MAX) {
return;
}
uint32_t rgb = sPrefsDlg.syntaxColors[idx];
uint8_t r = DVX_RGB_RED(rgb);
uint8_t g = DVX_RGB_GREEN(rgb);
uint8_t b = DVX_RGB_BLUE(rgb);
prefsSetChannelLabel(sPrefsDlg.lblR, "Red", r);
prefsSetChannelLabel(sPrefsDlg.lblG, "Green", g);
prefsSetChannelLabel(sPrefsDlg.lblB, "Blue", b);
wgtCanvasClear(sPrefsDlg.colorSwatch, packColor(&sAc->display, r, g, b));
}
// printCallback -- PRINT from the running program. The text is buffered
// (the pane is refreshed once per event-loop pass, see flushOutput) and,
// with Output to Log on, logged one line at a time.
static void printCallback(void *ctx, const char *text, bool newline) {
(void)ctx;
if (!text) {
return;
}
int32_t textLen = (int32_t)strlen(text);
outputAppend(text, textLen);
if (newline) {
outputAppend("\n", 1);
}
if (!sOutputToLog) {
return;
}
for (int32_t i = 0; i < textLen; i++) {
if (sLogLineLen >= (int32_t)sizeof(sLogLine) - 1) {
logFlushLine();
}
sLogLine[sLogLineLen++] = text[i];
}
if (newline) {
logFlushLine();
}
}
// procBodyEmpty -- true when a proc's text has nothing but blank lines
// between its declaration and its End Sub / End Function
static bool procBodyEmpty(const char *procText) {
bool isSub = false;
const char *p = dvxSkipWs(procText);
const char *afterKw = procDeclAt(p, &isSub);
const char *endTag = (afterKw && !isSub) ? KW_END_FUNCTION : KW_END_SUB;
for (p = skipLine(p); *p && !kwMatch(dvxSkipWs(p), endTag); p = skipLine(p)) {
const char *q = dvxSkipWs(p);
if (*q != '\n' && *q != '\r' && *q != '\0') {
return false;
}
}
return true;
}
// procBufContains -- true if needle occurs anywhere in a proc buffer.
static bool procBufContains(const char *hay, const char *needle, int32_t needleLen, bool caseSensitive) {
if (!hay) {
return false;
}
if (caseSensitive) {
return strstr(hay, needle) != NULL;
}
return findSubstrNoCase(hay, needle, needleLen) != NULL;
}
// procDeclAt -- if p (already whitespace-skipped) starts a SUB or
// FUNCTION declaration (Public or Private in front allowed), returns the
// text after the keyword; else NULL.
static const char *procDeclAt(const char *p, bool *outIsSub) {
if (kwMatch(p, KW_PUBLIC)) {
p = dvxSkipWs(p + KW_LEN(KW_PUBLIC));
} else if (kwMatch(p, KW_PRIVATE)) {
p = dvxSkipWs(p + KW_LEN(KW_PRIVATE));
}
if (kwMatch(p, KW_SUB)) {
*outIsSub = true;
return p + KW_LEN(KW_SUB);
}
if (kwMatch(p, KW_FUNCTION)) {
*outIsSub = false;
return p + KW_LEN(KW_FUNCTION);
}
return NULL;
}
// procIndexByName -- sProcTable index of the proc objName/evtName, or -1
static int32_t procIndexByName(const char *objName, const char *evtName) {
for (int32_t i = 0; i < (int32_t)arrlen(sProcTable); i++) {
if (strcasecmp(sProcTable[i].objName, objName) == 0 && strcasecmp(sProcTable[i].evtName, evtName) == 0) {
return i;
}
}
return -1;
}
// procIndexForCodeLine -- sProcTable index of the proc whose declaration
// through End line range holds codeLine, or -1 for the (General) section
static int32_t procIndexForCodeLine(int32_t codeLine) {
for (int32_t i = 0; i < (int32_t)arrlen(sProcTable); i++) {
if (codeLine >= sProcTable[i].lineNum && codeLine <= sProcTable[i].endLineNum) {
return i;
}
}
return -1;
}
// procNameFromDecl -- copy the procedure name that follows a SUB/FUNCTION
// keyword (stops at '(' or whitespace).
static void procNameFromDecl(const char *afterKw, char *out, int32_t outSize) {
const char *p = dvxSkipWs(afterKw);
int32_t n = 0;
while (*p && *p != '(' && *p != ' ' && *p != '\t' && *p != '\r' && *p != '\n' && n < outSize - 1) {
out[n++] = *p++;
}
out[n] = '\0';
}
// procNameOf -- the name a proc's text declares (its first line)
static void procNameOf(const char *procText, char *out, int32_t outSize) {
bool isSub = false;
const char *afterKw = procDeclAt(dvxSkipWs(procText), &isSub);
procNameFromDecl(afterKw ? afterKw : procText, out, outSize);
}
// procStartLines -- first whole-file line of each proc in the canonical
// layout of general + procs (see joinProcArrays), as an stb_ds array the
// caller frees
static int32_t *procStartLines(const char *general, char **procs) {
int32_t *starts = NULL;
int32_t genLines = sectionLineCount(general);
int32_t line = genLines > 0 ? genLines + IDE_SECTION_GAP + 1 : 1;
for (int32_t p = 0; p < (int32_t)arrlen(procs); p++) {
arrput(starts, line);
line += sectionLineCount(procs[p]) + IDE_SECTION_GAP;
}
return starts;
}
// projectFileText -- the current text of project file fileIdx: its loaded
// buffer, else the file on disk read by prjReadFileText (returned in
// *outOwned too, for the caller to free). Returns NULL when the file
// cannot be used; *outMissing then tells whether it simply does not
// exist yet (a new file) rather than being unreadable or too large.
static const char *projectFileText(int32_t fileIdx, char **outOwned, bool *outMissing) {
PrjFileT *file = &sProject.files[fileIdx];
*outOwned = NULL;
*outMissing = false;
if (file->buffer) {
return file->buffer;
}
*outOwned = prjReadFileText(&sProject, fileIdx, outMissing);
return *outOwned;
}
// promptAndSave -- ask user to save, discard, or cancel.
// Returns true if the caller should proceed (user saved or discarded).
// Returns false if the user cancelled or a save failed.
static bool promptAndSave(void) {
if (!hasUnsavedData()) {
return true;
}
int32_t result = dvxPromptSave(sAc, IDE_MAIN_TITLE);
if (result == DVX_SAVE_YES) {
return saveAllModified();
}
return result == DVX_SAVE_NO;
}
// rebuildProcTable -- one sProcTable entry per proc buffer (so table and
// buffer indices always agree) with its object/event split and its line
// range in the canonical layout. Procedure names are split on '_' into
// ObjectName and EventName (e.g. "Command1_Click") using the designer's
// known object names.
static void rebuildProcTable(void) {
arrsetlen(sProcTable, 0);
// Collect all known object names once; they only depend on sDesigner.form
const char **objNames = NULL; // stb_ds temp array
if (sDesigner.form) {
arrput(objNames, sDesigner.form->name);
for (int32_t ci = 0; ci < (int32_t)arrlen(sDesigner.form->controls); ci++) {
arrput(objNames, sDesigner.form->controls[ci]->name);
}
for (int32_t mi = 0; mi < (int32_t)arrlen(sDesigner.form->menuItems); mi++) {
arrput(objNames, sDesigner.form->menuItems[mi].name);
}
}
int32_t *starts = procStartLines(sGeneralBuf, sProcBufs);
for (int32_t p = 0; p < (int32_t)arrlen(sProcBufs); p++) {
const char *text = sProcBufs[p];
bool isSub = false;
int32_t endOffset = DVX_MAX(sectionLineCount(text) - 1, 0);
char procName[BAS_MAX_IDENT];
procNameOf(text, procName, sizeof(procName));
if (procDeclAt(dvxSkipWs(text), &isSub)) {
skipToEndProc(text, isSub, &endOffset);
}
IdeProcEntryT entry;
memset(&entry, 0, sizeof(entry));
entry.lineNum = starts[p];
entry.endLineNum = starts[p] + endOffset;
// Match proc name against known objects: form name, controls,
// menu items. Try each as a prefix followed by "_". This handles
// names with multiple underscores correctly (e.g., "cmdOK_Click"
// matches "cmdOK", not "This_Is_A_Dumb_Name" matching a control
// named "This").
bool isEvent = false;
for (int32_t oi = 0; oi < (int32_t)arrlen(objNames); oi++) {
int32_t objLen = (int32_t)strlen(objNames[oi]);
if (objLen > 0 && strncasecmp(procName, objNames[oi], objLen) == 0 && procName[objLen] == '_') {
snprintf(entry.objName, sizeof(entry.objName), "%s", objNames[oi]);
snprintf(entry.evtName, sizeof(entry.evtName), "%s", procName + objLen + 1);
isEvent = true;
break;
}
}
if (!isEvent) {
snprintf(entry.objName, sizeof(entry.objName), "%s", IDE_GENERAL_SECTION);
snprintf(entry.evtName, sizeof(entry.evtName), "%s", procName);
}
arrput(sProcTable, entry);
}
arrfree(starts);
arrfree(objNames);
}
static void recentAdd(const char *path) {
if (!path || !path[0]) {
return;
}
// If already in the list, move it to the top
for (int32_t i = 0; i < (int32_t)arrlen(sRecentFiles); i++) {
if (strcasecmp(sRecentFiles[i], path) == 0) {
char *existing = sRecentFiles[i];
arrdel(sRecentFiles, i);
arrins(sRecentFiles, 0, existing);
recentSave();
recentRebuildMenu();
return;
}
}
// If at cap, drop the oldest entry (last)
while ((int32_t)arrlen(sRecentFiles) >= CMD_RECENT_MAX) {
int32_t last = (int32_t)arrlen(sRecentFiles) - 1;
free(sRecentFiles[last]);
arrdel(sRecentFiles, last);
}
// Insert new entry at the top
char *copy = strdup(path);
if (!copy) {
return;
}
arrins(sRecentFiles, 0, copy);
recentSave();
recentRebuildMenu();
}
static void recentLoad(void) {
// Clear any prior entries
for (int32_t i = 0; i < (int32_t)arrlen(sRecentFiles); i++) {
free(sRecentFiles[i]);
}
arrsetlen(sRecentFiles, 0);
if (!sPrefs) {
return;
}
for (int32_t i = 0; i < CMD_RECENT_MAX; i++) {
char key[IDE_PREF_KEY_BUF];
snprintf(key, sizeof(key), PREF_KEY_RECENT_FMT, (long)i);
const char *val = prefsGetString(sPrefs, PREF_SEC_RECENT, key, "");
if (val[0]) {
char *copy = strdup(val);
if (copy) {
arrput(sRecentFiles, copy);
}
}
}
}
static void recentOpen(int32_t index) {
if (index < 0 || index >= (int32_t)arrlen(sRecentFiles)) {
return;
}
// recentAdd reorders the list, so work from a private copy of the path
char path[DVX_MAX_PATH];
snprintf(path, sizeof(path), "%s", sRecentFiles[index]);
openAnyPath(path);
}
static void recentRebuildMenu(void) {
if (!sFileMenu) {
return;
}
// Truncate menu back to the base items (everything through Exit)
sFileMenu->itemCount = sFileMenuBase;
int32_t count = (int32_t)arrlen(sRecentFiles);
if (count == 0) {
return;
}
// Append separator + recent file items after Exit
wmAddMenuSeparator(sFileMenu);
for (int32_t i = 0; i < count; i++) {
// Show just the filename for shorter labels
const char *name = platformPathBaseName(sRecentFiles[i]);
char label[MAX_MENU_LABEL];
snprintf(label, sizeof(label), "&%ld %s", (long)(i + 1), name);
wmAddMenuItem(sFileMenu, label, CMD_RECENT_BASE + i);
}
}
// recentRemove -- drop path from the Recent list (it no longer opens)
static void recentRemove(const char *path) {
for (int32_t i = 0; i < (int32_t)arrlen(sRecentFiles); i++) {
if (strcasecmp(sRecentFiles[i], path) == 0) {
free(sRecentFiles[i]);
arrdel(sRecentFiles, i);
recentSave();
recentRebuildMenu();
return;
}
}
}
static void recentSave(void) {
if (!sPrefs) {
return;
}
int32_t count = (int32_t)arrlen(sRecentFiles);
for (int32_t i = 0; i < CMD_RECENT_MAX; i++) {
char key[IDE_PREF_KEY_BUF];
snprintf(key, sizeof(key), PREF_KEY_RECENT_FMT, (long)i);
prefsSetString(sPrefs, PREF_SEC_RECENT, key, i < count ? sRecentFiles[i] : "");
}
prefsSave(sPrefs);
}
// remapBreakpoints -- move the editor file's breakpoints to their anchors'
// lines in the current layout (starts: procStartLines of the current
// buffers; anchors parallel sBreakpoints). A breakpoint whose line is
// gone is removed. sProcTable must describe the current buffers.
static void remapBreakpoints(const IdeLineAnchorT *anchors, const int32_t *starts) {
bool changed = false;
for (int32_t i = (int32_t)arrlen(sBreakpoints) - 1; i >= 0; i--) {
IdeBreakpointT *bp = &sBreakpoints[i];
if (bp->fileIdx != sEditorFileIdx) {
continue;
}
int32_t line = anchorLine(&anchors[i], starts);
if (line == IDE_NO_LINE) {
arrdel(sBreakpoints, i);
changed = true;
continue;
}
changed = changed || line != bp->codeLine;
bp->codeLine = line;
setBreakpointProcName(bp, procIndexForCodeLine(line));
}
changed = dedupeBreakpoints() || changed;
if (changed) {
syncVmBreakpoints();
}
updateBreakpointWindow();
}
static void removeBreakpointsForFile(int32_t fileIdx) {
// Remove breakpoints for the given file and adjust indices for
// files above the removed one (since file indices shift down).
for (int32_t i = (int32_t)arrlen(sBreakpoints) - 1; i >= 0; i--) {
if (sBreakpoints[i].fileIdx == fileIdx) {
arrdel(sBreakpoints, i);
} else if (sBreakpoints[i].fileIdx > fileIdx) {
sBreakpoints[i].fileIdx--;
}
}
syncVmBreakpoints();
updateBreakpointWindow();
}
// renameInBuffer -- word-boundary rename of OldName followed by '.' or
// '_'. The character before the match must be a non-identifier
// character to avoid replacing "Command1" inside "MyCommand1". Returns
// the new text (malloc'd), or NULL when nothing matched.
static char *renameInBuffer(const char *src, const char *oldName, const char *newName) {
if (!src || !oldName || !newName || !oldName[0]) {
return NULL;
}
int32_t oldLen = (int32_t)strlen(oldName);
int32_t newLen = (int32_t)strlen(newName);
int32_t srcLen = (int32_t)strlen(src);
bool skipComments = prefsGetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_RENAME_SKIP, true);
// First pass: count replacements to compute output size
int32_t count = 0;
for (int32_t i = 0; i <= srcLen - oldLen; i++) {
if (renameMatchAt(src, i, oldName, oldLen, skipComments)) {
count++;
}
}
if (count == 0) {
return NULL;
}
// Allocate output
int32_t outLen = srcLen + count * (newLen - oldLen);
char *out = (char *)malloc(outLen + 1);
if (!out) {
return NULL;
}
// Second pass: build output
int32_t op = 0;
for (int32_t i = 0; i < srcLen; ) {
if (i <= srcLen - oldLen && renameMatchAt(src, i, oldName, oldLen, skipComments)) {
memcpy(out + op, newName, newLen);
op += newLen;
i += oldLen;
continue;
}
out[op++] = src[i++];
}
out[op] = '\0';
return out;
}
// renameMatchAt -- whether oldName at src[i] is a reference to rename: a
// whole identifier start followed by '.' or '_', outside comments and
// strings when skipComments.
static bool renameMatchAt(const char *src, int32_t i, const char *oldName, int32_t oldLen, bool skipComments) {
if (strncasecmp(&src[i], oldName, oldLen) != 0) {
return false;
}
char after = src[i + oldLen];
if (after != '.' && after != '_') {
return false;
}
if (i > 0 && basIsIdentChar(src[i - 1])) {
return false;
}
return !skipComments || !isInStringOrComment(src, i);
}
// renameMenuItemsInCode -- after the Menu Editor, rename the handlers of
// menu items whose name changed. Items are matched by the identity the
// editor keeps (DsgnMenuItemT.id, the item's position + 1 on entry), so
// inserting, deleting and moving items never looks like a rename. All
// old names go to unique placeholders first, so swapped names cannot
// collapse two handlers into one.
static void renameMenuItemsInCode(char **oldNames, int32_t oldCount) {
char **fromNames = NULL; // stb_ds: borrowed old names
char **toNames = NULL; // stb_ds: borrowed new names
int32_t newCount = (int32_t)arrlen(sDesigner.form->menuItems);
for (int32_t mi = 0; mi < newCount; mi++) {
DsgnMenuItemT *item = &sDesigner.form->menuItems[mi];
int32_t was = item->id - 1;
if (item->id == DSGN_NEW_MENU_ID || was < 0 || was >= oldCount || !oldNames[was] || !oldNames[was][0] || !item->name[0]) {
continue;
}
if (strcasecmp(oldNames[was], item->name) != 0) {
arrput(fromNames, oldNames[was]);
arrput(toNames, item->name);
}
}
int32_t renames = (int32_t)arrlen(fromNames);
bool viaTemporary = renames > 1; // a single rename cannot collide
if (viaTemporary) {
for (int32_t r = 0; r < renames; r++) {
char temp[BAS_MAX_IDENT];
snprintf(temp, sizeof(temp), IDE_RENAME_TEMP_FMT, (int)r);
ideRenameInCode(fromNames[r], temp);
}
}
for (int32_t r = 0; r < renames; r++) {
char temp[BAS_MAX_IDENT];
snprintf(temp, sizeof(temp), IDE_RENAME_TEMP_FMT, (int)r);
ideRenameInCode(viaTemporary ? temp : fromNames[r], toNames[r]);
}
arrfree(fromNames);
arrfree(toNames);
}
// renameProjectFile -- File > Rename File: ask for a new name for
// project file fileIdx, then renameProjectFileTo
static void renameProjectFile(int32_t fileIdx) {
char prompt[IDE_MSG_BUF];
char newName[DVX_MAX_PATH];
snprintf(prompt, sizeof(prompt), "New name for %s:", sProject.files[fileIdx].path);
if (dvxInputBox(sAc, IDE_RENAME_TITLE, prompt, sProject.files[fileIdx].path, newName, sizeof(newName)) && newName[0] != '\0') {
renameProjectFileTo(fileIdx, newName);
}
}
// renameProjectFileTo -- rename project file fileIdx to newName on disk
// and in the project (prjRenameFile, which puts everything back on
// failure; errors are shown). A class module named after its file
// (classFollowsFile) takes the new name as its class name; that name must
// then be free. A form keeps its Name.
static bool renameProjectFileTo(int32_t fileIdx, const char *newName) {
char err[IDE_MSG_BUF];
// The editor or designer may hold newer text than the project buffer
if ((fileIdx == sEditorFileIdx || fileIdx == sDesignerFileIdx) && !stashCurrentFile()) {
return false;
}
PrjFileT *file = &sProject.files[fileIdx];
bool nameClass = false;
char oldClass[BAS_MAX_IDENT];
char newClass[BAS_MAX_IDENT];
if (file->kind == PrjKindClassE) {
bool missing = false;
char *owned = NULL;
const char *text = projectFileText(fileIdx, &owned, &missing);
nameClass = text && classFollowsFile(fileIdx, text) && prjClassName(&sProject, fileIdx, text, oldClass, (int32_t)sizeof(oldClass));
free(owned);
basExtractClassName("", 0, newName, newClass, (int32_t)sizeof(newClass));
}
if (nameClass && !basIsValidIdent(newClass)) {
snprintf(err, sizeof(err), "%s is not a valid class name: the class module is named after its file.", newClass);
ideErrorBox(err);
return false;
}
if (nameClass && strcasecmp(newClass, oldClass) != 0 && classNameUsed(newClass, "")) {
snprintf(err, sizeof(err), "The project already has a form or class module named %s.", newClass);
ideErrorBox(err);
return false;
}
if (!prjRenameFile(&sProject, fileIdx, newName, err, (int32_t)sizeof(err))) {
ideErrorBox(err);
return false;
}
if (nameClass && !setClassNameAttr(fileIdx, newClass)) {
ideErrorBox("The file was renamed, but its class name could not be changed.");
}
invalidateCompiled();
updateProjectMenuState();
updateDirtyIndicators();
setStatus("File renamed.");
return true;
}
// replaceInSections -- Replace All over the editor file's sections: every
// proc (and General) holding the search text, or only the procs of object
// objFilter. The targets are collected by name first and looked up again
// before each visit, since showing a proc can drop an empty skeleton and
// shift the indices. Returns the number of replacements.
static int32_t replaceInSections(const char *objFilter, bool caseSensitive) {
int32_t needleLen = (int32_t)strlen(sFindText);
IdeProcEntryT *targets = NULL; // stb_ds: procs to visit, by name
int32_t count = 0;
if (!sEditor) {
return 0;
}
getFullSource();
bool inGeneral = sectionInScope(-1, objFilter) && procBufContains(sGeneralBuf, sFindText, needleLen, caseSensitive);
for (int32_t p = 0; p < (int32_t)arrlen(sProcBufs) && p < (int32_t)arrlen(sProcTable); p++) {
if (sectionInScope(p, objFilter) && procBufContains(sProcBufs[p], sFindText, needleLen, caseSensitive)) {
arrput(targets, sProcTable[p]);
}
}
if (inGeneral) {
showProc(IDE_SECTION_GENERAL);
count += wgtTextAreaReplaceAll(sEditor, sFindText, sReplaceText, caseSensitive);
}
for (int32_t t = 0; t < (int32_t)arrlen(targets); t++) {
int32_t idx = procIndexByName(targets[t].objName, targets[t].evtName);
if (idx < 0) {
continue;
}
showProc(idx);
count += wgtTextAreaReplaceAll(sEditor, sFindText, sReplaceText, caseSensitive);
}
arrfree(targets);
return count;
}
// reportUnreadable -- a project file exists but cannot be loaded
static void reportUnreadable(const char *path) {
char msg[IDE_MSG_BUF];
snprintf(msg, sizeof(msg), "Cannot load %s: unreadable or larger than %d bytes.", path, (int)(IDE_MAX_SOURCE - 1));
ideErrorBox(msg);
}
// resolveVarPath -- parse a variable reference and resolve it to a
// pointer into the running VM's live data. Handles:
// varName -- scalar variable
// varName(i) -- array element
// varName.field -- UDT field
// varName(i).field -- array element UDT field
// Returns NULL if it can't be resolved. *endPtr is set past the path.
static BasValueT *resolveVarPath(const char *path, const char **endPtr) {
const char *p = path;
// Extract variable name (identifier plus optional type suffix)
const char *nameStart = p;
while (basIsIdentChar(*p)) {
p++;
}
if (p == nameStart) {
return NULL;
}
if (basIsTypeSuffixChar(*p)) {
p++;
}
char varName[IDE_FULL_NAME_BUF];
int32_t nameLen = (int32_t)(p - nameStart);
if (nameLen >= (int32_t)sizeof(varName)) {
return NULL;
}
memcpy(varName, nameStart, nameLen);
varName[nameLen] = '\0';
// Look up the base variable
const BasDebugVarT *dv = findDebugVar(varName);
if (!dv) {
return NULL;
}
BasValueT *slot = getDebugVarSlot(dv);
if (!slot) {
return NULL;
}
// Parse optional array subscript: (idx1, idx2, ...)
if (*p == '(') {
if (slot->type != BAS_TYPE_ARRAY || !slot->arrVal) {
return NULL;
}
int32_t indices[BAS_ARRAY_MAX_DIMS];
int32_t numIndices = 0;
p = parseIndexList(p + 1, indices, &numIndices);
int32_t flatIdx = basArrayIndex(slot->arrVal, indices, numIndices);
if (flatIdx < 0 || flatIdx >= slot->arrVal->totalElements) {
return NULL;
}
slot = basValDeref(&slot->arrVal->elements[flatIdx]);
}
// Parse optional UDT field or class member variable: .fieldName
if (*p == '.') {
p++; // skip '.'
bool isInstance = slot->type == BAS_TYPE_INSTANCE;
if (!isInstance && (slot->type != BAS_TYPE_UDT || !slot->udtVal)) {
return NULL;
}
const char *fieldStart = p;
while (basIsIdentChar(*p)) {
p++;
}
char fieldName[IDE_FULL_NAME_BUF];
int32_t fieldLen = (int32_t)(p - fieldStart);
if (fieldLen <= 0 || fieldLen >= (int32_t)sizeof(fieldName)) {
return NULL;
}
memcpy(fieldName, fieldStart, fieldLen);
fieldName[fieldLen] = '\0';
if (isInstance) {
int32_t memberIdx = findMemberVarIdx(slot->instVal, fieldName);
if (memberIdx < 0) {
return NULL;
}
slot = &slot->instVal->fields[memberIdx];
} else {
int32_t fieldIdx = findUdtFieldIdx(slot->udtVal->typeId, fieldName);
if (fieldIdx < 0 || fieldIdx >= slot->udtVal->fieldCount) {
return NULL;
}
slot = &slot->udtVal->fields[fieldIdx];
}
}
if (endPtr) {
*endPtr = p;
}
return slot;
}
static void runCached(void) {
if (!sCachedModule) {
setStatus("No compiled program. Press F5 to compile first.");
return;
}
// The forms are registered from the project buffers
if (!stashCurrentFile()) {
return;
}
clearOutput();
runModule(sCachedModule);
}
static void runModule(BasModuleT *mod) {
// Never nest a run: a stopped program may still be unwinding
if (sVm) {
return;
}
// Create VM
BasVmT *vm = basVmCreate();
if (!vm) {
setStatus("Out of memory creating VM.");
return;
}
// Create form runtime (bridges UI opcodes to DVX widgets)
BasFormRtT *formRt = basFormRtCreate(sAc, vm, mod);
if (!formRt) {
basVmDestroy(vm);
setStatus("Out of memory creating form runtime.");
return;
}
setStatus("Running...");
closeFindDialog();
// Hide the designer, code and project windows while the program runs;
// they are restored (where they were visible) when it ends.
bool hadFormWin = sFormWin && sFormWin->visible;
bool hadToolbox = sToolboxWin && sToolboxWin->visible;
bool hadProps = sPropsWin && sPropsWin->visible;
bool hadCodeWin = sCodeWin && sCodeWin->visible;
bool hadPrjWin = sProjectWin && sProjectWin->visible;
if (sFormWin) {
dvxHideWindow(sAc, sFormWin);
}
if (sToolboxWin) {
dvxHideWindow(sAc, sToolboxWin);
}
if (sPropsWin) {
dvxHideWindow(sAc, sPropsWin);
}
if (sCodeWin) {
dvxHideWindow(sAc, sCodeWin);
}
if (sProjectWin) {
dvxHideWindow(sAc, sProjectWin);
}
basVmLoadModule(vm, mod);
// Set App.Path/Config/Data. In the IDE, config and data live under
// the project directory so everything stays together during development.
// Standalone apps use the DVX root-level CONFIG/ and DATA/ directories
// since the app directory (on CD-ROM) is read-only.
snprintf(vm->appPath, sizeof(vm->appPath), "%s", sProject.projectDir);
snprintf(vm->appConfig, sizeof(vm->appConfig), "%s" DVX_PATH_SEP "CONFIG", sProject.projectDir);
snprintf(vm->appData, sizeof(vm->appData), "%s" DVX_PATH_SEP "DATA", sProject.projectDir);
basVmSetCommand(vm, sProject.commandArgs);
platformMkdirRecursive(vm->appConfig);
platformMkdirRecursive(vm->appData);
// Set I/O callbacks
basVmSetPrintCallback(vm, printCallback, NULL);
basVmSetInputCallback(vm, inputCallback, NULL);
basVmSetDoEventsCallback(vm, doEventsCallback, NULL);
vm->breakpointFn = onBreakpointHit;
vm->breakpointCtx = NULL;
// Set SQL callbacks
BasSqlCallbacksT sqlCb;
memset(&sqlCb, 0, sizeof(sqlCb));
sqlCb.sqlOpen = dvxSqlOpen;
sqlCb.sqlClose = dvxSqlClose;
sqlCb.sqlExec = dvxSqlExec;
sqlCb.sqlError = dvxSqlError;
sqlCb.sqlQuery = dvxSqlQuery;
sqlCb.sqlNext = dvxSqlNext;
sqlCb.sqlEof = dvxSqlEof;
sqlCb.sqlFieldCount = dvxSqlFieldCount;
sqlCb.sqlFieldName = dvxSqlFieldName;
sqlCb.sqlFieldText = dvxSqlFieldText;
sqlCb.sqlFieldByName = dvxSqlFieldByName;
sqlCb.sqlFieldInt = dvxSqlFieldInt;
sqlCb.sqlFieldDbl = dvxSqlFieldDbl;
sqlCb.sqlFreeResult = dvxSqlFreeResult;
sqlCb.sqlAffectedRows = dvxSqlAffectedRows;
basVmSetSqlCallbacks(vm, &sqlCb);
// Set extern library callbacks (DECLARE LIBRARY support)
BasExternCallbacksT extCb;
extCb.resolveExtern = basExternResolve;
extCb.callExtern = basExternCall;
extCb.ctx = NULL;
basVmSetExternCallbacks(vm, &extCb);
// The IDE surfaces runtime errors via the Output pane and jumps
// the editor to the faulting line, so suppress the form runtime's
// modal error dialog. Keeping the dialog on top of an already-
// modal-heavy IDE session was producing phantom "press OK twice"
// UX as the dialog's nested event pump raced with other queued
// events coming out of the user's program.
formRt->suppressErrorDialog = true;
// The program's screen window (console / graphics) carries its name
snprintf(formRt->title, sizeof(formRt->title), "%s", sProject.name);
sVm = vm;
sDbgFormRt = formRt;
sDbgModule = mod;
sDbgState = DbgRunningE;
sStopRequested = false;
// Set project help file on form runtime for F1 context help
if (sProject.helpFile[0]) {
snprintf(formRt->helpFile, sizeof(formRt->helpFile), "%s" DVX_PATH_SEP "%s", sProject.projectDir, sProject.helpFile);
}
updateProjectMenuState();
// Set breakpoints BEFORE loading forms so breakpoints in form
// init code (module-level statements inside BEGINFORM) fire.
if (sDbgEnabled) {
syncVmBreakpoints();
if (sDbgBreakOnStart) {
basVmStepInto(vm);
}
}
// Load forms from project files (AFTER breakpoints are set so
// init code breakpoints fire), then show the startup form.
loadFrmFiles(formRt);
basFormRtLoadAllForms(formRt, sProject.startupForm);
// Run in slices of 10000 steps, yielding to DVX between slices
basVmSetStepLimit(vm, BAS_VM_DEFAULT_STEP_SLICE);
BasVmResultE result = runProgramSlices(vm);
// VB-style event loop: after module-level code finishes,
// keep processing events as long as any form is loaded.
// The program ends when all forms are unloaded (closed).
// Breakpoints inside event handlers pause inside the VM's own
// spin (basVmCallSub -> doEventsCallback), so nothing here needs
// to watch for DbgPausedE.
if (result == BAS_VM_HALTED && basFormRtKeepsRunning(formRt)) {
setStatus("Running (event loop)...");
// vm->errorMsg outliving an event dispatch means an unhandled
// runtime error escaped a handler (ON ERROR clears the message
// when it takes over); without this test the program kept
// running after the error and the report below never fired
// until the user pressed Stop.
while (sWin && sAc->running && basFormRtKeepsRunning(formRt) && !sStopRequested && !vm->ended && vm->errorMsg[0] == '\0') {
idePump();
}
}
// A normal end releases the module variables: their objects'
// Class_Terminates run (VB)
if (result == BAS_VM_HALTED && sWin && sAc->running && !sStopRequested && !formRt->terminated && basVmFinish(vm)) {
runProgramSlices(vm);
}
// A runtime error fired from a host callback (e.g. setting a
// property on an unknown control) halts execution by writing
// vm->errorMsg and setting vm->ended. basVmRun surfaces that as
// BAS_VM_ERROR for module-level code, but errors raised inside an
// event handler just break the loop above. Either way, report
// the message and navigate the editor to the offending line so
// the user can fix it. debugNavigateToLine depends on sVm and
// sDbgModule, so it has to run BEFORE the cleanup block below.
// Use vm->errorLine (snapshot at error time) rather than
// vm->currentLine: the dialog/event pump can fire another handler
// whose OP_LINE overwrites currentLine before we read it here.
bool hadRuntimeError = (vm->errorMsg[0] != '\0') && sWin;
int32_t errorLine = hadRuntimeError ? vm->errorLine : 0;
if (hadRuntimeError) {
// Map the concatenated line to a file / proc-local line the
// same way compile errors do, so the Output message matches
// what the editor is actually showing.
int32_t errFileIdx = -1;
int32_t errLocalLine = errorLine;
const char *errFile = "";
if (errorLine > 0) {
prjMapLine(&sProject, errorLine, &errFileIdx, &errLocalLine);
if (errFileIdx >= 0 && errFileIdx < prjFileCount(&sProject)) {
errFile = sProject.files[errFileIdx].path;
}
}
// Navigate to the failing line; the proc whose line range holds it
// (none for module-level code between procs) names the location.
char procName[IDE_FULL_NAME_BUF] = {0};
int32_t procLine = errLocalLine;
if (errFileIdx >= 0) {
int32_t procIdx = navigateToCodeLine(errFileIdx, errLocalLine, false);
if (procIdx >= 0 && procIdx < (int32_t)arrlen(sProcTable)) {
snprintf(procName, sizeof(procName), "%s.%s", sProcTable[procIdx].objName, sProcTable[procIdx].evtName);
procLine = wgtTextAreaGetCursorLine(sEditor);
}
}
char report[IDE_REPORT_BUF];
if (procName[0]) {
snprintf(report, sizeof(report), "\nRUNTIME ERROR:\n%s line %d: %s\n", procName, (int)procLine, vm->errorMsg);
} else if (errFile[0]) {
snprintf(report, sizeof(report), "\nRUNTIME ERROR:\n%s line %d: %s\n", errFile, (int)errLocalLine, vm->errorMsg);
} else {
snprintf(report, sizeof(report), "\nRUNTIME ERROR:\nline %d: %s\n", (int)errLocalLine, vm->errorMsg);
}
outputAppend(report, (int32_t)strlen(report));
outputLog(report);
}
if (sLogLineLen > 0) {
logFlushLine();
}
arrsetlen(sBreakTitles, 0);
sVm = NULL;
sDbgFormRt = NULL;
sDbgModule = NULL;
sDbgState = DbgIdleE;
sDbgCurrentLine = -1;
sDbgEnabled = false;
basFormRtDestroy(formRt);
basVmDestroy(vm);
// If the IDE was closed while the program was running, skip all UI
// updates -- the windows are already destroyed -- and release the
// module onClose left for us.
if (!sWin) {
if (sCachedModule) {
basModuleFree(sCachedModule);
sCachedModule = NULL;
}
return;
}
updateProjectMenuState();
sOutputPending = true;
flushOutput();
setStatus(hadRuntimeError ? "Runtime error." : "Done.");
// Restore IDE windows. On a runtime error we want the code
// window on top so the user lands on the offending line; don't
// pop the form designer / toolbox / project back up, since that
// would cover the editor (dvxShowWindow raises). Output window
// stays up too so the error text is visible.
if (hadRuntimeError) {
if (sCodeWin && !sCodeWin->visible) {
dvxShowWindow(sAc, sCodeWin);
}
if (sCodeWin) {
dvxRaiseWindow(sAc, sCodeWin);
}
} else {
if (hadFormWin && sFormWin) {
dvxShowWindow(sAc, sFormWin);
}
if (hadToolbox && sToolboxWin) {
dvxShowWindow(sAc, sToolboxWin);
}
if (hadProps && sPropsWin) {
dvxShowWindow(sAc, sPropsWin);
}
if (hadCodeWin && sCodeWin) {
dvxShowWindow(sAc, sCodeWin);
}
if (hadPrjWin && sProjectWin) {
dvxShowWindow(sAc, sProjectWin);
}
}
// Repaint to clear destroyed runtime forms and restore designer
dvxUpdate(sAc);
}
// runProgramSlices -- run the program in step slices, yielding to DVX
// between them, pausing at breakpoints, until it halts, fails (its message
// left in vm->errorMsg) or is stopped. Returns the last result.
static BasVmResultE runProgramSlices(BasVmT *vm) {
BasVmResultE result = BAS_VM_HALTED;
for (;;) {
if (!sWin || !sAc->running || sStopRequested) {
break;
}
if (sDbgState == DbgPausedE) {
// Paused at breakpoint/step -- spin on GUI events until user acts
idePump();
// User may have pressed F5 (continue), F8 (step), or Esc (stop)
if (sDbgState == DbgRunningE) {
vm->running = true;
}
continue;
}
result = basVmRun(vm);
// Module-level pause: the same state as a pause inside a handler
if (result == BAS_VM_BREAKPOINT) {
onBreakpointHit(NULL, vm->currentLine > 0 ? vm->currentLine : 0);
continue;
}
if (result == BAS_VM_STEP_LIMIT) {
idePump();
continue;
}
if (result == BAS_VM_HALTED) {
break;
}
// Module-level runtime error. For VM-internal errors (e.g.
// division by zero) there's no vm->errorLine set, so fall
// back to vm->currentLine -- but copy it into errorLine so
// the shared post-loop handler below can format and navigate
// uniformly with the event-handler error path.
if (vm->errorMsg[0] == '\0') {
const char *msg = basVmGetError(vm);
snprintf(vm->errorMsg, sizeof(vm->errorMsg), "%s", msg ? msg : "Runtime error");
}
if (vm->errorLine == 0 && vm->currentLine > 0) {
vm->errorLine = vm->currentLine;
}
break;
}
return result;
}
// runSnippetVm -- run an Immediate/Watch snippet in bounded slices so an
// endless loop typed into the Immediate window cannot hang the IDE.
// BAS_VM_STEP_LIMIT means it was abandoned.
static BasVmResultE runSnippetVm(BasVmT *vm) {
BasVmResultE result = BAS_VM_STEP_LIMIT;
basVmSetStepLimit(vm, IDE_SNIPPET_SLICE);
for (int32_t slice = 0; slice < IDE_SNIPPET_MAX_SLICES && result == BAS_VM_STEP_LIMIT; slice++) {
result = basVmRun(vm);
}
return result;
}
// saveActiveFile -- write the active file (editor/designer state first
// stashed into its buffer). Returns false when nothing was written.
static bool saveActiveFile(void) {
if (!hasProject()) {
return false;
}
int32_t idx = sProject.activeFileIdx;
if (idx < 0 || idx >= prjFileCount(&sProject)) {
return false;
}
// Ensure buffer is up-to-date with editor/designer state
stashCurrentFile();
if (!writeProjectFile(idx)) {
return false;
}
setStatus("Saved.");
updateDirtyIndicators();
return true;
}
// saveAllModified -- write every modified file plus the .dbp when dirty.
// Returns false if any write failed (the user has already been told).
static bool saveAllModified(void) {
if (!hasProject()) {
return true;
}
stashCurrentFile();
syncFormDirty();
bool ok = true;
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (sProject.files[i].modified && !writeProjectFile(i)) {
ok = false;
}
}
if (sProject.dirty && !saveProjectFile()) {
ok = false;
}
updateDirtyIndicators();
return ok;
}
// saveCurProc -- store the editor text back into the buffer it shows.
// Nothing typed is ever dropped: lines outside the shown procedure move
// to (General), extra Sub/Function blocks become procedures of their
// own (a duplicate name too, so the compiler reports it), and a
// procedure whose declaration was deleted becomes (General) text. With
// discardSkeleton, an untouched generated event skeleton is removed
// instead -- only when the editor is leaving it. Breakpoints and the
// caret follow their lines to wherever they were stored. When memory
// runs out nothing changes and the text stays in the editor.
// Returns true if a buffer was removed (later sProcBufs indices shifted).
static bool saveCurProc(bool discardSkeleton) {
if (!sEditor || sEditorTruncated) {
return false;
}
const char *edText = wgtGetText(sEditor);
int32_t cur = sCurProcIdx;
if (!edText || cur < IDE_SECTION_GENERAL || cur >= (int32_t)arrlen(sProcBufs)) {
return false;
}
const char *stored = cur == IDE_SECTION_GENERAL ? sGeneralBuf : sProcBufs[cur];
if (!stored) {
stored = "";
}
// Stored text is already in canonical form: unchanged text needs
// nothing unless an untouched skeleton is being left.
bool leavingSkeleton = discardSkeleton && cur >= 0 && sSkeletonName[0];
if (!leavingSkeleton && strcmp(edText, stored) == 0) {
return false;
}
char *general = NULL;
char **procs = NULL;
IdeLineDestT *map = NULL;
if (!splitProcs(edText, &general, &procs, &map)) {
setStatus("Not enough memory to store the edit; it is kept in the editor.");
return false;
}
int32_t procCount = (int32_t)arrlen(procs);
char *newGeneral = NULL;
if (cur == IDE_SECTION_GENERAL && procCount == 0) {
// (General) with no procedure in it is kept exactly as typed
newGeneral = strdup(edText);
} else if (cur == IDE_SECTION_GENERAL) {
newGeneral = general;
general = NULL;
} else if (general[0]) {
newGeneral = generalAppend(sGeneralBuf, general);
}
if (!newGeneral && (cur == IDE_SECTION_GENERAL || general[0])) {
free(general);
for (int32_t i = 0; i < procCount; i++) {
free(procs[i]);
}
arrfree(procs);
arrfree(map);
setStatus("Not enough memory to store the edit; it is kept in the editor.");
return false;
}
// Pin the editor file's breakpoints and the caret to their sections in
// the layout as edited (see anchorCodeLine), before the buffers move.
int32_t edLines = countLines(edText);
int32_t delta = edLines - countLines(stored);
int32_t genBase = cur == IDE_SECTION_GENERAL ? 0 : sectionLineCount(sGeneralBuf);
int32_t *starts = procStartLines(sGeneralBuf, sProcBufs);
IdeLineAnchorT *anchors = NULL;
IdeLineAnchorT caret;
for (int32_t i = 0; i < (int32_t)arrlen(sBreakpoints); i++) {
IdeLineAnchorT a;
anchorCodeLine(&a, sBreakpoints[i].codeLine, cur, edLines, delta, starts);
arrput(anchors, a);
}
caret.edLine = wgtTextAreaGetCursorLine(sEditor) - 1;
// Store: the shown proc keeps its slot (the block with its name, or the
// first block when it was renamed); every other block is appended.
int32_t ownIdx = IDE_NO_LINE;
bool removed = false;
if (cur >= 0 && procCount == 0) {
// No declaration left: the text is module-level code
free(sProcBufs[cur]);
arrdel(sProcBufs, cur);
sCurProcIdx = IDE_SECTION_GENERAL;
removed = true;
} else if (cur >= 0) {
char ownName[IDE_FULL_NAME_BUF];
char name[IDE_FULL_NAME_BUF];
procNameOf(sProcBufs[cur], ownName, sizeof(ownName));
ownIdx = 0;
for (int32_t i = 0; i < procCount; i++) {
procNameOf(procs[i], name, sizeof(name));
if (strcasecmp(name, ownName) == 0) {
ownIdx = i;
break;
}
}
procNameOf(procs[ownIdx], name, sizeof(name));
bool isSkeleton = sSkeletonName[0] && strcasecmp(name, sSkeletonName) == 0;
bool bodyEmpty = procBodyEmpty(procs[ownIdx]);
free(sProcBufs[cur]);
if (discardSkeleton && isSkeleton && bodyEmpty && procCount == 1 && !general[0]) {
free(procs[ownIdx]);
procs[ownIdx] = NULL;
arrdel(sProcBufs, cur);
sCurProcIdx = IDE_SECTION_NONE;
sSkeletonName[0] = '\0';
removed = true;
} else {
sProcBufs[cur] = procs[ownIdx];
// Code typed into a generated skeleton makes it the user's
if (isSkeleton && !bodyEmpty) {
sSkeletonName[0] = '\0';
}
}
}
for (int32_t i = 0; i < procCount; i++) {
if (i != ownIdx) {
arrput(sProcBufs, procs[i]);
}
}
if (newGeneral) {
free(sGeneralBuf);
sGeneralBuf = newGeneral;
}
// Resolve the anchors in the new layout
for (int32_t i = 0; i < (int32_t)arrlen(anchors); i++) {
if (anchors[i].edLine != IDE_NO_LINE) {
anchorEditedLine(&anchors[i], map, procs, genBase);
}
}
anchorEditedLine(&caret, map, procs, genBase);
arrfree(starts);
starts = procStartLines(sGeneralBuf, sProcBufs);
rebuildProcTable();
remapBreakpoints(anchors, starts);
arrfree(starts);
arrfree(anchors);
arrfree(map);
arrfree(procs);
free(general);
// The editor shows exactly what was stored for the shown section, the
// caret on the line it was on
if (sCurProcIdx >= IDE_SECTION_GENERAL) {
const char *shownBuf = sCurProcIdx == IDE_SECTION_GENERAL ? NULL : sProcBufs[sCurProcIdx];
const char *shown = sCurProcIdx == IDE_SECTION_GENERAL ? sGeneralBuf : shownBuf;
if (strcmp(edText, shown ? shown : "") != 0) {
int32_t line = (caret.offset != IDE_NO_LINE && caret.section == shownBuf) ? caret.offset + 1 : IDE_CARET_KEEP;
editorSetText(shown ? shown : "", line);
}
}
return removed;
}
// saveFile -- Ctrl+S: the active file plus any other modified forms
static void saveFile(void) {
if (!hasProject() || sProject.activeFileIdx < 0) {
return;
}
if (!saveActiveFile()) {
return;
}
syncFormDirty();
for (int32_t i = 0; i < prjFileCount(&sProject); i++) {
if (i != sProject.activeFileIdx && sProject.files[i].kind == PrjKindFormE && sProject.files[i].modified) {
writeProjectFile(i);
}
}
updateDirtyIndicators();
}
// saveProjectFile -- write the .dbp; dirty is only cleared on success
static bool saveProjectFile(void) {
if (!prjSave(&sProject)) {
dvxErrorBox(sAc, NULL, "Could not write the project file.");
return false;
}
sProject.dirty = false;
return true;
}
// scanClassEvents -- append the [Public] Event Name[(params)] statements
// of a class module's text to *events (the compiler's words, read with
// its lexer so strings and comments never match)
static void scanClassEvents(const char *text, IdeClassEventT **events) {
BasLexerT lex;
bool stmtStart = true;
basLexerInit(&lex, text, (int32_t)strlen(text));
while (lex.token.type != TOK_EOF && lex.token.type != TOK_ERROR) {
if (stmtStart && lex.token.type == TOK_PUBLIC) {
basLexerNext(&lex);
}
BasTokenTypeE tt = lex.token.type;
bool isEvent = stmtStart && tt == TOK_IDENT && strcasecmp(lex.token.text, BAS_KW_EVENT) == 0;
if (isEvent && basLexerNext(&lex) == TOK_IDENT) {
IdeClassEventT evt;
memset(&evt, 0, sizeof(evt));
snprintf(evt.name, sizeof(evt.name), "%s", lex.token.text);
if (basLexerNext(&lex) == TOK_LPAREN) {
int32_t start = lex.token.pos + 1;
int32_t depth = 1;
while (depth > 0 && basLexerNext(&lex) != TOK_EOF && lex.token.type != TOK_NEWLINE && lex.token.type != TOK_ERROR) {
depth += (lex.token.type == TOK_LPAREN) - (lex.token.type == TOK_RPAREN);
}
int32_t len = lex.token.pos - start;
snprintf(evt.params, sizeof(evt.params), "%.*s", (int)DVX_MIN(len, (int32_t)sizeof(evt.params) - 1), text + start);
}
arrput(*events, evt);
tt = lex.token.type;
}
stmtStart = tt == TOK_NEWLINE || tt == TOK_COLON;
basLexerNext(&lex);
}
}
// scanWithEvents -- collect the WithEvents variables src declares (Dim /
// Private / Public WithEvents name As Class, several declarators allowed)
// into sWithEvents, read with the compiler's lexer
static void scanWithEvents(const char *src) {
BasLexerT lex;
bool stmtStart = true;
arrsetlen(sWithEvents, 0);
basLexerInit(&lex, src, (int32_t)strlen(src));
while (lex.token.type != TOK_EOF && lex.token.type != TOK_ERROR) {
BasTokenTypeE tt = lex.token.type;
if (!stmtStart || (tt != TOK_DIM && tt != TOK_PRIVATE && tt != TOK_PUBLIC)) {
stmtStart = tt == TOK_NEWLINE || tt == TOK_COLON;
basLexerNext(&lex);
continue;
}
// One declarator per pass: [WithEvents] name [As type]
do {
bool withEvents = basLexerNext(&lex) == TOK_IDENT && strcasecmp(lex.token.text, BAS_KW_WITHEVENTS) == 0;
if (withEvents && basLexerNext(&lex) == TOK_IDENT) {
IdeWithEventsT we;
snprintf(we.name, sizeof(we.name), "%s", lex.token.text);
if (basLexerNext(&lex) == TOK_AS && basLexerNext(&lex) == TOK_IDENT) {
snprintf(we.className, sizeof(we.className), "%s", lex.token.text);
arrput(sWithEvents, we);
}
}
// On to the next declarator (commas inside bounds do not count)
int32_t depth = 0;
while (lex.token.type != TOK_EOF && lex.token.type != TOK_ERROR && lex.token.type != TOK_NEWLINE && lex.token.type != TOK_COLON && (depth > 0 || lex.token.type != TOK_COMMA)) {
depth += (lex.token.type == TOK_LPAREN) - (lex.token.type == TOK_RPAREN);
basLexerNext(&lex);
}
} while (lex.token.type == TOK_COMMA);
stmtStart = false;
}
}
// sectionInScope -- whether section p (-1 = General) of the editor file
// belongs to object objFilter (NULL = every section)
static bool sectionInScope(int32_t p, const char *objFilter) {
if (!objFilter) {
return true;
}
if (p < 0) {
return strcasecmp(objFilter, IDE_GENERAL_SECTION) == 0;
}
return p < (int32_t)arrlen(sProcTable) && strcasecmp(sProcTable[p].objName, objFilter) == 0;
}
// sectionLineCount -- lines a section's text takes in the canonical
// layout (joinProcArrays ends every non-empty section with a newline)
static int32_t sectionLineCount(const char *text) {
if (!text || !text[0]) {
return 0;
}
int32_t n = 0;
const char *p = text;
for (; *p; p++) {
if (*p == '\n') {
n++;
}
}
return p[-1] == '\n' ? n : n + 1;
}
// selectDropdowns -- set the Object and Event dropdown selections to
// match a given control/event without triggering navigation callbacks.
// The caller is responsible for having already navigated to the proc.
static void selectDropdowns(const char *objName, const char *evtName) {
if (!sObjDropdown || !sEvtDropdown) {
return;
}
// Select the object
int32_t objCount = (int32_t)arrlen(sObjItems);
for (int32_t i = 0; i < objCount; i++) {
if (strcasecmp(sObjItems[i], objName) == 0) {
wgtDropdownSetSelected(sObjDropdown, i);
break;
}
}
// Rebuild the event list for this object but suppress navigation
bool savedSuppress = sDropdownNavSuppressed;
sDropdownNavSuppressed = true;
onObjDropdownChange(sObjDropdown);
sDropdownNavSuppressed = savedSuppress;
// Now select the specific event
int32_t evtCount = (int32_t)arrlen(sEvtItems);
for (int32_t i = 0; i < evtCount; i++) {
if (evtLabelMatches(sEvtItems[i], evtName)) {
wgtDropdownSetSelected(sEvtDropdown, i);
break;
}
}
}
// setBreakpointProcName -- label a breakpoint with the proc it is in
// (procIdx into sProcTable, out of range = (General))
static void setBreakpointProcName(IdeBreakpointT *bp, int32_t procIdx) {
if (procIdx >= 0 && procIdx < (int32_t)arrlen(sProcTable)) {
snprintf(bp->procName, sizeof(bp->procName), "%s.%s", sProcTable[procIdx].objName, sProcTable[procIdx].evtName);
} else {
snprintf(bp->procName, sizeof(bp->procName), "%s", IDE_GENERAL_SECTION);
}
}
// setClassNameAttr -- give class module fileIdx the class name name in
// its Attribute VB_Name (when it has one; else the name already comes
// from the file name). The text becomes an unsaved edit, and the editor
// shows it when the file is open there. False when out of memory or the
// file cannot be read.
static bool setClassNameAttr(int32_t fileIdx, const char *name) {
PrjFileT *file = &sProject.files[fileIdx];
if (!file->buffer) {
file->buffer = prjReadFileText(&sProject, fileIdx, NULL);
}
if (!file->buffer) {
return false;
}
int32_t len = (int32_t)strlen(file->buffer);
int32_t start = 0;
int32_t oldLen = 0;
int32_t nameLen = (int32_t)strlen(name);
if (!basClassNameAttr(file->buffer, len, &start, &oldLen)) {
return true;
}
char *text = (char *)malloc((size_t)(len - oldLen + nameLen + 1));
if (!text) {
return false;
}
memcpy(text, file->buffer, (size_t)start);
memcpy(text + start, name, (size_t)nameLen);
memcpy(text + start + nameLen, file->buffer + start + oldLen, (size_t)(len - start - oldLen + 1));
free(file->buffer);
file->buffer = text;
file->modified = true;
if (fileIdx == sEditorFileIdx) {
loadModuleIntoEditor(fileIdx, text);
}
return true;
}
static void setOutputText(const char *text) {
if (!sOutWin) {
showOutputWindow();
}
if (sOutput) {
wgtSetText(sOutput, text);
}
}
static void setStatus(const char *text) {
if (sStatus) {
wgtSetText(sStatus, text);
}
}
// shiftBreakpointsForEdit -- move the editor file's breakpoints to follow
// an edit that changed the line count by delta. The edited region comes
// from diffing the old and new text (longest common suffix first, then
// prefix): lines that start before it stay, lines that start after it
// move by delta, and lines whose start was deleted or replaced lose
// their breakpoint. Joined lines can leave two breakpoints on one line;
// the duplicate goes.
static void shiftBreakpointsForEdit(const char *oldText, const char *newText, int32_t delta) {
int32_t oldLen = (int32_t)strlen(oldText);
int32_t newLen = (int32_t)strlen(newText);
int32_t suffix = 0;
int32_t prefix = 0;
while (suffix < oldLen && suffix < newLen && oldText[oldLen - 1 - suffix] == newText[newLen - 1 - suffix]) {
suffix++;
}
while (prefix < oldLen - suffix && prefix < newLen - suffix && oldText[prefix] == newText[prefix]) {
prefix++;
}
int32_t oldEnd = oldLen - suffix; // end of the replaced old text
int32_t base = editorLineToCodeLine(1) - 1; // code line before editor line 1
int32_t oldLines = countLines(oldText);
bool changed = false;
for (int32_t i = (int32_t)arrlen(sBreakpoints) - 1; i >= 0; i--) {
if (sBreakpoints[i].fileIdx != sEditorFileIdx) {
continue;
}
int32_t edLine = sBreakpoints[i].codeLine - base;
// Sections before the editor's are untouched, sections after it move
if (edLine < 1) {
continue;
}
if (edLine > oldLines) {
sBreakpoints[i].codeLine += delta;
changed = true;
continue;
}
int32_t start = lineStartOffset(oldText, edLine);
if (start < prefix) {
continue;
}
if (start >= oldEnd) {
sBreakpoints[i].codeLine += delta;
changed = true;
} else if (start != prefix) {
arrdel(sBreakpoints, i);
changed = true;
}
}
changed = dedupeBreakpoints() || changed;
if (changed) {
syncVmBreakpoints();
updateBreakpointWindow();
}
}
static void showBreakpointWindow(void) {
if (sBreakpointWin) {
dvxShowWindow(sAc, sBreakpointWin);
dvxRaiseWindow(sAc, sBreakpointWin);
updateBreakpointWindow();
return;
}
int32_t winW = IDE_BP_WIN_W;
int32_t winH = IDE_DEBUG_WIN_H;
int32_t winX = sAc->display.width - winW - IDE_WIN_MARGIN;
int32_t winY = sAc->display.height - winH - IDE_WIN_MARGIN;
sBreakpointWin = dvxCreateWindow(sAc, "Breakpoints", winX, winY, winW, winH, true);
if (sBreakpointWin) {
sBreakpointWin->onClose = onBreakpointWinClose;
sBreakpointWin->onMenu = onMenu;
sBreakpointWin->accelTable = sWin ? sWin->accelTable : NULL;
sBreakpointWin->resizable = true;
WidgetT *root = wgtInitWindow(sAc, sBreakpointWin);
if (root) {
sBreakpointList = wgtListView(root);
if (sBreakpointList) {
sBreakpointList->weight = WGT_WEIGHT_FILL;
sBreakpointList->onKeyDown = onBreakpointListKeyDown;
sBreakpointList->onDblClick = onBreakpointListDblClick;
wgtListViewSetMultiSelect(sBreakpointList, true);
static const ListViewColT cols[] = {
{ "File", wgtChars(IDE_COL_W_FILE), ListViewAlignLeftE },
{ "Procedure", wgtChars(IDE_COL_W_PROC), ListViewAlignLeftE },
{ "Line", wgtChars(IDE_COL_W_LINE), ListViewAlignRightE },
};
wgtListViewSetColumns(sBreakpointList, cols, DVX_ARRAY_LEN(cols));
}
}
}
updateBreakpointWindow();
}
static void showCallStackWindow(void) {
if (sCallStackWin) {
dvxShowWindow(sAc, sCallStackWin);
dvxRaiseWindow(sAc, sCallStackWin);
updateCallStackWindow();
return;
}
int32_t winW = IDE_CALLSTACK_WIN_W;
int32_t winH = IDE_DEBUG_WIN_H;
int32_t winX = sAc->display.width - winW;
int32_t winY = toolbarBottom() + IDE_CALLSTACK_WIN_Y_OFF;
sCallStackWin = dvxCreateWindow(sAc, "Call Stack", winX, winY, winW, winH, true);
if (sCallStackWin) {
sCallStackWin->onClose = onCallStackClose;
sCallStackWin->onMenu = onMenu;
sCallStackWin->accelTable = sWin ? sWin->accelTable : NULL;
sCallStackWin->resizable = true;
WidgetT *root = wgtInitWindow(sAc, sCallStackWin);
if (root) {
sCallStackList = wgtListView(root);
if (sCallStackList) {
sCallStackList->weight = WGT_WEIGHT_FILL;
static const ListViewColT cols[] = {
{ "Procedure", wgtChars(IDE_COL_W_PROC), ListViewAlignLeftE },
{ "Line", wgtChars(IDE_COL_W_LINE), ListViewAlignRightE },
};
wgtListViewSetColumns(sCallStackList, cols, DVX_ARRAY_LEN(cols));
}
}
}
updateCallStackWindow();
}
// showCodeView -- show the code of fileIdx (the active file): reopen the
// code window with the file's code loaded when it was closed, reload it
// when the editor holds another file, show the window if hidden, raise.
static void showCodeView(int32_t fileIdx) {
bool reopened = !sCodeWin;
if (reopened) {
showCodeWindow();
}
if (!sEditor) {
return;
}
if (reopened || sEditorFileIdx != fileIdx) {
if (sProject.files[fileIdx].kind == PrjKindFormE) {
loadFormCodeIntoEditor();
} else {
// Stash first: it may replace this very file's buffer
saveCurProc(true);
stashEditor();
bool missing = false;
char *owned = NULL;
const char *source = projectFileText(fileIdx, &owned, &missing);
loadModuleIntoEditor(fileIdx, source ? source : "");
free(owned);
}
}
if (!sCodeWin->visible) {
dvxShowWindow(sAc, sCodeWin);
}
dvxRaiseWindow(sAc, sCodeWin);
setStatus("Code view.");
}
static void showCodeWindow(void) {
if (sCodeWin) {
return; // already open
}
int32_t codeY = toolbarBottom();
int32_t codeH = sAc->display.height - codeY - (IDE_OUTPUT_WIN_H + IDE_OUTPUT_WIN_GAP);
sCodeWin = dvxCreateWindow(sAc, "Code", 0, codeY, sAc->display.width, codeH, true);
if (!sCodeWin) {
return;
}
// Ensure position is below the toolbar (dvxCreateWindow may adjust)
sCodeWin->y = codeY;
sCodeWin->onMenu = onMenu;
sCodeWin->onFocus = onContentFocus;
sCodeWin->onClose = onCodeWinClose;
sCodeWin->accelTable = sWin ? sWin->accelTable : NULL;
sLastFocusWin = sCodeWin;
WidgetT *codeRoot = wgtInitWindow(sAc, sCodeWin);
WidgetT *dropdownRow = codeRoot ? wgtHBox(codeRoot) : NULL;
sObjDropdown = (dropdownRow && wgtLabel(dropdownRow, "Object:")) ? wgtDropdown(dropdownRow) : NULL;
sEvtDropdown = (sObjDropdown && wgtLabel(dropdownRow, "Function:")) ? wgtDropdown(dropdownRow) : NULL;
sEditor = sEvtDropdown ? wgtTextArea(codeRoot, IDE_MAX_SOURCE) : NULL;
if (!sEditor) {
dvxDestroyWindow(sAc, sCodeWin);
sCodeWin = NULL;
sObjDropdown = NULL;
sEvtDropdown = NULL;
sLastFocusWin = NULL;
ideErrorBox("Not enough memory to open the code window.");
return;
}
// A new editor shows no section yet
sCurProcIdx = IDE_SECTION_NONE;
dropdownRow->spacing = wgtPixels(IDE_WIDGET_SPACING);
sObjDropdown->weight = WGT_WEIGHT_FILL;
sObjDropdown->onChange = onObjDropdownChange;
wgtDropdownSetItems(sObjDropdown, NULL, 0);
sEvtDropdown->weight = WGT_WEIGHT_FILL;
sEvtDropdown->onChange = onEvtDropdownChange;
wgtDropdownSetItems(sEvtDropdown, NULL, 0);
sEditor->weight = WGT_WEIGHT_FILL;
wgtTextAreaSetColorize(sEditor, basicColorize, NULL);
// Apply saved syntax colors
uint32_t initColors[TEXT_SYNTAX_MAX];
for (int32_t i = 0; i < TEXT_SYNTAX_MAX; i++) {
char key[IDE_PREF_KEY_BUF];
snprintf(key, sizeof(key), PREF_KEY_COLOR_FMT, (int)i);
initColors[i] = (uint32_t)prefsGetInt(sPrefs, PREF_SEC_SYNTAX, key, (int32_t)textEditDefaultSyntaxRgb((uint8_t)i));
}
wgtTextAreaSetSyntaxColors(sEditor, initColors, TEXT_SYNTAX_MAX);
wgtTextAreaSetLineDecorator(sEditor, debugLineDecorator, sAc);
wgtTextAreaSetGutterClick(sEditor, onGutterClick);
wgtTextAreaSetShowLineNumbers(sEditor, true);
wgtTextAreaSetAutoIndent(sEditor, true);
wgtTextAreaSetCaptureTabs(sEditor, true);
wgtTextAreaSetTabWidth(sEditor, prefsGetInt(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_TAB_WIDTH, IDE_DEFAULT_TAB_WIDTH));
wgtTextAreaSetUseTabChar(sEditor, !prefsGetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_USE_SPACES, true));
// Programmatic loads go through editorSetText, which suppresses
// onChange, so the handler can be attached right away without false
// dirty marking.
sEditor->onChange = onEditorChange;
editorSnapshot(countLines(wgtGetText(sEditor)));
updateProjectMenuState();
updateDirtyIndicators();
}
// showCompileError -- present sOutputBuf (already filled) as the
// compile result and leave the busy state.
static void showCompileError(const char *status) {
outputLog(sOutputBuf);
setOutputText(sOutputBuf);
showOutputWindow();
if (sOutWin) {
dvxRaiseWindow(sAc, sOutWin);
}
setStatus(status);
dvxSetBusy(sAc, false);
}
static void showImmediateWindow(void) {
if (sImmWin) {
dvxShowWindow(sAc, sImmWin);
dvxRaiseWindow(sAc, sImmWin);
return;
}
int32_t outH = IDE_OUTPUT_WIN_H;
int32_t outY = sAc->display.height - outH;
sImmWin = dvxCreateWindow(sAc, "Immediate", sAc->display.width / 2, outY, sAc->display.width / 2, outH, true);
if (sImmWin) {
sImmWin->onClose = onImmWinClose;
sImmWin->onFocus = onContentFocus;
sImmWin->onMenu = onMenu;
sImmWin->accelTable = sWin ? sWin->accelTable : NULL;
sLastFocusWin = sImmWin;
WidgetT *immRoot = wgtInitWindow(sAc, sImmWin);
if (immRoot) {
sImmediate = wgtTextArea(immRoot, IDE_MAX_IMM);
if (sImmediate) {
sImmediate->weight = WGT_WEIGHT_FILL;
sImmediate->readOnly = false;
sImmediate->onKeyDown = onImmediateKeyDown;
} else {
dvxLog("IDE: failed to create immediate TextArea");
}
} else {
dvxLog("IDE: failed to init immediate window root");
}
}
}
static void showLocalsWindow(void) {
if (sLocalsWin) {
dvxShowWindow(sAc, sLocalsWin);
dvxRaiseWindow(sAc, sLocalsWin);
updateLocalsWindow();
return;
}
int32_t winW = IDE_LOCALS_WIN_W;
int32_t winH = IDE_LOCALS_WIN_H;
int32_t winX = sAc->display.width - winW;
int32_t winY = toolbarBottom();
sLocalsWin = dvxCreateWindow(sAc, "Locals", winX, winY, winW, winH, true);
if (sLocalsWin) {
sLocalsWin->onClose = onLocalsClose;
sLocalsWin->onMenu = onMenu;
sLocalsWin->accelTable = sWin ? sWin->accelTable : NULL;
sLocalsWin->resizable = true;
WidgetT *root = wgtInitWindow(sAc, sLocalsWin);
if (root) {
sLocalsList = wgtListView(root);
if (sLocalsList) {
sLocalsList->weight = WGT_WEIGHT_FILL;
static const ListViewColT cols[] = {
{ "Name", wgtChars(IDE_COL_W_NAME), ListViewAlignLeftE },
{ "Type", wgtChars(IDE_COL_W_TYPE), ListViewAlignLeftE },
{ "Value", wgtChars(IDE_COL_W_VALUE), ListViewAlignLeftE },
};
wgtListViewSetColumns(sLocalsList, cols, DVX_ARRAY_LEN(cols));
}
}
}
updateLocalsWindow();
}
static void showOutputWindow(void) {
if (sOutWin) {
dvxShowWindow(sAc, sOutWin);
return;
}
int32_t outH = IDE_OUTPUT_WIN_H;
int32_t outY = sAc->display.height - outH;
sOutWin = dvxCreateWindow(sAc, "Output", 0, outY, sAc->display.width / 2, outH, true);
if (sOutWin) {
sOutWin->onClose = onOutWinClose;
sOutWin->onFocus = onContentFocus;
sOutWin->onMenu = onMenu;
sOutWin->accelTable = sWin ? sWin->accelTable : NULL;
sLastFocusWin = sOutWin;
WidgetT *outRoot = wgtInitWindow(sAc, sOutWin);
sOutput = outRoot ? wgtTextArea(outRoot, IDE_MAX_OUTPUT) : NULL;
if (!sOutput) {
dvxLog("IDE: failed to create output TextArea");
return;
}
sOutput->weight = WGT_WEIGHT_FILL;
sOutput->readOnly = true;
if (sOutputLen > 0) {
setOutputText(sOutputBuf);
}
}
}
static void showPreferencesDialog(void) {
// One dialog at a time: its handlers share sPrefsDlg
if (sPrefsDlg.win) {
dvxRaiseWindow(sAc, sPrefsDlg.win);
return;
}
memset(&sPrefsDlg, 0, sizeof(sPrefsDlg));
WindowT *win = dvxCreateWindowCentered(sAc, "Preferences", IDE_PREFS_WIN_W, IDE_PREFS_WIN_H, false);
if (!win) {
return;
}
win->maxW = win->w;
win->maxH = win->h;
if (!prefsBuild(win)) {
dvxDestroyWindow(sAc, win);
memset(&sPrefsDlg, 0, sizeof(sPrefsDlg));
ideErrorBox("Not enough memory to open Preferences.");
return;
}
// Closing the window (X, Alt+F4) cancels like the Cancel button
sPrefsDlg.win = win;
win->onClose = onPrefsClose;
win->modal = true;
dvxFitWindow(sAc, win);
WindowT *prevModal = sAc->modalWindow;
sAc->modalWindow = win;
while (!sPrefsDlg.done && sAc->running) {
dvxUpdate(sAc);
}
if (sPrefsDlg.accepted) {
// General tab
prefsSetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_RENAME_SKIP, wgtCheckboxIsChecked(sPrefsDlg.renameSkipComments));
prefsSetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_OPTION_EXPLICIT, wgtCheckboxIsChecked(sPrefsDlg.optionExplicit));
prefsSetBool(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_USE_SPACES, wgtCheckboxIsChecked(sPrefsDlg.useSpaces));
const char *tw = wgtGetText(sPrefsDlg.tabWidthInput);
int32_t tabW = tw ? atoi(tw) : IDE_DEFAULT_TAB_WIDTH;
if (tabW < IDE_MIN_TAB_WIDTH) {
tabW = IDE_MIN_TAB_WIDTH;
}
if (tabW > IDE_MAX_TAB_WIDTH) {
tabW = IDE_MAX_TAB_WIDTH;
}
prefsSetInt(sPrefs, IDE_PREF_SECTION_EDITOR, IDE_PREF_KEY_TAB_WIDTH, tabW);
if (sEditor) {
wgtTextAreaSetTabWidth(sEditor, tabW);
wgtTextAreaSetUseTabChar(sEditor, !wgtCheckboxIsChecked(sPrefsDlg.useSpaces));
}
const char *val;
val = wgtGetText(sPrefsDlg.defAuthor);
prefsSetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_AUTHOR, val ? val : "");
val = wgtGetText(sPrefsDlg.defPublisher);
prefsSetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_PUBLISHER, val ? val : "");
val = wgtGetText(sPrefsDlg.defVersion);
prefsSetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_VERSION, val ? val : IDE_PREF_DEFAULT_VERSION);
val = wgtGetText(sPrefsDlg.defCopyright);
prefsSetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_COPYRIGHT, val ? val : "");
char desc[PRJ_MAX_DESC];
val = wgtGetText(sPrefsDlg.defDescription);
prjSingleLine(desc, sizeof(desc), val ? val : "");
prefsSetString(sPrefs, IDE_PREF_SECTION_DEFAULTS, IDE_PREF_KEY_DESCRIPTION, desc);
// Colors tab
for (int32_t i = 0; i < TEXT_SYNTAX_MAX; i++) {
char key[IDE_PREF_KEY_BUF];
snprintf(key, sizeof(key), PREF_KEY_COLOR_FMT, (int)i);
prefsSetInt(sPrefs, PREF_SEC_SYNTAX, key, (int32_t)sPrefsDlg.syntaxColors[i]);
}
applySyntaxColors();
prefsSave(sPrefs);
}
sAc->modalWindow = prevModal;
sPrefsDlg.win = NULL;
dvxDestroyWindow(sAc, win);
}
// showProc -- display a procedure buffer (-1 = General) in the editor
static void showProc(int32_t procIdx) {
if (!sEditor) {
return;
}
// Save whatever is currently in the editor. Leaving an untouched
// event skeleton discards it; since arrdel shifts everything after
// it, the target index follows.
if (sCurProcIdx >= IDE_SECTION_GENERAL) {
int32_t leftIdx = sCurProcIdx;
bool removed = saveCurProc(procIdx != sCurProcIdx);
// Every later procedure's line number depends on the buffer just
// saved (lines added or removed above it shift them), so the proc
// table is rebuilt after any save -- not only when the list
// changed -- or breakpoints toggled in the next proc land on the
// wrong compile line.
joinProcBufs();
if (removed && leftIdx >= 0 && procIdx > leftIdx) {
procIdx--;
}
}
if (procIdx >= 0 && procIdx < (int32_t)arrlen(sProcBufs)) {
editorSetText(sProcBufs[procIdx] ? sProcBufs[procIdx] : "", IDE_CARET_LOAD);
sCurProcIdx = procIdx;
} else {
editorSetText(sGeneralBuf ? sGeneralBuf : "", IDE_CARET_LOAD);
sCurProcIdx = IDE_SECTION_GENERAL;
}
}
// showProcAndFind -- switch to a procedure, sync the dropdowns, and
// select the search match in the editor.
static bool showProcAndFind(int32_t procIdx, const char *needle, bool caseSensitive, bool forward) {
showProc(procIdx);
// Sync the Object/Event dropdowns to match
if (procIdx >= 0 && procIdx < (int32_t)arrlen(sProcTable)) {
selectDropdowns(sProcTable[procIdx].objName, sProcTable[procIdx].evtName);
} else if (procIdx == -1 && sObjDropdown) {
wgtDropdownSetSelected(sObjDropdown, 0); // (General)
}
if (sEditor) {
// showProc leaves the cursor at the top of the proc, which is the
// wrong anchor for a backward scan (it would find nothing). When
// searching backward, move the cursor to the true end of the buffer
// (offset == len) so the scan walks upward through every match,
// including any on the final line of a proc with no trailing newline.
if (!forward) {
wgtTextAreaCursorToEnd(sEditor);
}
return wgtTextAreaFindNext(sEditor, needle, caseSensitive, forward);
}
return false;
}
static void showWatchWindow(void) {
if (sWatchWin) {
dvxShowWindow(sAc, sWatchWin);
dvxRaiseWindow(sAc, sWatchWin);
updateWatchWindow();
return;
}
int32_t winW = IDE_WATCH_WIN_W;
int32_t winH = IDE_DEBUG_WIN_H;
int32_t winX = sAc->display.width - winW - IDE_WATCH_WIN_X_GAP;
int32_t winY = toolbarBottom();
sWatchWin = dvxCreateWindow(sAc, "Watch", winX, winY, winW, winH, true);
if (sWatchWin) {
sWatchWin->onClose = onWatchClose;
sWatchWin->onMenu = onMenu;
sWatchWin->accelTable = sWin ? sWin->accelTable : NULL;
sWatchWin->resizable = true;
WidgetT *root = wgtInitWindow(sAc, sWatchWin);
if (root) {
// Expression input at top
sWatchInput = wgtTextInput(root, IDE_VALUE_BUF);
if (sWatchInput) {
sWatchInput->onKeyDown = onWatchInputKeyDown;
}
// Results list below
sWatchList = wgtListView(root);
if (sWatchList) {
sWatchList->weight = WGT_WEIGHT_FILL;
sWatchList->onKeyDown = onWatchListKeyDown;
sWatchList->onDblClick = onWatchListDblClick;
static const ListViewColT cols[] = {
{ "Expression", wgtChars(IDE_COL_W_EXPR), ListViewAlignLeftE },
{ "Value", wgtChars(IDE_COL_W_WATCH_VALUE), ListViewAlignLeftE },
};
wgtListViewSetColumns(sWatchList, cols, DVX_ARRAY_LEN(cols));
}
}
}
updateWatchWindow();
}
// skipLine -- advance past the end of the current line (or to the NUL)
static const char *skipLine(const char *p) {
while (*p && *p != '\n') {
p++;
}
if (*p == '\n') {
p++;
}
return p;
}
// skipToEndProc -- from the start of a SUB/FUNCTION declaration line,
// return the position just past the matching END SUB/END FUNCTION line
// (or the end of the text). *outEndLineOffset receives the END line's
// distance in lines from the declaration (the last line's when missing).
static const char *skipToEndProc(const char *declLine, bool isSub, int32_t *outEndLineOffset) {
const char *endTag = isSub ? KW_END_SUB : KW_END_FUNCTION;
const char *scan = skipLine(declLine);
int32_t line = 1;
bool found = false;
while (*scan) {
if (kwMatch(dvxSkipWs(scan), endTag)) {
found = true;
scan = skipLine(scan);
break;
}
scan = skipLine(scan);
line++;
}
*outEndLineOffset = found ? line : line - 1;
return scan;
}
// splitProcs -- split source into a (General) buffer plus one buffer per
// SUB/FUNCTION block. Every line outside a procedure (including any
// between or after procedures) belongs to General, so nothing is lost
// when the file is reassembled; General's trailing blank lines are
// trimmed. When outMap is not NULL it receives, per source line, the
// piece and line it went to (a trimmed line maps past General's end).
// Returns false, with nothing allocated, when memory runs out. Caller
// frees the results.
static bool splitProcs(const char *source, char **outGeneral, char ***outProcs, IdeLineDestT **outMap) {
int32_t srcLen = (int32_t)strlen(source);
char *general = (char *)malloc(srcLen + 2); // room for '\n' + NUL
int32_t genLen = 0;
int32_t genLine = 0;
char **procs = NULL;
IdeLineDestT *map = NULL;
const char *pos = source;
bool ok = general != NULL;
while (ok && *pos) {
bool isSub = false;
if (procDeclAt(dvxSkipWs(pos), &isSub)) {
int32_t endOffset = 0;
const char *end = skipToEndProc(pos, isSub, &endOffset);
int32_t procLen = (int32_t)(end - pos);
char *procBuf = (char *)malloc(procLen + 1);
ok = procBuf != NULL;
if (ok) {
memcpy(procBuf, pos, procLen);
procBuf[procLen] = '\0';
arrput(procs, procBuf);
int32_t line = 0;
for (const char *q = pos; outMap && q < end; q = skipLine(q)) {
IdeLineDestT dest = { (int32_t)arrlen(procs) - 1, line++ };
arrput(map, dest);
}
}
pos = end;
continue;
}
const char *next = skipLine(pos);
memcpy(general + genLen, pos, next - pos);
genLen += (int32_t)(next - pos);
if (outMap) {
IdeLineDestT dest = { IDE_SECTION_GENERAL, genLine };
arrput(map, dest);
}
genLine++;
pos = next;
}
if (!ok) {
free(general);
for (int32_t i = 0; i < (int32_t)arrlen(procs); i++) {
free(procs[i]);
}
arrfree(procs);
arrfree(map);
return false;
}
// Trim trailing blank lines; a non-empty section ends in one newline
general[genLen] = '\0';
genLen = dvxTrimRight(general);
if (genLen > 0) {
general[genLen++] = '\n';
}
general[genLen] = '\0';
*outGeneral = general;
*outProcs = procs;
if (outMap) {
*outMap = map;
}
return true;
}
// stashCurrentFile -- stash the editor's and the designer's state back
// into the project buffers of the files they belong to (the designer may
// hold a form while a module is active). Caching only: nothing is
// marked modified beyond mirroring the designer's dirty flag. Returns
// false, after telling the user, when the form cannot be serialized; its
// previous buffer is kept.
static bool stashCurrentFile(void) {
stashEditor();
if (!sDesigner.form || sDesignerFileIdx < 0 || sDesignerFileIdx >= prjFileCount(&sProject)) {
return true;
}
PrjFileT *file = &sProject.files[sDesignerFileIdx];
syncFormDirty();
// Serialize form designer state to .frm text
char *frmBuf = (char *)malloc(IDE_MAX_SOURCE);
if (!frmBuf) {
ideErrorBox("Not enough memory to save the form.");
return false;
}
int32_t frmLen = dsgnSaveFrm(&sDesigner, frmBuf, IDE_MAX_SOURCE);
// On failure keep the previous buffer rather than a truncated one
if (frmLen < 0) {
free(frmBuf);
ideErrorBox(frmLen == DSGN_SAVE_LINE_TOO_LONG ? "A property value is too long to save at its position in the form. Shorten it and save again." : "Form is too large to save; its code section does not fit.");
return false;
}
frmBuf[frmLen] = '\0';
// Keep only what the text needs, not the whole scratch size
char *fitted = (char *)realloc(frmBuf, (size_t)frmLen + 1);
free(file->buffer);
file->buffer = fitted ? fitted : frmBuf;
snprintf(file->formName, sizeof(file->formName), "%s", sDesigner.form->name);
return true;
}
// stashEditor -- write the editor's text back to the file it is bound
// to: a module's project buffer, or the designer form's code.
static void stashEditor(void) {
if (sEditorFileIdx < 0 || sEditorFileIdx >= prjFileCount(&sProject)) {
return;
}
PrjFileT *file = &sProject.files[sEditorFileIdx];
if (file->kind == PrjKindFormE) {
stashFormCode();
return;
}
char *copy = strdup(getFullSource());
if (copy) {
free(file->buffer);
file->buffer = copy;
}
}
// stashFormCode -- if the proc buffers belong to the designer's form,
// save them back to form->code.
static void stashFormCode(void) {
if (!sDesigner.form || sEditorFileIdx < 0 || sEditorFileIdx != sDesignerFileIdx) {
return;
}
char *code = strdup(getFullSource());
if (code) {
free(sDesigner.form->code);
sDesigner.form->code = code;
}
}
static void switchToDesign(void) {
stashFormCode();
// If already open, just bring to front
if (sFormWin) {
dvxRaiseWindow(sAc, sFormWin);
return;
}
// A form file the designer could not parse opens as a blank form
if (!sDesigner.form) {
dsgnNewForm(&sDesigner, IDE_DEFAULT_FORM);
sDesignerFileIdx = sProject.activeFileIdx;
}
if (!sDesigner.form) {
return;
}
DsgnFormT *form = sDesigner.form;
// Create the form designer window using the shared form window builder
char title[IDE_FORM_TITLE_BUF];
snprintf(title, sizeof(title), "%s [Design]", form->name);
WidgetT *root;
WidgetT *contentBox;
sFormWin = basFormRtCreateFormWindow(sAc, title, form->layout, form->resizable, false, false, form->width, form->height, 0, 0, &root, &contentBox);
if (!sFormWin) {
return;
}
sFormWin->visible = true;
sFormWin->onClose = onFormWinClose;
sFormWin->onMenu = onFormWinMenu;
sFormWin->onFocus = onContentFocus;
sFormWin->accelTable = sWin ? sWin->accelTable : NULL;
sDesigner.formWin = sFormWin;
// Build preview menu bar from form's menu items
dsgnBuildPreviewMenuBar(sFormWin, form);
// Override paint and mouse AFTER wgtInitWindow (which sets widgetOnPaint).
// onResize is attached after the initial sizing below: sizing the
// window to the form is not an edit.
sFormWin->onPaint = onFormWinPaint;
sFormWin->onMouse = onFormWinMouse;
sFormWin->onKey = onFormWinKey;
sFormWin->onCursorQuery = onFormWinCursorQuery;
// Create live widgets for each control
dsgnCreateWidgets(&sDesigner, contentBox);
// Set form caption as window title
if (form->caption[0]) {
snprintf(title, sizeof(title), "%s [Design]", form->caption);
dvxSetTitle(sAc, sFormWin, title);
}
// Size the form window
if (form->autoSize) {
dvxFitWindow(sAc, sFormWin);
form->width = sFormWin->w;
form->height = sFormWin->h;
} else {
dvxResizeWindow(sAc, sFormWin, form->width, form->height);
}
sFormWin->onResize = onFormWinResize;
// Create toolbox and properties windows
if (!sToolboxWin) {
sToolboxWin = tbxCreate(sAc, &sDesigner, toolbarBottom());
if (sToolboxWin) {
sToolboxWin->onMenu = onMenu;
sToolboxWin->accelTable = sWin ? sWin->accelTable : NULL;
}
}
if (!sPropsWin) {
sPropsWin = prpCreate(sAc, &sDesigner);
if (sPropsWin) {
sPropsWin->y = toolbarBottom();
sPropsWin->onMenu = onMenu;
sPropsWin->accelTable = sWin ? sWin->accelTable : NULL;
}
}
dvxInvalidateWindow(sAc, sFormWin);
updateProjectMenuState();
setStatus("Design view open.");
}
// syncFormDirty -- mirror form->dirty onto the designer file's project
// entry so the tree, title bar and save logic all see one consistent flag.
static void syncFormDirty(void) {
if (sDesigner.form && sDesigner.form->dirty && sDesignerFileIdx >= 0 && sDesignerFileIdx < prjFileCount(&sProject)) {
sProject.files[sDesignerFileIdx].modified = true;
}
}
// syncVmBreakpoints -- push the IDE breakpoint list to the live VM (no-op
// when nothing is running or the program was started without debugging).
static void syncVmBreakpoints(void) {
if (!sVm || !sDbgEnabled) {
return;
}
buildVmBreakpoints();
basVmSetBreakpoints(sVm, sVmBreakpoints, (int32_t)arrlen(sVmBreakpoints));
}
static void teardownFormWin(void) {
if (sFormWin) {
dvxDestroyWindow(sAc, sFormWin);
cleanupFormWin();
}
}
static void toggleBreakpoint(void) {
if (!sEditor) {
return;
}
toggleBreakpointLine(wgtTextAreaGetCursorLine(sEditor));
}
static void toggleBreakpointLine(int32_t editorLine) {
int32_t fileIdx = sEditorFileIdx;
if (fileIdx < 0) {
return;
}
// Convert editor line to file code line by adding proc offset
int32_t codeLine = editorLineToCodeLine(editorLine);
// Check if this breakpoint already exists -- remove it
for (int32_t i = 0; i < (int32_t)arrlen(sBreakpoints); i++) {
if (sBreakpoints[i].fileIdx == fileIdx && sBreakpoints[i].codeLine == codeLine) {
arrdel(sBreakpoints, i);
syncVmBreakpoints();
if (sEditor) {
wgtInvalidatePaint(sEditor);
}
updateBreakpointWindow();
return;
}
}
// Validate that this line is breakable (not blank, comment, SUB/FUNCTION
// decl/end or a class module's header)
if (sEditor) {
const char *text = wgtGetText(sEditor);
if (text) {
// A class module's header opens its (General) section
if (sProject.files[fileIdx].kind == PrjKindClassE && sCurProcIdx == IDE_SECTION_GENERAL) {
int32_t firstCodeLine = 1;
prjClassCodePos(text, (int32_t)strlen(text), &firstCodeLine);
if (editorLine < firstCodeLine) {
return;
}
}
// Find the start of editorLine (1-based)
const char *p = text;
for (int32_t ln = 1; *p && ln < editorLine; ln++) {
p = skipLine(p);
}
// Skip leading whitespace
p = dvxSkipWs(p);
// Blank line
if (*p == '\0' || *p == '\n' || *p == '\r') {
return;
}
// Comment (single quote or REM)
if (*p == '\'') {
return;
}
if (isRemAt(p, 0, (int32_t)strcspn(p, "\n"))) {
return;
}
// SUB/FUNCTION declaration or END SUB/FUNCTION
bool isSub;
if (procDeclAt(p, &isSub) || kwMatch(p, KW_END_SUB) || kwMatch(p, KW_END_FUNCTION)) {
return;
}
}
}
// Add new breakpoint
IdeBreakpointT bp;
memset(&bp, 0, sizeof(bp));
bp.fileIdx = fileIdx;
bp.codeLine = codeLine;
setBreakpointProcName(&bp, sCurProcIdx);
arrput(sBreakpoints, bp);
syncVmBreakpoints();
// The first breakpoint of the file starts the edit snapshots
if (sEditor) {
editorSnapshot(sEditorLineCount);
wgtInvalidatePaint(sEditor);
}
updateBreakpointWindow();
}
static int32_t toolbarBottom(void) {
return sWin ? sWin->y + sWin->h + IDE_TOOLBAR_GAP : IDE_TOOLBAR_FALLBACK_Y;
}
static const char *typeNameStr(uint8_t dt) {
switch (dt) {
case BAS_TYPE_INTEGER:
return "Integer";
case BAS_TYPE_BYTE:
return "Byte";
case BAS_TYPE_CURRENCY:
return "Currency";
case BAS_TYPE_LONG:
return "Long";
case BAS_TYPE_SINGLE:
return "Single";
case BAS_TYPE_DOUBLE:
return "Double";
case BAS_TYPE_STRING:
return "String";
case BAS_TYPE_BOOLEAN:
return "Boolean";
case BAS_TYPE_DATE:
return "Date";
case BAS_TYPE_ARRAY:
return "Array";
case BAS_TYPE_UDT:
return "UDT";
case BAS_TYPE_OBJECT:
case BAS_TYPE_INSTANCE:
return IDE_OBJECT_TYPE;
case BAS_TYPE_EMPTY:
return "Empty";
case BAS_TYPE_NULL:
return "Null";
case BAS_TYPE_VARIANT:
return "Variant";
case BAS_TYPE_MISSING:
return "Missing";
default:
return "?";
}
}
static void updateBreakpointWindow(void) {
if (!sBreakpointList || !sBreakpointWin || !sBreakpointWin->visible) {
return;
}
listRowsReset(&sBpRows);
int32_t count = (int32_t)arrlen(sBreakpoints);
for (int32_t i = 0; i < count; i++) {
char lineBuf[IDE_LINE_NUM_BUF];
// File name
if (sBreakpoints[i].fileIdx >= 0 && sBreakpoints[i].fileIdx < prjFileCount(&sProject)) {
listRowsAdd(&sBpRows, sProject.files[sBreakpoints[i].fileIdx].path);
} else {
listRowsAdd(&sBpRows, "?");
}
// Procedure name
listRowsAdd(&sBpRows, sBreakpoints[i].procName);
// Line number
snprintf(lineBuf, sizeof(lineBuf), "%d", (int)sBreakpoints[i].codeLine);
listRowsAdd(&sBpRows, lineBuf);
}
listRowsCommit(&sBpRows, sBreakpointList, count);
}
static void updateCallStackWindow(void) {
if (!sCallStackList || !sCallStackWin || !sCallStackWin->visible) {
return;
}
listRowsReset(&sCallRows);
if (sDbgState != DbgPausedE || !sVm || !sDbgModule) {
listRowsCommit(&sCallRows, sCallStackList, 0);
return;
}
int32_t rowCount = 0;
// Current location first
if (sDbgCurrentLine > 0) {
char lineBuf[IDE_LINE_NUM_BUF];
int32_t curProcIdx = vmCurProcIdx();
snprintf(lineBuf, sizeof(lineBuf), "%d", (int)sDbgCurrentLine);
listRowsAdd(&sCallRows, curProcIdx >= 0 ? sDbgModule->procs[curProcIdx].name : IDE_MODULE_FRAME);
listRowsAdd(&sCallRows, lineBuf);
rowCount++;
}
// Walk the callers, innermost first. Frame d is suspended at the
// return address of frame d + 1; frame 0 is the implicit module frame.
for (int32_t d = sVm->callDepth - 2; d >= 0; d--) {
listRowsAdd(&sCallRows, d > 0 ? vmProcNameForPc(sVm->callStack[d + 1].returnPc) : IDE_MODULE_FRAME);
listRowsAdd(&sCallRows, "");
rowCount++;
}
listRowsCommit(&sCallRows, sCallStackList, rowCount);
}
static void updateDirtyIndicators(void) {
syncFormDirty();
updateMainTitle();
// Code window title -- only shows * when code has been edited
if (sCodeWin) {
bool codeDirty = false;
const char *codeFile = "";
if (sEditorFileIdx >= 0 && sEditorFileIdx < prjFileCount(&sProject)) {
codeDirty = sProject.files[sEditorFileIdx].modified;
codeFile = sProject.files[sEditorFileIdx].path;
} else if (sProject.activeFileIdx >= 0 && sProject.activeFileIdx < prjFileCount(&sProject)) {
codeDirty = sProject.files[sProject.activeFileIdx].modified;
codeFile = sProject.files[sProject.activeFileIdx].path;
}
char codeTitle[IDE_MSG_BUF];
snprintf(codeTitle, sizeof(codeTitle), "Code - %s%s", codeFile, codeDirty ? " *" : "");
dvxSetTitle(sAc, sCodeWin, codeTitle);
}
// Design window title
if (sFormWin && sDesigner.form) {
char title[IDE_FORM_TITLE_BUF];
snprintf(title, sizeof(title), "%s [Design]%s", sDesigner.form->caption[0] ? sDesigner.form->caption : sDesigner.form->name, sDesigner.form->dirty ? " *" : "");
dvxSetTitle(sAc, sFormWin, title);
}
// Project tree: rebuild with "*" on dirty files
if (sProjectWin) {
prjRebuildTree(&sProject);
}
}
// updateDropdowns -- refresh sProcTable from the editor's buffers and
// repopulate the Object dropdown (which cascades into the Event dropdown).
static void updateDropdowns(void) {
// Rebuilds sProcTable as a side effect; the file's WithEvents
// variables are objects too
scanWithEvents(getFullSource());
// Reset dynamic arrays. sObjItems owns strdup'd copies -- free them
// first so no entry survives a subsequent controls/menuItems mutation
// that could invalidate the source pointer.
for (int32_t i = 0; i < (int32_t)arrlen(sObjItems); i++) {
free((void *)sObjItems[i]);
}
arrsetlen(sObjItems, 0);
evtItemsReset();
if (!sObjDropdown || !sEvtDropdown) {
return;
}
// Build object names for the Object dropdown. All entries are
// strdup'd so sObjItems owns its strings -- the designer's menuItems
// array in particular is an stb_ds struct array whose backing
// storage can move on the next arrput, which would dangle any name
// pointer we borrowed from &menuItems[i].name.
arrput(sObjItems, strdup(IDE_GENERAL_SECTION));
if (sDesigner.form) {
arrput(sObjItems, strdup(sDesigner.form->name));
for (int32_t i = 0; i < (int32_t)arrlen(sDesigner.form->controls); i++) {
arrput(sObjItems, strdup(sDesigner.form->controls[i]->name));
}
// Add menu item names (non-separator, non-top-level-header-only)
for (int32_t i = 0; i < (int32_t)arrlen(sDesigner.form->menuItems); i++) {
DsgnMenuItemT *mi = &sDesigner.form->menuItems[i];
if (mi->name[0] && mi->caption[0] != '-') {
arrput(sObjItems, strdup(mi->name));
}
}
}
for (int32_t i = 0; i < (int32_t)arrlen(sWithEvents); i++) {
arrput(sObjItems, strdup(sWithEvents[i].name));
}
// A failed strdup would put a NULL name in the dropdown
for (int32_t i = (int32_t)arrlen(sObjItems) - 1; i >= 0; i--) {
if (!sObjItems[i]) {
arrdel(sObjItems, i);
}
}
// Sort object items alphabetically, keeping (General) first
int32_t objCount = (int32_t)arrlen(sObjItems);
if (objCount > 1) {
qsort(sObjItems + 1, objCount - 1, sizeof(const char *), cmpStrPtrs);
}
wgtDropdownSetItems(sObjDropdown, sObjItems, objCount);
if (objCount > 0) {
wgtDropdownSetSelected(sObjDropdown, 0);
onObjDropdownChange(sObjDropdown);
} else {
wgtDropdownSetItems(sEvtDropdown, NULL, 0);
}
}
static void updateLocalsWindow(void) {
if (!sLocalsList || !sLocalsWin || !sLocalsWin->visible) {
return;
}
listRowsReset(&sLocalsRows);
if (sDbgState != DbgPausedE || !sVm || !sDbgModule) {
listRowsCommit(&sLocalsRows, sLocalsList, 0);
return;
}
// Locals of the current proc, globals, and the current form's variables
int32_t curProcIdx = vmCurProcIdx();
int32_t rowCount = 0;
if (sDbgModule->debugVars) {
for (int32_t i = 0; i < sDbgModule->debugVarCount; i++) {
BasDebugVarT *dv = &sDbgModule->debugVars[i];
if (!debugVarVisible(dv, curProcIdx) || isMangledDebugName(dv->name)) {
continue;
}
char typeBuf[IDE_TYPE_NAME_BUF];
char valueBuf[BAS_MAX_IDENT];
// Read the value first so we can use it for the type column
BasValueT val;
BasValueT *slot = getDebugVarSlot(dv);
if (slot) {
val = *slot;
} else {
memset(&val, 0, sizeof(val));
}
// Type column -- arrays show "type()" with the element type, an
// object its class, a Variant "Variant/" and what it holds
const char *valType = (val.type == BAS_TYPE_INSTANCE) ? instanceTypeName(val.instVal) : typeNameStr(val.type);
if (dv->dataType == BAS_TYPE_ARRAY && val.arrVal) {
snprintf(typeBuf, sizeof(typeBuf), "%s()", typeNameStr(val.arrVal->elementType));
} else if (dv->dataType == BAS_TYPE_VARIANT) {
snprintf(typeBuf, sizeof(typeBuf), "%s/%s", typeNameStr(BAS_TYPE_VARIANT), valType);
} else if (val.type == BAS_TYPE_INSTANCE) {
snprintf(typeBuf, sizeof(typeBuf), "%s", valType);
} else {
snprintf(typeBuf, sizeof(typeBuf), "%s", typeNameStr(dv->dataType));
}
formatValue(&val, valueBuf, sizeof(valueBuf));
listRowsAdd(&sLocalsRows, dv->name);
listRowsAdd(&sLocalsRows, typeBuf);
listRowsAdd(&sLocalsRows, valueBuf);
rowCount++;
}
}
listRowsCommit(&sLocalsRows, sLocalsList, rowCount);
}
// updateMainTitle -- "DVX BASIC - [ProjectName] *" (the * when anything
// is unsaved), or just "DVX BASIC" with no project open.
static void updateMainTitle(void) {
if (!sWin) {
return;
}
char title[IDE_TITLE_BUF];
if (hasProject()) {
snprintf(title, sizeof(title), "%s - [%s]%s", IDE_MAIN_TITLE, sProject.name, hasUnsavedData() ? " *" : "");
} else {
snprintf(title, sizeof(title), "%s", IDE_MAIN_TITLE);
}
dvxSetTitle(sAc, sWin, title);
}
static void updateProjectMenuState(void) {
if (!sWin || !sWin->menuBar) {
return;
}
bool project = hasProject();
bool hasFile = (project && sProject.activeFileIdx >= 0 && sProject.activeFileIdx < prjFileCount(&sProject));
bool hasForm = activeIsForm();
bool isIdle = (sDbgState == DbgIdleE);
bool isPaused = (sDbgState == DbgPausedE);
bool isRunning = (sDbgState == DbgRunningE);
bool canRun = project && (isIdle || isPaused);
bool canStop = isRunning || isPaused;
// Project menu
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_SAVE, project && sProject.dirty);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_CLOSE, project && isIdle);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_NEW, isIdle);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_OPEN, isIdle);
wmMenuItemSetEnabled(sWin->menuBar, CMD_OPEN, isIdle);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_NEW_CLASS, project && isIdle);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_PROPS, project);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_RENAME, isIdle && prjGetSelectedFileIdx() >= 0);
wmMenuItemSetEnabled(sWin->menuBar, CMD_PRJ_REMOVE, isIdle && prjGetSelectedFileIdx() >= 0);
// Save: only when active file is dirty
bool fileDirty = hasFile && sProject.files[sProject.activeFileIdx].modified;
bool formDirty = hasFile && sDesigner.form && sDesigner.form->dirty;
wmMenuItemSetEnabled(sWin->menuBar, CMD_SAVE, fileDirty || formDirty);
// Save All: only when any file is dirty
wmMenuItemSetEnabled(sWin->menuBar, CMD_SAVE_ALL, anyFileModified());
wmMenuItemSetEnabled(sWin->menuBar, CMD_MAKE_EXE, project && isIdle);
// Edit menu
wmMenuItemSetEnabled(sWin->menuBar, CMD_FIND, project);
wmMenuItemSetEnabled(sWin->menuBar, CMD_FIND_NEXT, project);
wmMenuItemSetEnabled(sWin->menuBar, CMD_REPLACE, project);
// View menu -- consider both active file and project tree selection
int32_t selIdx = prjGetSelectedFileIdx();
bool selIsFile = (project && selIdx >= 0 && selIdx < prjFileCount(&sProject));
bool selIsForm = (selIsFile && sProject.files[selIdx].kind == PrjKindFormE);
bool canCode = hasFile || selIsFile;
bool canDesign = hasForm || selIsForm;
wmMenuItemSetEnabled(sWin->menuBar, CMD_VIEW_CODE, canCode);
wmMenuItemSetEnabled(sWin->menuBar, CMD_VIEW_DESIGN, canDesign);
wmMenuItemSetEnabled(sWin->menuBar, CMD_MENU_EDITOR, canDesign);
// Run menu
wmMenuItemSetEnabled(sWin->menuBar, CMD_RUN, canRun);
wmMenuItemSetEnabled(sWin->menuBar, CMD_RUN_NOCMP, project && isIdle && sCachedModule != NULL);
wmMenuItemSetEnabled(sWin->menuBar, CMD_DEBUG, canRun);
wmMenuItemSetEnabled(sWin->menuBar, CMD_STOP, canStop);
wmMenuItemSetEnabled(sWin->menuBar, CMD_STEP_INTO, canRun);
wmMenuItemSetEnabled(sWin->menuBar, CMD_STEP_OVER, isPaused);
wmMenuItemSetEnabled(sWin->menuBar, CMD_STEP_OUT, isPaused);
wmMenuItemSetEnabled(sWin->menuBar, CMD_RUN_TO_CURSOR, isPaused);
wmMenuItemSetEnabled(sWin->menuBar, CMD_TOGGLE_BP, hasFile);
// Toolbar buttons
if (sTbRun) {
wgtSetEnabled(sTbRun, canRun);
}
if (sTbStop) {
wgtSetEnabled(sTbStop, canStop);
}
if (sTbDebug) {
wgtSetEnabled(sTbDebug, canRun);
}
if (sTbStepInto) {
wgtSetEnabled(sTbStepInto, canRun);
}
if (sTbStepOver) {
wgtSetEnabled(sTbStepOver, isPaused);
}
if (sTbStepOut) {
wgtSetEnabled(sTbStepOut, isPaused);
}
if (sTbRunToCur) {
wgtSetEnabled(sTbRunToCur, isPaused);
}
if (sTbCode) {
wgtSetEnabled(sTbCode, canCode);
}
if (sTbDesign) {
wgtSetEnabled(sTbDesign, canDesign);
}
}
// updateWatchWindow -- evaluate watch expressions
static void updateWatchWindow(void) {
if (!sWatchList || !sWatchWin || !sWatchWin->visible) {
return;
}
listRowsReset(&sWatchRows);
int32_t count = (int32_t)arrlen(sWatchExprs);
for (int32_t i = 0; i < count; i++) {
char valBuf[IDE_VALUE_BUF];
valBuf[0] = '\0';
if (sDbgState == DbgPausedE && sVm && sDbgModule) {
BasValueT val;
memset(&val, 0, sizeof(val));
if (lookupWatchVar(sWatchExprs[i], &val)) {
// Simple variable/field/subscript lookup succeeded
formatValue(&val, valBuf, sizeof(valBuf));
} else if (!evalWatchExpr(sWatchExprs[i], valBuf, sizeof(valBuf))) {
snprintf(valBuf, sizeof(valBuf), "<error>");
}
}
listRowsAdd(&sWatchRows, sWatchExprs[i]);
listRowsAdd(&sWatchRows, valBuf);
}
listRowsCommit(&sWatchRows, sWatchList, count);
}
// ============================================================
// Compile-time CtrlName.Member validator
// ============================================================
//
// The IDE (unlike bascomp) has widget DXEs loaded, so wgtGetIface
// returns live interface metadata. Combined with a static scan of
// the project's .frm files (control name -> widget type), we can
// reject typos like GfxCanvas.Boggle or LblStatus.Caphtion at
// compile time instead of letting them surface as runtime errors
// at event-click time. Dynamically-created controls (via
// CreateControl at runtime) aren't in the map; lookupCtrlType
// returns NULL for them and validation is skipped.
// validatorFree -- release a validator context filled during a compile
static void validatorFree(IdeValidatorCtxT *ctx) {
arrfree(ctx->entries);
arrfree(ctx->badTypes);
ctx->entries = NULL;
ctx->badTypes = NULL;
}
static bool validatorIsMethodValid(void *ctx, const char *wgtType, const char *methodName) {
(void)ctx;
if (!wgtType || !methodName) {
return true; // be permissive on malformed input
}
if (basFormRtCommonMethodId(methodName) != BAS_CM_NONE) {
return true;
}
// Drawing methods of forms and PictureBoxes
if ((strcasecmp(wgtType, IDE_FORM_TYPE_NAME) == 0 || strcasecmp(wgtType, BAS_PICTUREBOX_TYPE) == 0) && basFormRtIsDrawMember(methodName, false)) {
return true;
}
// Form-level methods
if (strcasecmp(wgtType, IDE_FORM_TYPE_NAME) == 0) {
return strcasecmp(methodName, "Show") == 0 || strcasecmp(methodName, "Hide") == 0;
}
// Menu items have no methods beyond common
if (strcasecmp(wgtType, IDE_MENU_TYPE_NAME) == 0) {
return false;
}
// Widget-specific methods from the live iface
const char *wgtName = wgtFindByBasName(wgtType);
if (!wgtName) {
return true; // unknown type -- skip validation
}
const WgtIfaceT *iface = wgtGetIface(wgtName);
if (!iface) {
return true;
}
// A known type with no interface methods accepts only the common
// set (already checked above); being permissive here let typos
// like btnGo.Boggle compile.
for (int32_t i = 0; i < iface->methodCount; i++) {
if (strcasecmp(iface->methods[i].name, methodName) == 0) {
return true;
}
}
return false;
}
static bool validatorIsPropValid(void *ctx, const char *wgtType, const char *propName) {
(void)ctx;
if (!wgtType || !propName) {
return true;
}
// Drawing properties of forms and PictureBoxes
if ((strcasecmp(wgtType, IDE_FORM_TYPE_NAME) == 0 || strcasecmp(wgtType, BAS_PICTUREBOX_TYPE) == 0) && basFormRtIsDrawMember(propName, true)) {
return true;
}
// Form-level properties (the runtime's own table)
if (strcasecmp(wgtType, IDE_FORM_TYPE_NAME) == 0) {
return basFormRtFindFormProp(propName) != NULL;
}
// Menu items (the runtime's own table)
if (strcasecmp(wgtType, IDE_MENU_TYPE_NAME) == 0) {
return basFormRtFindMenuProp(propName) != NULL;
}
// Properties every non-menu control accepts (the runtime's own table)
if (basFormRtFindCommonProp(propName)) {
return true;
}
// Widget-specific props from the live iface
const char *wgtName = wgtFindByBasName(wgtType);
if (!wgtName) {
return true;
}
const WgtIfaceT *iface = wgtGetIface(wgtName);
if (!iface) {
return true;
}
// Same reasoning as validatorIsMethodValid: an empty interface
// property table must not turn validation off for the whole type.
return wgtIfaceFindProp(iface, propName) != NULL;
}
// validatorLookupCtrlType -- widget type of ctrlName for the parser's
// member checks, or NULL to skip validation. Resolved the way the
// runtime finds controls: a name declared on the form whose code is being
// compiled (basParserFormScope) wins; any other name is looked up across
// every form and skipped when it has different types on different forms
// (Text1 as TextBox and ListBox) rather than checked against the wrong one.
static const char *validatorLookupCtrlType(void *ctx, const char *ctrlName) {
IdeValidatorCtxT *v = (IdeValidatorCtxT *)ctx;
const char *found = NULL;
bool ambiguous = false;
if (!v || !ctrlName) {
return NULL;
}
const char *scope = v->compiler ? basCompilerFormScope(v->compiler) : "";
for (int32_t i = 0; i < (int32_t)arrlen(v->entries); i++) {
const IdeCtrlMapEntryT *e = &v->entries[i];
if (strcasecmp(e->name, ctrlName) != 0) {
continue;
}
if (scope[0] && strcasecmp(e->formName, scope) == 0) {
return e->wgtType;
}
ambiguous = ambiguous || (found && strcasecmp(found, e->wgtType) != 0);
found = e->wgtType;
}
return ambiguous ? NULL : found;
}
static void validatorOnCtrlBegin(void *ud, const char *typeName, const char *name) {
IdeValidatorCtxT *v = ((IdeFrmScanT *)ud)->validator;
if (!v) {
return;
}
IdeCtrlMapEntryT e;
memset(&e, 0, sizeof(e));
snprintf(e.name, BAS_MAX_IDENT, "%s", name ? name : "");
snprintf(e.wgtType, BAS_MAX_IDENT, "%s", typeName ? typeName : "");
snprintf(e.formName, BAS_MAX_IDENT, "%s", v->currentForm);
arrput(v->entries, e);
// Also flag unknown widget types. wgtFindByBasName returns NULL
// for anything not registered by a .wgt DXE loaded by the IDE.
// Skip internal structural types (they're handled by layout code,
// not widget DXEs).
if (typeName && typeName[0]) {
bool structural = (strcasecmp(typeName, IDE_FORM_TYPE_NAME) == 0 || strcasecmp(typeName, IDE_MENU_TYPE_NAME) == 0);
if (!structural && !wgtFindByBasName(typeName)) {
IdeBadTypeT bad;
memset(&bad, 0, sizeof(bad));
snprintf(bad.ctrlName, BAS_MAX_IDENT, "%s", name ? name : "?");
snprintf(bad.typeName, BAS_MAX_IDENT, "%s", typeName);
snprintf(bad.formName, BAS_MAX_IDENT, "%s", v->currentForm);
arrput(v->badTypes, bad);
}
}
}
static bool validatorOnFormBegin(void *ud, const char *name) {
IdeValidatorCtxT *v = ((IdeFrmScanT *)ud)->validator;
if (!v) {
return true;
}
IdeCtrlMapEntryT e;
memset(&e, 0, sizeof(e));
snprintf(v->currentForm, BAS_MAX_IDENT, "%s", name ? name : "");
snprintf(e.name, BAS_MAX_IDENT, "%s", v->currentForm);
snprintf(e.wgtType, BAS_MAX_IDENT, "%s", IDE_FORM_TYPE_NAME);
snprintf(e.formName, BAS_MAX_IDENT, "%s", v->currentForm);
arrput(v->entries, e);
return true;
}
static void validatorOnMenuBegin(void *ud, const char *name, int32_t level) {
(void)level;
IdeValidatorCtxT *v = ((IdeFrmScanT *)ud)->validator;
if (!v) {
return;
}
IdeCtrlMapEntryT e;
memset(&e, 0, sizeof(e));
snprintf(e.name, BAS_MAX_IDENT, "%s", name ? name : "");
snprintf(e.wgtType, BAS_MAX_IDENT, "%s", IDE_MENU_TYPE_NAME);
snprintf(e.formName, BAS_MAX_IDENT, "%s", v->currentForm);
arrput(v->entries, e);
}
// vmCurProcIdx -- compiled proc the paused VM is in, or -1 at module
// level. Proc bodies carry no end address and module-level code can sit
// after a proc (a later file, form init code), so the frame depth -- not
// the pc -- says whether a proc is executing.
static int32_t vmCurProcIdx(void) {
return sVm->callDepth > 1 ? vmProcIndexForPc(sVm->pc) : -1;
}
// vmProcIndexForPc -- index of the compiled proc whose codeAddr is the
// greatest one <= pc (-1 before every proc). Only meaningful for a pc
// known to be inside a proc (see vmCurProcIdx). Requires sDbgModule.
static int32_t vmProcIndexForPc(int32_t pc) {
int32_t best = -1;
int32_t bestAddr = -1;
for (int32_t i = 0; i < sDbgModule->procCount; i++) {
int32_t addr = sDbgModule->procs[i].codeAddr;
if (addr <= pc && addr > bestAddr) {
bestAddr = addr;
best = i;
}
}
return best;
}
static const char *vmProcNameForPc(int32_t pc) {
int32_t idx = vmProcIndexForPc(pc);
return idx >= 0 ? sDbgModule->procs[idx].name : IDE_MODULE_FRAME;
}
static void watchEditSelected(void) {
if (!sWatchList || !sWatchInput) {
return;
}
int32_t sel = wgtListViewGetSelected(sWatchList);
if (sel < 0 || sel >= (int32_t)arrlen(sWatchExprs)) {
return;
}
// Put expression text into the input box
wgtSetText(sWatchInput, sWatchExprs[sel]);
// Remove from list
free(sWatchExprs[sel]);
arrdel(sWatchExprs, sel);
updateWatchWindow();
// Focus the input box
wgtSetFocused(sWatchInput);
}
static void watchPrintCallback(void *ctx, const char *text, bool newline) {
(void)ctx;
if (text) {
int32_t tl = (int32_t)strlen(text);
if (sWatchPrintLen + tl < (int32_t)sizeof(sWatchPrintBuf) - 1) {
memcpy(sWatchPrintBuf + sWatchPrintLen, text, tl);
sWatchPrintLen += tl;
}
}
if (newline && sWatchPrintLen < (int32_t)sizeof(sWatchPrintBuf) - 1) {
sWatchPrintBuf[sWatchPrintLen++] = '\n';
}
sWatchPrintBuf[sWatchPrintLen] = '\0';
}
// writeProjectFile -- write files[idx].buffer to disk (a NULL buffer is
// an empty file), byte for byte. The text goes to a temporary sibling
// file that platformReplaceFile swaps in only once every write
// succeeded, so a failed save never destroys the copy on disk. Clears
// the modified flags only on success; reports the failure otherwise.
static bool writeProjectFile(int32_t idx) {
PrjFileT *file = &sProject.files[idx];
const char *text = file->buffer ? file->buffer : "";
char fullPath[DVX_MAX_PATH];
char tempPath[DVX_MAX_PATH];
char bakPath[DVX_MAX_PATH];
prjFullPath(&sProject, idx, fullPath, sizeof(fullPath));
bool ok = platformPathSibling(tempPath, sizeof(tempPath), fullPath, PLATFORM_TMP_EXT) && platformPathSibling(bakPath, sizeof(bakPath), fullPath, PLATFORM_BAK_EXT);
if (ok) {
size_t len = strlen(text);
FILE *f = fopen(tempPath, "wb");
ok = (f != NULL);
if (f) {
ok = (fwrite(text, 1, len, f) == len);
ok = (fclose(f) == 0) && ok;
}
// The swap keeps the original on failure (and removes tempPath)
if (ok) {
ok = platformReplaceFile(tempPath, fullPath, bakPath);
} else {
remove(tempPath);
}
}
if (!ok) {
char msg[IDE_MSG_BUF];
snprintf(msg, sizeof(msg), "Could not write %s.", file->path);
ideErrorBox(msg);
return false;
}
file->modified = false;
if (idx == sDesignerFileIdx && sDesigner.form) {
sDesigner.form->dirty = false;
}
return true;
}
int32_t appMain(DxeAppContextT *ctx) {
sCtx = ctx;
sAc = ctx->shellCtx;
// Set help file and context-sensitive F1 handler
snprintf(ctx->helpFile, sizeof(ctx->helpFile), "%s" DVX_PATH_SEP "%s", ctx->appDir, IDE_HELP_FILE);
snprintf(sIdeHelpFile, sizeof(sIdeHelpFile), "%s", ctx->helpFile);
ctx->onHelpQuery = helpQueryHandler;
ctx->helpQueryCtx = NULL;
prjInit(&sProject);
buildWindow();
// Load persisted settings
shellEnsureConfigDir(sCtx);
char prefsPath[DVX_MAX_PATH];
shellConfigPath(sCtx, IDE_PREFS_FILE, prefsPath, sizeof(prefsPath));
sPrefs = prefsLoad(prefsPath);
if (!sPrefs) {
sPrefs = prefsCreate();
prefsSaveAs(sPrefs, prefsPath);
}
if (sWin && sWin->menuBar) {
if (sToolbar) {
bool showTb = prefsGetBool(sPrefs, PREF_SEC_VIEW, PREF_KEY_TOOLBAR, true);
sToolbar->visible = showTb;
wmMenuItemSetChecked(sWin->menuBar, CMD_VIEW_TOOLBAR, showTb);
}
if (sStatusBar) {
bool showSb = prefsGetBool(sPrefs, PREF_SEC_VIEW, PREF_KEY_STATUSBAR, true);
sStatusBar->visible = showSb;
wmMenuItemSetChecked(sWin->menuBar, CMD_VIEW_STATUS, showSb);
}
bool saveOnRun = prefsGetBool(sPrefs, PREF_SEC_RUN, PREF_KEY_SAVE_ON_RUN, true);
wmMenuItemSetChecked(sWin->menuBar, CMD_SAVE_ON_RUN, saveOnRun);
sOutputToLog = prefsGetBool(sPrefs, PREF_SEC_RUN, PREF_KEY_OUTPUT_TO_LOG, false);
wmMenuItemSetChecked(sWin->menuBar, CMD_OUTPUT_TO_LOG, sOutputToLog);
}
// Load recent files list and populate menu
recentLoad();
recentRebuildMenu();
if (sWin) {
dvxFitWindowH(sAc, sWin);
}
updateProjectMenuState();
setStatus("Ready.");
// A project or source file on the command line (a document opened
// through its file type) opens at once.
char arg[DVX_MAX_PATH];
bool quoted = false;
if (dvxNextArg(ctx->args, arg, sizeof(arg), &quoted)) {
openAnyPath(arg);
}
return 0;
}
Reference in a new issue View git blame Copy permalink