Gold Fish 3

home *** CD-ROM | disk | FTP | other *** search

/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1015.lha / Programs / SnoopDos / Source.lha / Source / settings.c < prev next >

Wrap

C/C++ Source or Header | 1994-09-18 | 51.0 KB | 1,907 lines

/* * SETTINGS.C vi:ts=4 * * Copyright (c) Eddy Carroll, September 1994. * * This module handles all the command parsing for tooltypes, command * line options, config files, AREXX, etc. */ #include "system.h" #include "snoopdos.h" extern char Version[]; /* From Snoopdos.c */ extern char CommodityTitle[]; /* From Snoopdos.c */ char ConfigID[] = "<SnoopDos Settings>"; ULONG UpdateFlags; /* Shows what settings were changed */ struct MsgPort *RemoteReplyPort; /* Used when talking to b/g SnoopDos */ /* * Now the result codes returned by our simple command interpreter */ typedef enum { EXEC_FAIL, /* The command failed for some reason */ EXEC_OKAY, /* The command succeeded */ EXEC_UNKNOWN, /* The command wasn't recognised */ EXEC_NOPARAM /* The command was missing a parameter */ } ExecEnum; /* * Now let's define the commands we understand. */ #define CMD_UNKNOWN -1 #define CMD_NOPARAM -2 typedef enum { CMD_END, /* * Options within function requester. Note that these MUST correspond * exactly with the first set of enums in SNOOPDOS.H for GID_???! */ CMD_FINDPORT, CMD_FINDRESIDENT, CMD_FINDSEMAPHORE, CMD_FINDTASK, CMD_LOCKSCREEN, CMD_OPENDEVICE, CMD_OPENFONT, CMD_OPENLIBRARY, CMD_OPENRESOURCE, CMD_READTOOLTYPES, CMD_SENDREXX, CMD_CHANGEDIR, CMD_DELETE, CMD_EXECUTE, CMD_GETVAR, CMD_LOADSEG, CMD_LOCK, CMD_MAKEDIR, CMD_MAKELINK, CMD_OPEN, CMD_RENAME, CMD_RUNCOMMAND, CMD_SETVAR, CMD_DOSSYSTEM, /* CMD_SYSTEM is defined in dos/dosextens.h */ CMD_DUMMY1, CMD_DUMMY2, CMD_DUMMY3, CMD_DUMMY4, CMD_DUMMY5, CMD_ONLYSHOWFAILS, CMD_SHOWCLI, CMD_SHOWFULLPATH, CMD_USEDEVICENAME, CMD_MONITORPACKETS, CMD_MONALLPACKETS, CMD_MONROMCALLS, CMD_IGNORESHELL, #define MAX_BOOL_CMD CMD_IGNORESHELL CMD_MATCHNAME, /* * General commands */ CMD_LOADSETTINGS, CMD_SAVESETTINGS, CMD_LOADDEFSETTINGS, CMD_SAVEDEFSETTINGS, CMD_SETTINGS, CMD_FUNCTIONS, CMD_LANGUAGE, CMD_CLEARBUFFER, CMD_WINDOWWIDTH, CMD_HELP, CMD_COPYWINDOW, CMD_COPYBUFFER, CMD_SAVEWINDOW, CMD_SAVEBUFFER, CMD_SHOW, CMD_HIDE, CMD_OPENFORMAT, CMD_OPENFUNCTION, CMD_OPENSETUP, CMD_CLOSEFORMAT, CMD_CLOSEFUNCTION, CMD_CLOSESETUP, CMD_QUIT, CMD_PAUSE, CMD_UNPAUSE, CMD_DISABLE, CMD_ENABLE, CMD_SINGLESTEP, CMD_OPENLOG, CMD_APPENDLOG, CMD_OPENSERIALLOG, CMD_CLOSELOG, CMD_ADDLOG, CMD_FLUSHLOG, CMD_SCROLLUP, CMD_SCROLLDOWN, CMD_GOTO, /* * General settings */ CMD_PATCHRAMLIB, CMD_STACKLIMIT, CMD_ICONPOS, CMD_SHOWGADGETS, CMD_HIDEGADGETS, CMD_AUTOOPEN, CMD_DISABLEWHENHIDDEN, CMD_SHOWSTATUS, CMD_HIDESTATUS, CMD_CREATEICONS, CMD_TEXTSPACING, CMD_SIMPLEREFRESH, CMD_SMARTREFRESH, CMD_LEFTALIGNED, CMD_RIGHTALIGNED, CMD_ROWQUALIFIER, CMD_MAINPOS, CMD_MAINSIZE, CMD_FUNCPOS, CMD_FORMPOS, CMD_SETPOS, CMD_TASKPRI, CMD_CXPRI, /* * Options within setup requester */ CMD_HIDEMETHOD, CMD_SCREENTYPE, CMD_BUFFERSIZE, CMD_LOGMODE, CMD_FILEIOTYPE, CMD_FORMAT, CMD_LOGFORMAT, CMD_HOTKEY, CMD_SCREENNAME, CMD_LOGNAME, CMD_WINDOWFONT, CMD_BUFFERFONT, NUMCOMMANDS } COMMAND_ID; /* * Now associate a command string with each of these identifiers */ struct Command { short cmdid; /* Command ID */ short changemask; /* Which group of settings will change */ short numparms; /* Min number of parameters (0 or more) */ char *name; /* Command name */ } CommandTable[] = { /* * In alphabetical order, for quick reference */ CMD_ADDLOG, SET_NONE, 1, "AddLog", CMD_APPENDLOG, SET_NONE, 1, "AppendLog", CMD_AUTOOPEN, SET_MAIN, 0, "AutoOpen", CMD_BUFFERFONT, SET_SETUP, 1, "BufferFont", CMD_BUFFERSIZE, SET_SETUP, 1, "BufferSize", CMD_CHANGEDIR, SET_FUNC, 0, "ChangeDir", CMD_CLEARBUFFER, SET_FUNC, 0, "ClearBuffer", CMD_CLOSEFORMAT, SET_NONE, 0, "CloseFormat", CMD_CLOSEFUNCTION, SET_NONE, 0, "CloseFunction", CMD_CLOSELOG, SET_NONE, 0, "CloseLog", CMD_CLOSESETUP, SET_NONE, 0, "CloseSetup", CMD_COPYBUFFER, SET_NONE, 0, "CopyBuffer", CMD_COPYWINDOW, SET_NONE, 0, "CopyWindow", CMD_CREATEICONS, SET_MAIN, 0, "CreateIcons", CMD_HOTKEY, SET_SETUP, 1, "CX_PopKey", CMD_SHOW, SET_NONE, 0, "CX_Popup", CMD_CXPRI, SET_NONE, 1, "CX_Priority", CMD_DELETE, SET_FUNC, 0, "Delete", CMD_DISABLE, SET_NONE, 0, "Disable", CMD_DISABLEWHENHIDDEN, SET_MAIN, 0, "DisableWhenHidden", CMD_ENABLE, SET_NONE, 0, "Enable", CMD_EXECUTE, SET_FUNC, 0, "Execute", CMD_FILEIOTYPE, SET_SETUP, 1, "FileIOType", CMD_FINDPORT, SET_FUNC, 0, "FindPort", CMD_FINDRESIDENT, SET_FUNC, 0, "FindResident", CMD_FINDSEMAPHORE, SET_FUNC, 0, "FindSemaphore", CMD_FINDTASK, SET_FUNC, 0, "FindTask", CMD_FLUSHLOG, SET_NONE, 0, "FlushLog", CMD_FORMAT, SET_SETUP, 1, "Format", CMD_FORMPOS, SET_MAIN, 1, "FormatWindowPos", CMD_FUNCTIONS, SET_FUNC, 1, "Functions", CMD_FUNCPOS, SET_MAIN, 1, "FunctionWindowPos", CMD_GETVAR, SET_FUNC, 0, "GetVar", CMD_GOTO, SET_NONE, 1, "GotoLine", CMD_HELP, SET_NONE, 0, "Help", CMD_HIDE, SET_NONE, 0, "Hide", CMD_HIDEGADGETS, SET_MAIN, 0, "HideGadgets", CMD_HIDEMETHOD, SET_SETUP, 1, "HideMethod", CMD_HIDESTATUS, SET_MAIN, 0, "HideStatus", CMD_HOTKEY, SET_SETUP, 1, "HotKey", CMD_ICONPOS, SET_MAIN, 1, "IconPos", CMD_IGNORESHELL, SET_FUNC, 0, "IgnoreShell", CMD_LANGUAGE, SET_NONE, 1, "Language", CMD_LEFTALIGNED, SET_MAIN, 0, "LeftAligned", CMD_LOADDEFSETTINGS, SET_NONE, 0, "LoadDefSettings", CMD_LOADSEG, SET_FUNC, 0, "LoadSeg", CMD_LOADSETTINGS, SET_NONE, 1, "LoadSettings", CMD_LOCK, SET_FUNC, 0, "Lock", CMD_LOCKSCREEN, SET_FUNC, 0, "LockScreen", CMD_LOGFORMAT, SET_SETUP, 1, "LogFormat", CMD_LOGMODE, SET_SETUP, 1, "LogMode", CMD_LOGNAME, SET_SETUP, 1, "LogName", CMD_MAINPOS, SET_MAIN, 1, "MainWindowPos", CMD_MAINSIZE, SET_MAIN, 1, "MainWindowSize", CMD_MAKEDIR, SET_FUNC, 0, "MakeDir", CMD_MAKELINK, SET_FUNC, 0, "MakeLink", CMD_MATCHNAME, SET_FUNC, 1, "MatchName", CMD_MONITORPACKETS, SET_FUNC, 0, "MonitorPackets", CMD_MONROMCALLS, SET_FUNC, 0, "MonitorROMCalls", CMD_ONLYSHOWFAILS, SET_FUNC, 0, "OnlyShowFails", CMD_OPEN, SET_FUNC, 0, "Open", CMD_OPENDEVICE, SET_FUNC, 0, "OpenDevice", CMD_OPENFONT, SET_FUNC, 0, "OpenFont", CMD_OPENFORMAT, SET_NONE, 0, "OpenFormat", CMD_OPENFUNCTION, SET_NONE, 0, "OpenFunction", CMD_OPENLIBRARY, SET_FUNC, 0, "OpenLibrary", CMD_OPENLOG, SET_NONE, 1, "OpenLog", CMD_OPENRESOURCE, SET_FUNC, 0, "OpenResource", CMD_OPENSERIALLOG, SET_NONE, 0, "OpenSerialLog", CMD_OPENSETUP, SET_NONE, 0, "OpenSetup", CMD_MONALLPACKETS, SET_FUNC, 0, "PacketDebugger", CMD_PATCHRAMLIB, SET_NONE, 0, "PatchRamLib", CMD_PAUSE, SET_NONE, 0, "Pause", CMD_QUIT, SET_NONE, 0, "Quit", CMD_READTOOLTYPES, SET_FUNC, 0, "ReadToolTypes", CMD_RENAME, SET_FUNC, 0, "Rename", CMD_RIGHTALIGNED, SET_MAIN, 0, "RightAligned", CMD_ROWQUALIFIER, SET_MAIN, 1, "RowQualifier", CMD_RUNCOMMAND, SET_FUNC, 0, "RunCommand", CMD_SAVEBUFFER, SET_NONE, 1, "SaveBuffer", CMD_SAVEDEFSETTINGS, SET_NONE, 0, "SaveDefSettings", CMD_SAVESETTINGS, SET_NONE, 1, "SaveSettings", CMD_SAVEWINDOW, SET_NONE, 1, "SaveWindow", CMD_SCREENNAME, SET_SETUP, 1, "ScreenName", CMD_SCREENTYPE, SET_SETUP, 1, "ScreenType", CMD_SCROLLDOWN, SET_NONE, 1, "ScrollDown", CMD_SCROLLUP, SET_NONE, 1, "ScrollUp", CMD_SENDREXX, SET_FUNC, 0, "SendRexx", CMD_SETTINGS, SET_NONE, 1, "Settings", CMD_SETPOS, SET_MAIN, 1, "SetupWindowPos", CMD_SETVAR, SET_FUNC, 0, "SetVar", CMD_SHOW, SET_NONE, 0, "Show", CMD_SHOWCLI, SET_FUNC, 0, "ShowCLI", CMD_SHOWFULLPATH, SET_FUNC, 0, "ShowFullPath", CMD_SHOWGADGETS, SET_MAIN, 0, "ShowGadgets", CMD_SHOWSTATUS, SET_MAIN, 0, "ShowStatus", CMD_SIMPLEREFRESH, SET_MAIN, 0, "SimpleRefresh", CMD_SINGLESTEP, SET_NONE, 0, "SingleStep", CMD_SMARTREFRESH, SET_MAIN, 0, "SmartRefresh", CMD_STACKLIMIT, SET_MAIN, 1, "StackLimit", CMD_DOSSYSTEM, SET_FUNC, 0, "System", CMD_TASKPRI, SET_NONE, 1, "TaskPri", CMD_TEXTSPACING, SET_MAIN, 1, "TextSpacing", CMD_UNPAUSE, SET_NONE, 0, "Unpause", CMD_USEDEVICENAME, SET_FUNC, 0, "UseDeviceNames", CMD_WINDOWFONT, SET_SETUP, 1, "WindowFont", CMD_WINDOWWIDTH, SET_NONE, 1, "WindowWidth", CMD_END, 0, 0, NULL }; #define NUM_CMDNAMES (sizeof(CommandTable) / sizeof(CommandTable[0])) char *CmdNames[NUMCOMMANDS]; /* Map command IDs back to name strings */ char *Names_HideMethod[] = { "Invisible", "Iconify", "ToolsMenu", "None", NULL }; char *Names_ScreenType[] = { "Default", "Front", "Named", NULL }; char *Names_LogMode[] = { "Prompt", "Append", "Overwrite", "SerialPort", NULL }; char *Names_FileIOType[] = { "Automatic", "Immediate", "Buffered", NULL }; char *Names_Functions[] = { "All", "None", "AllDos", "NoDos", "AllSystem", "NoSystem", NULL }; char *Names_RowQualifier[] = { "Ignore", "None", "Shift", "Alt", "Ctrl", "All", NULL }; typedef enum { FUNC_ALL, FUNC_NONE, FUNC_ALLDOS, FUNC_NODOS, FUNC_ALLSYSTEM, FUNC_NOSYSTEM } FuncTypes; /* * InitSettings() * * Initialises variables associated with settings. For now, this * just means the mapping array that maps command IDs to command * names. This makes it easier to write out the configuration file. */ void InitSettings(void) { struct Command *cmd; int i; for (i = 0; i < NUMCOMMANDS; i++) CmdNames[i] = ""; /* Make sure non-cmds initialised to safe value */ for (cmd = CommandTable; cmd->cmdid != CMD_END; cmd++) CmdNames[cmd->cmdid] = cmd->name; } /* * MatchParam(&var, param, keywords) * * Searches the keyword list for a match with param and stores * the result in the given variable. If no match is found, var * is not altered and returns EXEC_FAIL, else returns EXEC_OKAY. */ int MatchParam(unsigned char *var, char *param, char **keywords) { int i; for (i = 0; keywords[i]; i++) { if (stricmp(param, keywords[i]) == 0) { *var = i; return (EXEC_OKAY); } } return (EXEC_FAIL); } /* * ParseFontName(fontspec, fontname, &fontsize) * * Parses the font spec in fontspec, which is of the form * "fontname size" or "fontname.font size" or "fontname.size", * into two parts. * * The bulk of the name (plus a .font suffix) is copied into fontname. * The size of the font is copied into fontsize. In the event of a parse * error, EXEC_FAIL is returned and no alteration is made to fontname * or fontsize. For success, EXEC_OKAY is returned. * * Note that the contents of the string pointed to by fontspec may be * altered. If fontspec is "default" then a fontsize of 0 is returned * to indicate that SnoopDos should use the system default fonts. */ int ParseFontName(char *fontspec, char *fontname, USHORT *fontsize) { char *p; int size; /* * First, see if we can find a dot specifier. Anything before * the dot is a font name. */ if (stricmp(fontspec, "default") == 0) { strcpy(fontname, fontspec); *fontsize = 0; return (EXEC_OKAY); } p = strchr(fontspec, '.'); if (p) { *p++ = '\0'; if (strnicmp(p, "font", 4) == 0) p += 4; } else { p = strchr(fontspec, ' '); if (!p) return (EXEC_FAIL); *p++ = '\0'; } while (*p == ' ' || *p == '.') p++; size = atoi(p); if (size == 0) return (EXEC_FAIL); strcpy(fontname, fontspec); strcat(fontname, ".font"); *fontsize = size; return (EXEC_OKAY); } /* * ParseTwoNums(param, &num1, &num2) * * Parses the given param string, assumed to be in the form "x1,x2" * and stores the two numbers in the given variables. If either number * is invalid, then no change is made to either number and EXEC_FAIL * is returned, else EXEC_OKAY is returned. * * The string pointed to by param may be altered. */ int ParseTwoNums(char *param, WORD *num1, WORD *num2) { char *p; p = strchr(param, ','); if (!p) return (EXEC_FAIL); *p++ = '\0'; while (*p == ' ') p++; if (*param < '-' || *param > '9' || *p < '-' || *p > '9') return (EXEC_FAIL); *num1 = atoi(param); *num2 = atoi(p); return (EXEC_OKAY); } /* * cid = ParseCommand(cmdline, cmdname, param, &boolvalue, &cmd) * * Copies the cmdline into two separate strings, one for the * command name and one for the parameters. Bool is initalised * to 0 or 1, according to the default value of the parameter * (1 if Yes,True,On, 0 if No, False, Off, or if the command * is prefixed by the word No). * * cmd points to the command structure for this command. * * cid is the command ID that matches the command, CMD_END for * a null command, CMD_UNKNOWN for an unrecognised command, * and CMD_NOPARAM for a known command with too few parameters. * If CMD_NOPARAM is returned, cmdname and &cmd will be initialised * to the command that was matched. * */ int ParseCommand(char *cmdline, char *cmdname, char *param, int *boolvalue, struct Command **pcmd) { struct Command *cmd; int cid; char *p; char *q; if (!cmdline) return (CMD_END); /* * First, copy just the command header */ for (p = cmdline; *p == ' ' || *p == '\t'; p++) ; q = cmdname; while (*p && *p != ';' && *p != '=' && *p != ' ' && *p != '\t' && *p != '\n') *q++ = *p++; *q = '\0'; if (!*cmdname) return (CMD_END); /* Skip over blank lines and comments */ /* * Now skip over any whitespace until we find the next parameter */ while (*p == ' ' || *p == '=' || *p == '\t' || *p == '\n') p++; q = param; if (*p == '\"') { /* * Got a quoted string .. copy everything inside the quotes */ p++; while (*p && *p != '\n' && *p != '\"') *q++ = *p++; *q = '\0'; } else { /* * Not a quoted string .. copy everything to end of line * or semicolon, excluding any trailing spaces. */ while (*p && *p != '\n' && *p != ';') *q++ = *p++; while (--q >= param && (*q == ' ' || *q == '\n' || *q == '\t')) ; *++q = '\0'; if (q == param) q = NULL; } /* * Finally, if we got no specific parameter, check if the * command beings with "No" -- if so, then assume the * parameter is boolean instead and set accordingly */ *boolvalue = 1; if (!q) { if (strnicmp(cmdname, "no", 2) == 0) { *boolvalue = 0; cmdname += 2; } } else { if ( stricmp(param, "off") == 0 || stricmp(param, "no") == 0 || stricmp(param, "0") == 0) { *boolvalue = 0; } } /* * Now locate identifier which matches command */ for (cmd = CommandTable; cmd->cmdid != CMD_END; cmd++) if (stricmp(cmd->name, cmdname) == 0) break; cid = cmd->cmdid; if (cid == CMD_END) return (CMD_UNKNOWN); *pcmd = cmd; if (cmd->numparms > 0 && !q) return (CMD_NOPARAM); return (cid); } /* * ExecCommand(cmd, mode, set) * * Interprets the given command and executes it. cmd points to the * command string which is one of the following forms: * * command * command=value * setting * nosetting * setting=on * setting=off * * The "setting" commands are used to toggle the various boolean * settings that can be accessed through the requesters. * * mode is the place where the setting occurs. This will be one of * MODE_REXX, MODE_SETTINGS, MODE_CMDLINE or MODE_TOOLTYPE, depending * on where the command being executed originated from. In some cases, * this affects how the command is executed. * * set is a pointer to a copy of the current settings (NOT the actual * settings!) This copy is updated to reflect the changes. The intention * is that you can call ExecCommand() multiple times with the same * copy, and then finally call InstallSettings() at the end to make * the new settings take effect. This way, only a single update * needs to be done for an entire configuration file. * * The global UpdateFlags should be initialised to 0 before the first * call, and then passed to InstallSettings() at the end -- it will * contain the appropriate combination of SET_??? flags to indicate * what settings actually changed. * * Returns EXEC_OKAY for success, EXEC_FAIL for failure, or EXEC_UNKNOWN * if the command couldn't be understood. */ int ExecCommand(char *cmdline, int mode, Settings *set) { APTR oldwinptr = *TaskWindowPtr; struct Command *cmd; /* Pointer to command */ char cmdname[100]; /* Storage area for command */ char parambuf[100]; /* Storage for parameters */ char *param; /* Pointer to parameters */ int boolvalue; /* for settings: either 1 or 0 */ int success = EXEC_OKAY; /* Default return value */ int cid; int val; cid = ParseCommand(cmdline, cmdname, parambuf, &boolvalue, &cmd); switch (cid) { case CMD_END: return (EXEC_OKAY); case CMD_UNKNOWN: return (EXEC_UNKNOWN); case CMD_NOPARAM: return (EXEC_NOPARAM); } UpdateFlags |= cmd->changemask; param = parambuf; /* * Okay, got ourselves a valid command. Now interpret it. */ if (cid <= MAX_BOOL_CMD) { /* * Got a boolean option to update */ set->Func.Opts[cid] = boolvalue; return (EXEC_OKAY); } switch (cid) { case CMD_LANGUAGE: strcpy(Language, param); break; case CMD_SETTINGS: strcpy(DefaultConfigName, param); strcpy(ConfigFileName, param); break; case CMD_LOADDEFSETTINGS: success = LoadConfig(DefaultConfigName, mode, set); break; case CMD_SAVEDEFSETTINGS: success = SaveConfig(DefaultConfigName, SAVE_NOICON); break; case CMD_LOADSETTINGS: success = LoadConfig(param, mode, set); break; case CMD_SAVESETTINGS: success = SaveConfig(param, SAVE_ICON); break; case CMD_HELP: { char helpmsg[100]; /* * We install the current settings first, to ensure * that things like the default public screen are * correctly set up before we open help. */ if (UpdateFlags) { InstallSettings(set, UpdateFlags); UpdateFlags = 0; *set = CurSettings; } if (*param) mysprintf(helpmsg, "LINK %s\n", param); else strcpy(helpmsg, MSG(MSG_LINK_MAIN)); ShowAGuide(helpmsg); break; } case CMD_SHOWGADGETS: set->ShowGadgets = boolvalue; break; case CMD_HIDEGADGETS: set->ShowGadgets = !boolvalue; break; case CMD_SHOWSTATUS: set->ShowStatus = boolvalue; break; case CMD_HIDESTATUS: set->ShowStatus = !boolvalue; break; case CMD_AUTOOPEN: set->AutoOpenMain = boolvalue; break; case CMD_DISABLEWHENHIDDEN: set->DisableWhenHidden = boolvalue; break; case CMD_CREATEICONS: set->MakeIcons = boolvalue; break; case CMD_SIMPLEREFRESH: set->SimpleRefresh = boolvalue; break; case CMD_SMARTREFRESH: set->SimpleRefresh = !boolvalue; break; case CMD_LEFTALIGNED: set->RightAlign = !boolvalue; break; case CMD_RIGHTALIGNED: set->RightAlign = boolvalue; break; case CMD_TEXTSPACING: val = *param - '0'; if (val < 0 || val > 2) return (EXEC_FAIL); set->TextSpacing = val; break; case CMD_ROWQUALIFIER: return MatchParam(&set->RowQualifier, param, Names_RowQualifier); case CMD_FUNCTIONS: /* * Set or clear the function table according to the * parameters */ { unsigned char functype; int low = FIRST_SYS_GADGET; int high = LAST_DOS_GADGET; int bool = 1; int i; if (MatchParam(&functype, param, Names_Functions) == EXEC_FAIL) return (EXEC_FAIL); switch (functype) { case FUNC_ALL: break; /* Use defaults */ case FUNC_NONE: bool = 0; break; case FUNC_ALLDOS: low = FIRST_DOS_GADGET; break; case FUNC_NODOS: low = FIRST_DOS_GADGET; bool = 0; break; case FUNC_ALLSYSTEM: high = LAST_SYS_GADGET; break; case FUNC_NOSYSTEM: high = LAST_SYS_GADGET; bool = 0; break; } for (i = low; i <= high; i++) set->Func.Opts[i] = bool; break; } case CMD_COPYWINDOW: DisableAllWindows(); success = SaveBuffer(SAVEBUF_WINDOW, SAVEBUF_CLIPBOARD, SAVEBUF_OVERWRITE); EnableAllWindows(); break; /* Fallthrough */ case CMD_COPYBUFFER: DisableAllWindows(); success = SaveBuffer(SAVEBUF_ALL, SAVEBUF_CLIPBOARD, SAVEBUF_OVERWRITE); EnableAllWindows(); break; case CMD_SAVEWINDOW: DisableAllWindows(); success = SaveBuffer(SAVEBUF_WINDOW, param, SAVEBUF_OVERWRITE); EnableAllWindows(); break; case CMD_SAVEBUFFER: DisableAllWindows(); success = SaveBuffer(SAVEBUF_ALL, param, SAVEBUF_OVERWRITE); EnableAllWindows(); break; case CMD_CXPRI: CommodityPriority = atoi(param); if (HotKeyActive) { /* * Reinstall commodity to take advantage of the * updated priority */ InstallHotKey(CurSettings.Setup.HotKey); } break; case CMD_ICONPOS: success = ParseTwoNums(param, &set->IconPosLeft, &set->IconPosTop); break; case CMD_HIDE: case CMD_SHOW: /* * Install all settings modified so far */ if (UpdateFlags) { InstallSettings(set, UpdateFlags); UpdateFlags = 0; *set = CurSettings; } /* * We allow both of these so that NOSHOW and NOHIDE * will also work, as well as SHOW=YES and HIDE=NO * In particular, CX_Popup=Yes and CX_Popup=No will * work as expected. */ if ((boolvalue && cid == CMD_SHOW) || (!boolvalue && cid == CMD_HIDE)) { /* * Showing SnoopDos. Install all settings changed * so far, so that they'll be in effect when the window * is open (especially font changes) */ success = ShowSnoopDos(); HideOnStartup = 0; } else { HideSnoopDos(); HideOnStartup = 1; } break; case CMD_OPENFORMAT: case CMD_OPENFUNCTION: case CMD_OPENSETUP: /* * Install the current settings, so that they take * effect before the window is opened (font changes * and the like). */ if (UpdateFlags) { InstallSettings(set, UpdateFlags); UpdateFlags = 0; *set = CurSettings; } switch (cid) { case CMD_OPENFORMAT: success = OpenFormatWindow(); break; case CMD_OPENFUNCTION: success = OpenFunctionWindow(); break; case CMD_OPENSETUP: success = OpenSettingsWindow(); break; } break; case CMD_CLOSEFORMAT: CloseFormatWindow(); break; case CMD_CLOSEFUNCTION: CloseFunctionWindow(); break; case CMD_CLOSESETUP: CloseSettingsWindow(); break; case CMD_QUIT: if (mode != MODE_SETTINGS) QuitFlag = 1; else success = EXEC_FAIL; break; case CMD_SINGLESTEP: SingleStep(); break; case CMD_PAUSE: case CMD_DISABLE: case CMD_UNPAUSE: case CMD_ENABLE: /* * We treat these four together so we can account for * all the different boolean verisons (Disable=Yes, * Enable=No, UnPause=Yes, Pause=No, etc.) */ if ((cid == CMD_DISABLE && boolvalue) || (cid == CMD_ENABLE && !boolvalue)) { SetMonitorMode(MONITOR_DISABLED); } else if ((cid == CMD_PAUSE && boolvalue) || (cid == CMD_UNPAUSE && !boolvalue)) { SetMonitorMode(MONITOR_PAUSED); } else SetMonitorMode(MONITOR_NORMAL); break; case CMD_OPENLOG: case CMD_APPENDLOG: /* * For these two, we make any current settings take effect, * so that things like default file buffering mode will be * activated. */ if (UpdateFlags) { InstallSettings(set, UpdateFlags); UpdateFlags = 0; *set = CurSettings; } if (cid == CMD_OPENLOG) success = OpenLog(LOGMODE_OVERWRITE, param); else success = OpenLog(LOGMODE_APPEND, param); break; case CMD_OPENSERIALLOG: success = OpenLog(LOGMODE_SERIALPORT, param); break; case CMD_CLOSELOG: CloseLog(); break; case CMD_ADDLOG: /* * Output a user comment to the specified logfile */ strcat(param, "\n"); WriteLog(param); break; case CMD_FLUSHLOG: /* * Flush the current contents of the log */ WriteLog(NULL); break; case CMD_HIDEMETHOD: return MatchParam(&set->Setup.HideMethod, param, Names_HideMethod); case CMD_SCREENTYPE: return MatchParam(&set->Setup.ScreenType, param, Names_ScreenType); case CMD_LOGMODE: return MatchParam(&set->Setup.LogMode, param, Names_LogMode); case CMD_FILEIOTYPE: return MatchParam(&set->Setup.FileIOType, param, Names_FileIOType); case CMD_BUFFERSIZE: val = atoi(param); if (val > 1) set->Setup.BufferSize = val; break; case CMD_WINDOWWIDTH: SetMainWindowWidth(atoi(param)); /* 0 is supported */ break; case CMD_STACKLIMIT: if (*param < '0' || *param > '9') return (EXEC_FAIL); set->StackLimit = atoi(param); break; case CMD_PATCHRAMLIB: break; /* Actually handled in ParseStartup */ case CMD_FORMAT: strcpy(set->Setup.BufferFormat, param); break; case CMD_LOGFORMAT: if (stricmp(param, "none") == 0) *param = '\0'; strcpy(set->Setup.LogfileFormat, param); break; break; case CMD_HOTKEY: strcpy(set->Setup.HotKey, param); break; case CMD_SCREENNAME: strcpy(set->Setup.ScreenName, param); break; case CMD_LOGNAME: strcpy(set->Setup.LogFile, param); *TaskWindowPtr = (APTR)-1; if (IsFileSystem(set->Setup.LogFile)) strcpy(ChosenLogName, param); *TaskWindowPtr = oldwinptr; break; case CMD_MATCHNAME: strcpy(set->Func.Pattern, param); break; case CMD_WINDOWFONT: return ParseFontName(param, set->Setup.WindowFont, &set->Setup.WinFontSize); case CMD_BUFFERFONT: return ParseFontName(param, set->Setup.BufferFont, &set->Setup.BufFontSize); case CMD_MAINSIZE: success = ParseTwoNums(param, &set->MainWinWidth, &set->MainWinHeight); if (success && mode != MODE_SETTINGS && MainWindow) SizeWindow(MainWindow, set->MainWinWidth - MainWindow->Width, set->MainWinHeight- MainWindow->Height); break; case CMD_MAINPOS: success = ParseTwoNums(param, &set->MainWinLeft, &set->MainWinTop); if (success && mode != MODE_SETTINGS && MainWindow) MoveWindow(MainWindow, set->MainWinLeft - MainWindow->LeftEdge, set->MainWinTop - MainWindow->TopEdge); break; case CMD_FORMPOS: success = ParseTwoNums(param, &set->FormWinLeft, &set->FormWinTop); if (success && mode != MODE_SETTINGS && FormWindow) MoveWindow(FormWindow, set->FormWinLeft - FormWindow->LeftEdge, set->FormWinTop - FormWindow->TopEdge); break; case CMD_FUNCPOS: success = ParseTwoNums(param, &set->FuncWinLeft, &set->FuncWinTop); if (success && mode != MODE_SETTINGS && FuncWindow) MoveWindow(FuncWindow, set->FuncWinLeft - FuncWindow->LeftEdge, set->FuncWinTop - FuncWindow->TopEdge); break; case CMD_SETPOS: success = ParseTwoNums(param, &set->SetupWinLeft, &set->SetupWinTop); if (success && mode != MODE_SETTINGS && SetWindow) MoveWindow(SetWindow, set->SetupWinLeft - SetWindow->LeftEdge, set->SetupWinTop - SetWindow->TopEdge); break; case CMD_TASKPRI: val = atoi(param); if ((val == 0 && *param != '0') || val < -20 || val > 20) return (EXEC_FAIL); SetTaskPri(SysBase->ThisTask, val); if (MainWindow) SetMenuOptions(); break; case CMD_CLEARBUFFER: ClearWindowBuffer(); break; case CMD_GOTO: val = atoi(param); if (val != 0) { val += BaseSeq; /* Get real start position */ if (val > TopSeq) DoArrowScrolling(GID_DOWNARROW, val - TopSeq); else DoArrowScrolling(GID_UPARROW, TopSeq - val); } else success = EXEC_FAIL; break; case CMD_SCROLLUP: case CMD_SCROLLDOWN: val = atoi(param); if (!val) val = 1; if (cid == CMD_SCROLLUP) DoArrowScrolling(GID_UPARROW, val); else DoArrowScrolling(GID_DOWNARROW, val); break; } return (success ? EXEC_OKAY : EXEC_FAIL); } /* * GetFontDesc(fontdesc, fontname, size) * * Builds a a string from the supplied fontname and size and stores * it in fontdesc. Returns a pointer to the new string. * * For example, name="courier.font" and size=13 will return the * string "courier 13"; * * In the event that the fontname is invalid, the string "Default" * is returned instead. */ char *GetFontDesc(char *fontdesc, char *fontname, int size) { char *p; if (!fontname || !*fontname) return ("Default"); strcpy(fontdesc, fontname); p = strchr(fontdesc, '.'); if (!p) p = fontdesc + strlen(fontdesc); mysprintf(p, " %ld", size); return (fontdesc); } /* * SaveConfig(filename, saveicon) * * Writes the current configuration to the named disk file. Returns * 1 for success, 0 for failure. * * saveicon is SAVE_ICON if an icon should be saved and CreateIcos * is true, or SAVE_NOICON if an icon should never be saved. */ int SaveConfig(char *filename, int saveicon) { char tempdesc[MAX_SHORT_LEN]; SetupSettings *setup = &CurSettings.Setup; BPTR file; int i; mysprintf(StatusLineText, MSG(MSG_STATUS_SAVESET), filename); ShowStatus(StatusLineText); DisableAllWindows(); RecordWindowSizes(); file = Open(filename, MODE_NEWFILE); if (!file) { EnableAllWindows(); UpdateStatus(); return (0); } FPrintf(file, "%s\n;\n; %s\n;\n; Settings file\n;\n", ConfigID, Version); #define NM(x) CmdNames[CMD_##x] #define PF1(s,p) FPrintf(file, s, p) #define PF2(s,p1,p2) FPrintf(file, s, p1, p2) /* * First of all, write out the function settings */ for (i = 1; i <= MAX_BOOL_CMD; i++) { if (*CmdNames[i]) { if (CurSettings.Func.Opts[i]) PF1("%s\n", CmdNames[i]); else PF1("No%s\n", CmdNames[i]); } } /* * Now write out all the variable settings */ PF2(";\n%s=\"%s\"\n",NM(MATCHNAME), CurSettings.Func.Pattern); PF2("%s=%s\n", NM(HIDEMETHOD), Names_HideMethod[setup->HideMethod]); PF2("%s=%s\n", NM(SCREENTYPE), Names_ScreenType[setup->ScreenType]); PF2("%s=%s\n", NM(LOGMODE), Names_LogMode[setup->LogMode]); PF2("%s=%s\n", NM(FILEIOTYPE), Names_FileIOType[setup->FileIOType]); PF2("%s=%ld\n", NM(BUFFERSIZE), setup->BufferSize); PF2("%s=\"%s\"\n", NM(HOTKEY), setup->HotKey); PF2("%s=\"%s\"\n", NM(SCREENNAME), setup->ScreenName); PF2("%s=\"%s\"\n", NM(LOGNAME), setup->LogFile); PF2("%s=\"%s\"\n", NM(WINDOWFONT), GetFontDesc(tempdesc, setup->WindowFont, setup->WinFontSize)); PF2("%s=\"%s\"\n", NM(BUFFERFONT), GetFontDesc(tempdesc, setup->BufferFont, setup->BufFontSize)); PF2("%s=\"%s\"\n", NM(FORMAT), setup->BufferFormat); PF2("%s=\"%s\"\n", NM(LOGFORMAT), setup->LogfileFormat); PF2("%s=%ld\n", NM(TEXTSPACING), CurSettings.TextSpacing); PF1("%s\n", CurSettings.SimpleRefresh ? NM(SIMPLEREFRESH) : NM(SMARTREFRESH)); PF1("%s\n", CurSettings.RightAlign ? NM(RIGHTALIGNED) : NM(LEFTALIGNED)); PF2("%s=%s\n", NM(ROWQUALIFIER), Names_RowQualifier[RowQual]); PF1("%s\n", CurSettings.ShowStatus ? NM(SHOWSTATUS) : NM(HIDESTATUS)); PF1("%s\n", CurSettings.ShowGadgets ? NM(SHOWGADGETS) : NM(HIDEGADGETS)); PF2("%s%s\n", (AutoOpen ? "" : "No"), NM(AUTOOPEN)); PF2("%s%s\n", (DisableOnHide ? "" : "No"), NM(DISABLEWHENHIDDEN)); PF2("%s%s\n", (CurSettings.MakeIcons ? "" : "No"), NM(CREATEICONS)); FPrintf(file, "%s=%ld,%ld\n", NM(MAINPOS), CurSettings.MainWinLeft, CurSettings.MainWinTop); FPrintf(file, "%s=%ld,%ld\n", NM(MAINSIZE), CurSettings.MainWinWidth, CurSettings.MainWinHeight); FPrintf(file, "%s=%ld,%ld\n", NM(FORMPOS), CurSettings.FormWinLeft, CurSettings.FormWinTop); FPrintf(file, "%s=%ld,%ld\n", NM(FUNCPOS), CurSettings.FuncWinLeft, CurSettings.FuncWinTop); FPrintf(file, "%s=%ld,%ld\n", NM(SETPOS), CurSettings.SetupWinLeft, CurSettings.SetupWinTop); FPrintf(file, "%s=%ld,%ld\n", NM(ICONPOS), CurSettings.IconPosLeft, CurSettings.IconPosTop); FPrintf(file, "%s=%ld\n", NM(STACKLIMIT), CurSettings.StackLimit); FPrintf(file, "%s=%ld\n", NM(TASKPRI), SysBase->ThisTask->tc_Node.ln_Pri); Close(file); if (CreateIcons && saveicon != SAVE_NOICON) WriteIcon(filename); EnableAllWindows(); UpdateStatus(); GotLastSaved = 1; /* Indicate "Last Saved" can now be performed */ return (1); } /* * LoadConfig(filename, mode, set) * * Attempts to load the specified configuration file into memory. * Returns 1 for success (having executed all the commands, and updated * windows etc. as appropriate) or 0 for failure (couldn't open file). * * To prevent infinite loops, we only allow three levels of nested * configuration files (i.e. a maximum of three recursive calls to * LoadConfig) * * Normally, set is NULL. If non-NULL, then it represents a set * of settings currently being updated. In this case, LoadConfig * doesn't actually install the new settings when it's finished * reading them, it merely updates the values in set with the * new values and relies on the caller to set them later on. * * The mode parameter indicates how we are being called -- from * the CLI, Workbench, ARexx or internally. This is used to determine * how error messages should be displayed (currently, messages will * only be displayed in a CLI window). * * New: we now support reading from an interactive file (CON:....) * This allows the user to open a command window by trying to load * a suitable CON: specification. Commands will be executed as soon * as they arrive, and settings will be updated immediately. */ int LoadConfig(char *filename, int mode, Settings *set) { static int nestcount; Settings newsettings; Settings *myset; int interactive; int linenum = 0; int retvalue = EXEC_FAIL; BPTR errorfile = NULL; BPTR file; char linebuf[200]; if (set == NULL) { myset = &newsettings; *myset = CurSettings; UpdateFlags = 0; } else { myset = set; } if (nestcount >= MAX_LOAD_NESTING) return (EXEC_FAIL); nestcount++; DisableAllWindows(); mysprintf(StatusLineText, MSG(MSG_STATUS_LOADSET), filename); ShowStatus(StatusLineText); file = Open(filename, MODE_OLDFILE); if (!file) goto abort_load; /* * If we're executing this command from a CLI, then display * error messages in the CLI window, else don't display them * at all. */ if (mode == MODE_CMDLINE) errorfile = Output(); interactive = IsInteractive(file); if (interactive) { errorfile = file; /* Send errors to the command window */ } else { /* * If we're not loading settings from an interactive * window, then check that the first line of the file * contains the settings file identifier */ if (!FGets(file, linebuf, 199) || strnicmp(linebuf, ConfigID, strlen(ConfigID)) != 0) { goto abort_load; } linenum++; } /* * Now read in lines from the command file and execute them. */ if (interactive) { FPrintf(errorfile, "%s%s", MSG(MSG_CMD_HEADER), MSG(MSG_CMD_PROMPT)); Flush(errorfile); } while (FGets(file, linebuf, 199) != NULL) { char *cmdline = linebuf; char *q; int result; linenum++; for (q = cmdline; *q && *q != '\n'; q++) ; if (*q) *q++ = '\0'; while (*cmdline == ' ' || *cmdline == '\t') cmdline++; if (!*cmdline || *cmdline == ';') continue; /* Skip over lines with no text on them */ if (stricmp(cmdline, "exit") == 0) /* Skip rest of file */ break; if (interactive && *cmdline == '?') { ShowCommands(errorfile); goto show_prompt; } /* * Now execute the command ... interactive commands are * executed internally, to allow QUIT to be executed. */ result = ExecCommand(cmdline, (interactive ? MODE_INTERNAL : MODE_SETTINGS), myset); if (QuitFlag) break; if (result == EXEC_OKAY) { if (interactive) { /* * For interactive commands, we update the * settings at each step along the way so * the user can see them taking effect. */ InstallSettings(myset, UpdateFlags); UpdateFlags = 0; *myset = CurSettings; } } else if (errorfile) { int msgid; switch (result) { case EXEC_UNKNOWN: msgid = MSG_CMD_UNKNOWN; break; case EXEC_FAIL: msgid = MSG_CMD_FAIL; break; case EXEC_NOPARAM: msgid = MSG_CMD_NOPARAM; break; } if (!interactive) FPrintf(errorfile, "%s, line %ld: ", filename, linenum); FPrintf(errorfile, MSG(msgid), cmdline); } show_prompt: if (interactive) { FPrintf(errorfile, MSG(MSG_CMD_PROMPT)); Flush(errorfile); } } retvalue = EXEC_OKAY; if (interactive) { /* * For interactive use, we clear any CTRL-C typed by * the user during usage; this avoids confusion since * the CTRL-C wouldn't have taken effect immediately * anyway. */ CheckSignal(SIGBREAKF_CTRL_C); } /* * If we just successfully loaded a file, it was probably the * defaults file, so enable the "Last Saved" menu option (if it's * not enabled, then it doesn't try to load a file since there was * no file ever saved). */ GotLastSaved = 1; abort_load: if (file) Close(file); nestcount--; if (set == NULL) InstallSettings(myset, UpdateFlags); UpdateStatus(); EnableAllWindows(); return (retvalue); } /* * InitRexxPort * * Attempts to create SnoopDos's public port and initialise SnoopPort * and RexxPortMask accordingly. If the port already exists, still * returns TRUE but SnoopPort will be NULL. * * If we can't create the port for some reason, returns FALSE. */ int InitRexxPort(void) { struct MsgPort *port; Forbid(); port = FindPort(PORT_NAME); if (!port) { SnoopPort = CreateMsgPort(); if (!SnoopPort) { Permit(); return (FALSE); } SnoopPort->mp_Node.ln_Name = PORT_NAME; SnoopPort->mp_Node.ln_Pri = 1; /* Speed up searches */ AddPort(SnoopPort); RexxPortMask = 1 << SnoopPort->mp_SigBit; } Permit(); return (TRUE); } /* * CleanupRexxPort() * * Cleans up our SnoopDos port -- removes it from the public port * list, and then replies to any messages it has outstanding. Call * before exiting. */ void CleanupRexxPort(void) { if (SnoopPort) { struct RexxMsg *msg; Forbid(); RemPort(SnoopPort); while ((msg = (struct RexxMsg *)GetMsg(SnoopPort)) != NULL) { msg->rm_Result1 = RC_FATAL; msg->rm_Result2 = NULL; ReplyMsg(msg); } Permit(); DeleteMsgPort(SnoopPort); SnoopPort = NULL; } if (RemoteReplyPort) { DeleteMsgPort(RemoteReplyPort); RemoteReplyPort = NULL; } } /* * HandleRexxMsgs() * * Handles any new messages at our Rexx port */ void HandleRexxMsgs(void) { Settings newsettings = CurSettings; struct RexxMsg *msg; UpdateFlags = 0; while ((msg = (struct RexxMsg *)GetMsg(SnoopPort)) != NULL) { msg->rm_Result1 = RC_OK; msg->rm_Result2 = NULL; if ((msg->rm_Action & RXCODEMASK) == RXCOMM) { /* * Got a valid ARexx message, now process it */ switch (ExecCommand(msg->rm_Args[0], MODE_REXX, &newsettings)) { /* * See include:rexx/errors.h for the meanings of * these Rexx return codes */ case EXEC_NOPARAM: msg->rm_Result1 = 10; break; case EXEC_FAIL: msg->rm_Result1 = 20; break; case EXEC_UNKNOWN: msg->rm_Result1 = 30; break; } } ReplyMsg(msg); } InstallSettings(&newsettings, UpdateFlags); } /* * SendRemote(cmdline, mode) * * Sends a command to a remote copy of SnoopDos running in the * background. The mode is MODE_CMDLINE or MODE_TOOLTYPE. The * difference is that for MODE_TOOLYPE, HIDE commands are ignored. * * In both cases, the command is first checked against the command * table to make sure it's valid. If it's invalid, then if the mode * is MODE_CMDLINE, an appropriate error message is printed. */ void SendRemote(char *cmdline, int mode) { struct Command *cmd; struct MsgPort *ourport; char cmdname[100]; char param[100]; int boolvalue; int cid; cid = ParseCommand(cmdline, cmdname, param, &boolvalue, &cmd); switch (cid) { case CMD_UNKNOWN: if (mode == MODE_CMDLINE) Printf(MSG(MSG_ERROR_CLI_UNKNOWN), cmdline); return; case CMD_NOPARAM: if (mode == MODE_CMDLINE) Printf(MSG(MSG_ERROR_CLI_NOPARAM), cmdline); return; case CMD_HIDE: /* * Don't send a HIDE command to the current SnoopDos if * it was in an icon's tooltypes */ if (mode == MODE_TOOLTYPE) return; break; case CMD_END: return; } /* * Got a command that's okay to send. Now locate SnoopDos port * and send it. We have to locate the port each time, in case * the user quits the background copy suddenly. */ if (!RemoteReplyPort) { RemoteReplyPort = CreateMsgPort(); if (!RemoteReplyPort) return; } Forbid(); ourport = FindPort(PORT_NAME); if (ourport) { struct RexxMsg msg; msg.rm_Action = RXCOMM; msg.rm_Args[0] = cmdline; msg.rm_Node.mn_ReplyPort = RemoteReplyPort; PutMsg(ourport, &msg); WaitPort(RemoteReplyPort); GetMsg(RemoteReplyPort); Permit(); if (mode == MODE_CMDLINE && msg.rm_Result1 >= RC_ERROR) Printf(MSG(MSG_ERROR_CLI_FAILED), cmdline); } else Permit(); } /* * ShowCommands(file) * * Prints a neatly formatted list of recognised commands to * the specified output file. */ void ShowCommands(BPTR file) { int i; int numrows = (NUM_CMDNAMES + 3) / 4; FPrintf(file, MSG(MSG_CLI_HELPBANNER)); for (i = 0; i < numrows; i++) { int j; if (CheckSignal(SIGBREAKF_CTRL_C)) { FPrintf(file, "^C\n"); break; } for (j = i; j < NUM_CMDNAMES; j += numrows) { char *pmsg = (CommandTable[j].numparms > 0) ? "*" : " "; char *cmsg = CommandTable[j].name; if (j < (NUM_CMDNAMES - numrows)) FPrintf(file, "%s%-18s", pmsg, cmsg); else FPrintf(file, "%s%s", pmsg, cmsg); } FPrintf(file, "\n"); } } /* * ParseStartupOpts() * * Handles the startup options, either on the command line or via * the tooltypes, and sets the default options accordingly. * * We handle a couple of options specially (LOCALE and SETTINGS) since * these must be set before doing anything else at all (we can't even * print a meaningful error message without LOCALE, for example.) * * After those, we read in our configuration file from disk, and then * parse the remaining items which can thus override any of the options * specified in the config file. This applies even to tooltypes, so if * an icon has a certain option hardcoded into it, this will always * override a config file with the same option set. * * Normally, CLI and Tooltype options are only used to control things * like opening a default logfile, set the Commodity priority or config * file name, making SnoopDos start in the background, or automatically * opening one or more windows. * * As a final step, if we spot that we are not the main instance of * SnoopDos, we send all the new commands to the background copy instead. * We also signal the background copy to come to the foreground by * default (Workbench) or if no other options are specified (CLI). * * Returns TRUE for success, FALSE for failure. * */ int ParseStartupOpts(int argc, char **argv) { struct Settings newset = DefaultSettings; struct DiskObject *IconCache[20]; struct DiskObject *dobj = NULL; struct WBArg *wbarg; char msg[200]; int success = 1; int maxargs; int i; int gotsettings = 0; /* If true, settings keyword specified */ /* * We start off in a special disabled state (not 0, not 1) * to ensure no events get monitored during our initialisation. * We use a special state so that we can detect if the user * specifies Disabled = Yes/No during startup. */ Disabled = 2; /* Start up in disabled state */ if (WBenchMsg) { /* * Starting up from Workbench. */ if (!IconBase) return (FALSE); maxargs = min(WBenchMsg->sm_NumArgs, 20); for (i = 0, wbarg = WBenchMsg->sm_ArgList; i < maxargs; i++, wbarg++) { BPTR olddir; IconCache[i] = NULL; if (wbarg->wa_Lock && *wbarg->wa_Name) { olddir = CurrentDir(wbarg->wa_Lock); dobj = GetDiskObject(wbarg->wa_Name); if (dobj) { char *param; param = FindToolType(dobj->do_ToolTypes, CmdNames[CMD_SETTINGS]); if (param && *param) { strcpy(DefaultConfigName, param); gotsettings = 1; } param = FindToolType(dobj->do_ToolTypes, CmdNames[CMD_LANGUAGE]); if (param && *param) strcpy(Language, param); param = FindToolType(dobj->do_ToolTypes, CmdNames[CMD_PATCHRAMLIB]); if (param && stricmp(param, "no") == 0) NoPatchRamLib = 1; IconCache[i] = dobj; } CurrentDir(olddir); } } } else { /* * Starting up from the CLI so scan the command line using * the passed-in arguments. */ if (argc > 1) { if (argv[1][0] == '-' || argv[1][0] == '?') { Printf(MSG(MSG_CLI_USAGE), CommodityTitle, argv[0]); return (FALSE); } } /* * Do a prescan of the command line looking * for SETTINGS, LANGUAGE or PATCHRAMLIB, keywords. */ for (i = 1; i < argc; i++) { char cmdname[50]; char param[150]; char newcmd[200]; int boolvalue; struct Command *cmd; int cid; cid = ParseCommand(argv[i], cmdname, param, &boolvalue, &cmd); if (cid == CMD_NOPARAM && ((i + 1) < argc)) { /* * Indicates we didn't get enough parameters for our * command. Let's grab the next option off the command * line instead and see if that makes sense. */ mysprintf(newcmd, "%s %s", argv[i], argv[i+1]); cid = ParseCommand(newcmd, cmdname, param, &boolvalue, &cmd); i++; /* Skip over next parameter */ } switch (cid) { case CMD_SETTINGS: strcpy(DefaultConfigName, param); gotsettings = 1; break; case CMD_LANGUAGE: strcpy(Language, param); break; case CMD_PATCHRAMLIB: NoPatchRamLib = !boolvalue; break; } } } /* * Now initialise locale according to the language chosen, * and read in our default configuration file. */ InitLocale(Language); InitMenus(); /* * Note that LoadConfig() and further ExecCommand() calls may * cause the settings to be installed at any time, and UpdateFlags * to be reset to null. Thus, it is important to ensure that * we initialise them correctly in the first place. */ UpdateFlags = SET_ALL; if (SnoopPort) { /* * We only initialise our patches if we're the only task * running at the moment. We leave the initialisation * until now so that we can control whether or not our * ramlib patch gets installed. */ if (!InitPatches()) { if (WBenchMsg) ShowError(MSG(MSG_ERROR_INITPATCHES)); else Printf("%s\n", MSG(MSG_ERROR_INITPATCHES)); Cleanup(40); } if (!gotsettings) { /* * If we haven't yet got a settings file, then try a number of * possible locations (in order of priority). If we find a * match, we overwrite the default config name with the new * name, for future use by LoadConfig and SaveConfig. */ static char *defconfig[] = { "PROGDIR:" SETTINGS_BASENAME, "S:" SETTINGS_BASENAME, "ENVARC:" SETTINGS_BASENAME, NULL }; APTR oldwinptr = *TaskWindowPtr; char **pdefname; *TaskWindowPtr = (APTR)-1; for (pdefname = defconfig; *pdefname; pdefname++) { BPTR lk = Lock(*pdefname, ACCESS_READ); if (lk) { UnLock(lk); break; } } if (!*pdefname) { /* * Choose a good default name. We try for ENVARC: * initially, but if that fails, fall back on S: */ if (IsFileSystem(defconfig[2])) pdefname = &defconfig[2]; else pdefname = &defconfig[1]; } strcpy(DefaultConfigName, *pdefname); strcpy(ConfigFileName, *pdefname); *TaskWindowPtr = oldwinptr; } else { /* * Do a quick check to see if the filename specified * using the Settings keyword exists -- if it doesn't, * then don't bother to try loading it (this avoids * a requester being shown unnecessarily). */ BPTR lk = Lock(DefaultConfigName, ACCESS_READ); if (lk) UnLock(lk); else gotsettings = 0; } /* * Now, one way or another, we have the default config filename * set up so try and load it. */ if (!LoadConfig(DefaultConfigName, (WBenchMsg ? MODE_TOOLTYPE : MODE_CMDLINE), &newset) && gotsettings) { ShowError(MSG(MSG_ERROR_LOADING_SETTINGS), DefaultConfigName); } } /* * Finally, lets parse the remaining startup options and/or icons */ if (WBenchMsg) { /* * Scan all the config files (if any) that were passed as * parameters via icons. */ wbarg = WBenchMsg->sm_ArgList + 1; for (i = 1; i < WBenchMsg->sm_NumArgs; i++, wbarg++) { char *name = wbarg->wa_Name; if (SnoopPort) { BPTR olddir = CurrentDir(wbarg->wa_Lock); LoadConfig(name, MODE_INTERNAL, &newset); CurrentDir(olddir); } else { /* * There's a background copy running so we need * to tell it to load the config file instead. */ char *p; mysprintf(msg, "%s ", CmdNames[CMD_LOADSETTINGS]); p = msg + strlen(msg); NameFromLock(wbarg->wa_Lock, p, 150); AddPart(p, wbarg->wa_Name, 150); SendRemote(msg, MODE_TOOLTYPE); } } /* * Rescan the icons, this time processing all the tooltypes that * we recognise. Any we don't recognise are ignored. SETTINGS * command may get parsed a second time, but that's okay. */ for (i = 0; i < maxargs; i++) { dobj = IconCache[i]; if (dobj) { char **tooltypes; for (tooltypes = dobj->do_ToolTypes; *tooltypes; tooltypes++) { if (SnoopPort) ExecCommand(*tooltypes, MODE_TOOLTYPE, &newset); else SendRemote(*tooltypes, MODE_TOOLTYPE); } FreeDiskObject(dobj); } } if (!SnoopPort) SendRemote(CmdNames[CMD_SHOW], MODE_CMDLINE); } else { /* * Do a proper scan of the CLI arguments. */ for (i = 1; i < argc; i++) { char newcmd[200]; char *thiscmd = argv[i]; struct Command *cmd; int boolvalue; int cid; /* * Check if the command we're checking needs more than * one parameter. If so, and if it wasn't supplied, we * assume that the parameter after it on the command * line is to be used. This means the user doesn't have * to specifically type the '='. * * HELP is a special case, since HELP will work with zero * parameters too. We only try and handle help if there * is at least one more parameter after it on the command * line. If there isn't, then we print a list of supported * commands instead. */ cid = ParseCommand(thiscmd, newcmd, newcmd+50, &boolvalue, &cmd); if ( (i+1) < argc && (cid == CMD_HELP || (cid == CMD_NOPARAM && cmd->numparms > 0)) ) { /* * We didn't have a parameter for this command, so * assume the next parameter on the command line is * the parameter instead. */ mysprintf(newcmd, "%s %s", argv[i], argv[i+1]); thiscmd = newcmd; i++; } else if (cid == CMD_HELP) { /* * Didn't have anything following the HELP so * print CLI help instead and exit immediately. */ ShowCommands(Output()); return (0); } if (SnoopPort) { switch (ExecCommand(thiscmd, MODE_CMDLINE, &newset)) { case EXEC_FAIL: Printf(MSG(MSG_ERROR_CLI_FAILED), thiscmd); success = 0; break; case EXEC_NOPARAM: Printf(MSG(MSG_ERROR_CLI_NOPARAM), thiscmd); success = 0; break; case EXEC_UNKNOWN: Printf(MSG(MSG_ERROR_CLI_UNKNOWN), thiscmd); success = 0; break; // case EXEC_OKAY: } } else { SendRemote(thiscmd, MODE_CMDLINE); } } if (!SnoopPort && argc == 1) SendRemote(CmdNames[CMD_SHOW], MODE_CMDLINE); } if (!SnoopPort) success = 0; /* * Now check if the user specified Disable=YES (or NO) during * startup. If they didn't, then reset the disable flag. * Regardless, we want to update the function flags to reflect * the current disable state. */ if (Disabled == 2) SetMonitorMode(MONITOR_NORMAL); if (success) InstallSettings(&newset, UpdateFlags | SET_FUNC); return (success); }