/*---------------------------------------------------------------------------- %%File: EMTEST.C %%Unit: Event Monitor (mntr) %%Contact: daleg Event Monitor Sample Application, Main Program. The purpose of this application is to demonstrate how to process events using the Event Monitor's Rule Compiler and rule engine. ----------------------------------------------------------------------------*/ //*** genem.c -- 'generic' evtmon client-side stuff // DESCRIPTION // the client-side of an evtmon app has two parts: // - evtmon generic code (client-side) // - application-specific rules // this file is reusable (and semi-frozen) generic code. it should be // #include'ed from the app. // NOTES // WARNING: do *not* put app-specific code here. put it in the // client (emclient/libem.c). in fact in general, think twice before // modifying this file at all. //*** YY_* -- generic rules support // #define YY_BASE 1 // base features (always needed) #ifdef YY_BASE // rulc.exe doesn't create all files if a given feature isn't used, // so we can't unconditionally include these guys. plus, we don't // want the helper code if we don't need it. // turn on these features here if you use them #ifndef YY_DELAYED #define YY_DELAYED 0 // delayed actions #endif #ifndef YY_CTOR #define YY_CTOR 0 // action ctors #endif #ifndef YY_SEQCHECK #define YY_SEQCHECK 0 // seq_check #endif #define YY_OTHER 0 //#define YY_BRKPT() #endif //*** FEATURE_* -- domain-specific rules support // NOTES #define FEATURE_DEMO 0 // demo code (e.g. wndproc test app) #define FEATURE_SAMPLE 0 // sample code (e.g. joe-event firer) #define FEATURE_OFFICE 0 // base office stuff #define FEATURE_TEXT 0 // text parser #define FEATURE_WORD 0 // format parser #define FEATURE_DEAD 0 // unused/dead code #define FEATURE_NYI 0 #include "mso.h" #include "msoem.h" DEBUGASSERTSZ #include "msolex.h" #include "emrule.h" #include "emkwd.h" #include "emact.h" #if FEATURE_DEMO #include "emtest.h" #include "emres.h" #endif // { Files generated by Rule Compiler #include "emdef.h" // rules (#defines) #if YY_CTOR // { #include "emacts.h" // ctor macro wrappers #endif // } #define DEBUG_RULE_POINTERS // Want ptrs to nodes #include "emruli.h" // rulebase #if YY_SEQCHECK // seq_check #include "emsqck.c_" // sequences #endif // } #if FEATURE_TEXT // { // Constants #define cbEditText 1024 #ifdef STATIC_INIT #define grfLexFlagsEm (MsoGrfLexFNoReset \ | MsoGrfLexFLookup \ | MsoGrfLexFLookupIntsAndSyms \ | MsoGrfLexFAllCapsAsFormat) // EM data structures MSORULTK rgrultkEmToken[200]; // Text Token cache MSORULTK rgrultkEmFormat[100]; // Format Token cache MSOLEXS vlexs = { &vkwtbEmTOKEN_KEYTABLE, // pkwtb {rgrultkEmToken, 200, }, // rultkhToken {rgrultkEmFormat, 100, }, // rultkhFormat fTrue, // fInited isttblDefault, // isttbl grfLexFlagsEm, // grpfLexFlags _hObjectNil, // hObjectNil MsoWchLexGetNextBufferDoc, // pfnlexbuf FGetNextLexRun, // pfnlexrun FGetTokenTextObject, // pfnlextxt NULL, // pfnlexfmt NULL, // pfnlexrunDiscontig NULL, // pfnlexrunForceCompl iNil, // ichRun -1, // cchLookahead }; MSOLEXS *vplexs = &vlexs; // Global lexer state #else /* !STATIC_INIT */ MSOLEXS vlexs; // Global lexer state MSOLEXS *vplexs; // Global lexer state #endif /* STATIC_INIT */ #endif // } #if YY_BASE // { // Global variables RULS *vlpruls = &vrulsEm; #ifndef STATIC_LINK_EM RULS **_pvlprulsDLL = &vlpruls; // App's Global state #endif /* !STATIC_LINK_EM */ #endif // } #if FEATURE_DEMO // { char vszAppName[20]; // Application name HWND vhInst; // Instance HWND vhWndMain; // Main window HWND vhWndDlg; // Dialog window char vszEditText[cbEditText]; // Text of edit control int vcchEditText; // #chs in edit control static int vcchPrev = 0; // Prev edit box len static int vcpIpPrev = 0; // Prev edit box ip int vfSettingDlgItem = fFalse; // Avoid Win recursion #endif // } #if YY_BASE // { #if YY_DELAYED #include "emactr.h" // data tables MSOACTTBL vacttbl = {vrgacttrecEm}; // Global action table MSOACTTBL *_pacttbl = &vacttbl; // Glob action tbl ptr #endif #endif // } #if FEATURE_OFFICE // { EMS vems; // EM global state EMS *vpems = &vems; // Ptr to global state #endif // } #if YY_BASE // { #ifdef DEBUG #ifndef STATIC_LINK_EM int vwDebugLogFilter = fDebugFilterAll; int vwDebugLogLvl = -2; #endif // !STATIC_LINK_EM // Pointers to global debug logging vars in Mso DLL int *pvwDebugLogFilter = &vwDebugLogFilter; int *pvwDebugLogLvl = &vwDebugLogLvl; #endif /* DEBUG */ #endif // } #if YY_BASE // { #ifdef STATIC_INIT // { /* F I N I T E M */ /*---------------------------------------------------------------------------- %%Function: FInitEm %%Contact: daleg Initialize the static (compiled) Event Monitor rules. ----------------------------------------------------------------------------*/ int FInitEm(void) { #ifndef STATIC_LINK_EM /* Mirror global debug pointers in Mso97.dll */ Debug(pvwDebugLogLvl = MsoPwDebugLogLvl(&pvwDebugLogFilter);) #endif /* !STATIC_LINK_EM */ Debug(*pvwDebugLogLvl = 7); #ifndef STATIC_LINK_EM /* Mirror global pointers (vlpruls, etc) in Mso97.dll */ _pvlprulsDLL = MsoPvlprulsMirror(&vlpruls); *_pvlprulsDLL = &vrulsEm; #endif /* !STATIC_LINK_EM */ #ifdef DYN_RULES /* Load dynamic rules */ FLoadDynEmRules(); #endif /* DYN_RULES */ #if FEATURE_OFFICE /* For performance reasons, action table is global */ vacttbl.prultkh = &vplexs->rultkhToken; #endif #if FEATURE_DEMO /* Allow Event Drivers to run */ EnableEM(); #endif /* Propagate the values through the rule network */ MsoScheduleIrul(irul_YYSTD_INIT, fTrue); #ifdef DYN_RULES MsoScheduleIrul(irul_YYSTD_LOADING_RULEBASE, fTrue); #endif /* DYN_RULES */ MsoEvaluateEvents(rulevtEm_YYSTD); return fTrue; } #else /* }{ !STATIC_INIT */ /* F I N I T E M */ /*---------------------------------------------------------------------------- %%Function: FInitEm %%Contact: daleg Initialize the static (compiled) Event Monitor rules. ----------------------------------------------------------------------------*/ int FInitEm(void) { #ifndef STATIC_LINK_EM /* Mirror global debug pointers in Mso97.dll */ Debug(pvwDebugLogLvl = MsoPwDebugLogLvl(&pvwDebugLogFilter);) #endif /* !STATIC_LINK_EM */ Debug(*pvwDebugLogLvl = 7); /* Initialize rule base, for performance reasons, rulebase is global */ if (!MsoFInitStaticRuls(&vrulsEm, &vrulsEm)) return fFalse; #ifndef STATIC_LINK_EM /* Mirror global pointers (vlpruls, etc) in Mso97.dll */ _pvlprulsDLL = MsoPvlprulsMirror(&vlpruls); *_pvlprulsDLL = &vrulsEm; #endif /* !STATIC_LINK_EM */ #ifdef DYN_RULES /* Load dynamic rules */ FLoadDynEmRules(); #endif /* DYN_RULES */ #if FEATURE_OFFICE /* Initialize the lexer to scan the doc */ if (!(vplexs = MsoPlexsLexInitDoc (&vlexs, _hObjectNil, FGetNextLexRun, FGetTokenTextObject, NULL, NULL, 200, 100))) return fFalse; vplexs->pkwtb = &vkwtbEmTOKEN_KEYTABLE; /* For performance reasons, action table is global */ vacttbl.prultkh = &vplexs->rultkhToken; #endif #if FEATURE_DEMO /* Allow Event Drivers to run */ EnableEM(); #endif /* Propagate the values through the rule network */ MsoScheduleIrul(irul_YYSTD_INIT, fTrue); #ifdef DYN_RULES MsoScheduleIrul(irul_YYSTD_LOADING_RULEBASE, fTrue); #endif /* DYN_RULES */ MsoEvaluateEvents(rulevtEm_YYSTD); return fTrue; } #endif /* } STATIC_INIT */ #endif // } #if YY_BASE // { /* F E V A L E M R U L E */ /*---------------------------------------------------------------------------- %%Function: FEvalEmRule %%Contact: daleg Evaluate the rule associated with the given rule ID number. Return a boolean value for whether its value was TRUE or FALSE. ----------------------------------------------------------------------------*/ #include "emeval.c" #endif // } #if FEATURE_DEMO // { /* W I N M A I N */ /*---------------------------------------------------------------------------- %%Function: WinMain %%Contact: daleg Main routine. ----------------------------------------------------------------------------*/ int CALLBACK WinMain( HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow ) { MSG msg; int nRc; char szString[256]; GdiSetBatchLimit(1); strcpy(vszAppName, "EMTEST"); vhInst = hInstance; if (!hPrevInstance) { /* Register window classes if first instance of application */ if ((nRc = nCwRegisterClasses()) == -1) { /* Put up msg if registering one of the windows failed */ LoadString(vhInst, IDS_ERR_REGISTER_CLASS, szString, sizeof(szString)); MessageBox(NULL, szString, NULL, MB_ICONEXCLAMATION); return nRc; } } /* Create application's Main window */ vhWndMain = CreateWindow(vszAppName, NULL, WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME | WS_CLIPCHILDREN | WS_OVERLAPPED, 0, 0, 400, 400, NULL, NULL, vhInst, NULL); /* If could not create main window, be nice before quitting */ if (vhWndMain == NULL) { LoadString(vhInst, IDS_ERR_CREATE_WINDOW, szString, sizeof(szString)); MessageBox(NULL, szString, NULL, MB_ICONEXCLAMATION); return IDS_ERR_CREATE_WINDOW; } /* Initialize the rulebase */ if (!FInitEm()) return 1; /* Display main window */ ShowWindow(vhWndMain, nCmdShow); /* Until WM_QUIT message */ while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } /* Do clean up before exiting from the application */ CwUnRegisterClasses(); return msg.wParam; } /* W N D P R O C */ /*---------------------------------------------------------------------------- %%Function: WndProc %%Contact: daleg Windows proc for main window. ----------------------------------------------------------------------------*/ LONG CALLBACK WndProc( HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam ) { HMENU hMenu = 0; int nRc = 0; switch (Message) { case WM_COMMAND: FEmEvalDialog(wParam); switch (LOWORD(wParam)) { case IDM_DIALOG: /* Respond to the menu item named "Dialog" */ { FARPROC lpfnDIALOGSMsgProc; lpfnDIALOGSMsgProc = MakeProcInstance((FARPROC) DIALOGSMsgProc, vhInst); nRc = DialogBox(vhInst, MAKEINTRESOURCE(IDM_DIALOG), hWnd, lpfnDIALOGSMsgProc); FreeProcInstance(lpfnDIALOGSMsgProc); } break; default: return DefWindowProc(hWnd, Message, wParam, lParam); } break; case WM_CLOSE: /* Destroy child windows, modeless dialogs, then, this window */ DestroyWindow(hWnd); /* Quit the application */ if (hWnd == vhWndMain) PostQuitMessage(0); break; default: return DefWindowProc(hWnd, Message, wParam, lParam); } return 0L; } /* D I A L O G S M S G P R O C */ /*---------------------------------------------------------------------------- %%Function: DIALOGSMsgProc %%Contact: daleg Dialog proc for inner window. ----------------------------------------------------------------------------*/ BOOL CALLBACK DIALOGSMsgProc( HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam ) { switch (Message) { case WM_INITDIALOG: cwCenter(hWndDlg, 0); vcchPrev = 0; vcpIpPrev = 0; vhWndDlg = hWndDlg; break; case WM_CLOSE: break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDC_EDIT1: switch (HIWORD(wParam)) { case EN_CHANGE: vcchEditText = GetDlgItemText(hWndDlg, IDC_EDIT1, vszEditText, cbEditText); if (!vfSettingDlgItem) { MSOCP cpIp; XCHAR wch; /* Get IP (Insertion Point) position */ SendDlgItemMessage(hWndDlg, IDC_EDIT1, EM_GETSEL, 0, (LPARAM)&cpIp); /* Get character typed */ wch = (vcchEditText > vcchPrev ? vszEditText[cpIp - 1] // Char typed : xchBackspace); // Backspace /* Notify Event Monitor CHAR driver */ FEmEvalChar(wch, cpIp, vszEditText, vcchEditText); /* Track prev text positions for invalidation detect */ vcchPrev = vcchEditText; vcpIpPrev = cpIp; } break; } break; case IDC_BUTTON1: case IDC_BUTTON2: case IDC_START: case IDC_STOP: default: FEmEvalDialog(wParam); break; case IDOK: FEmEvalDialog(wParam); EndDialog(hWndDlg, FALSE); break; } break; default: return FALSE; } return TRUE; } #endif // } #if FEATURE_SAMPLE // { joe event firer /* F E M E V A L D I A L O G */ /*---------------------------------------------------------------------------- %%Function: FEmEvalDialog %%Contact: daleg Event Monitor Event Driver for DIALOG events. ----------------------------------------------------------------------------*/ int FEmEvalDialog(WPARAM wParam) { short idc = LOWORD(wParam); IRUL irul; #if FEATURE_DEMO /* Make sure we are enabled (e.g. macros not running) */ if (FEmDisabled()) return fFalse; #endif /* Match the (sparse) dialog object to its associated (contig) event, if any */ vlpruls->irulPrimaryEvent = irul = (IRUL) MsoPkwdlhLookupL(idc, &vkwtbEmIDC_KEYTABLE)->tk; debugEM1(2, "DIALOG EVENT: %-20.20s\n", LpchRulName(LprulFromIrul(irul))); /* Push event into appropriate queue (resets depth) */ MsoScheduleIrul(irul, fTrue); MsoScheduleIrul(irulIDC_, idc); // non-mapped event (autoclear global) /* Propagate the values through the rule network */ MsoEvaluateEvents(rulevtEmDIALOG); // n.b. IDC_ is now autocleared /* Evaluate any pending actions */ if (_pacttbl->pactPending) DoPendingActions(); } /* F E M E V A L C H A R */ /*---------------------------------------------------------------------------- %%Function: FEmEvalChar %%Contact: daleg Event Driver for CHAR events in Event Monitor. Evaluate CHAR (KEYBOARD) events within the Event Monitor rulebase. Return whether or not it was handled. ----------------------------------------------------------------------------*/ int FEmEvalChar( XCHAR wch, MSOCP cpIp, XCHAR *wz, int ichMac ) { IRUL irul; #if FEATURE_DEMO /* Make sure we are enabled (e.g. macros not running) */ if (FEmDisabled()) return fFalse; #endif /* Primitive invalidation */ if (FCheckIfMustReset(wch, ichMac, cpIp)) InvalLex(vplexs); /* If our running state is still valid, adjust run variables */ if (FInvalLex(vplexs)) FResetEm((vplexs->cpIp = cpIp) - 1, wz, ichMac); /* Create a "lookahead" token to hold chars not yet scanned by lexer */ vplexs->cchLookahead++; _CacheTkTextNext(vplexs); /* Look up character in keyword table */ irul = (IRUL) MsoPkwdLookupName(&wch, 1, &vkwtbEmCHAR_KEYTABLE)->tk; debugEM3(2, "CHAR EVENT: %-20.20s for '%s' (0x%x)\n", LpchRulName(LprulFromIrul(irul)), MsoSzFromRgxchDebug(&wch, 1), wch); /* Push text token into appropriate queue (resets depth) */ MsoScheduleIrul(irulCH_, wch); MsoScheduleIrul(vlpruls->irulPrimaryEvent = irul, fTrue); /* Propagate the values through the rule network */ MsoEvaluateEvents(rulevtEmCHAR); /* Call TOKEN event driver to process any token events */ FEmEvalToken(cpIp, wz, ichMac); } /* E M E V A L T K I R U L */ /*---------------------------------------------------------------------------- %%Function: EmEvalTkIrul %%Contact: daleg Evaluate a TOKEN event irul. ----------------------------------------------------------------------------*/ void EmEvalTkIrul(IRUL irul) { MSORULTK *prultk; debugEM2(2, "TOKEN EVENT: %-20.20s \"%.100s\"\n", LpchIrulName(irul), MsoSzLexTokenText(vplexs)); /* Push pending token events into appropriate queues */ prultk = PrultkFromTokenIrultk(vplexs, vplexs->rultkhToken.irultkMin); while (vplexs->rultkhToken.irultkMin != vplexs->rultkhToken.irultkLim) { #ifdef DEBUG if (prultk->tk != irul) { debugEM2(4, "EXTRA TOKEN EVENT: %-20.20s %d\n", LpchIrulName(prultk->tk), prultk->lValue); debugEM1(8, " at CP %ld\n", prultk->cpFirst); } #endif /* DEBUG */ /* Push text token into appropriate queue (resets depth) */ MsoSignalEventIrul(IrulFromTk(prultk->tk), prultk->lValue); /* Move to next cache record, wrapping around if necessary */ IncrTokenPrultk(vplexs, &prultk, &vplexs->rultkhToken.irultkMin); } /* Push any applicable format tokens into appropriate queues */ if (vplexs->rultkhFormat.irultkMin != vplexs->rultkhFormat.irultkLim) PushIrultkFormatPending(); /* Push text token into appropriate queue (resets depth) */ MsoScheduleIrul(irulTOKEN_, vlpruls->irulPrimaryEvent = irul); /* Propagate the values through the rule network */ MsoEvaluateEvents(rulevtEmTOKEN); } #endif // } #if FEATURE_SAMPLE // { /* F E M E V A L T O K E N */ /*---------------------------------------------------------------------------- %%Function: FEmEvalToken %%Contact: daleg Event Monitor Event Driver for TOKEN events. ----------------------------------------------------------------------------*/ int FEmEvalToken( MSOCP cpIp, XCHAR *wz, int ichMac ) { IRUL irul; #if FEATURE_DEMO /* Make sure we are enabled (e.g. macros not running) */ if (FEmDisabled()) return fFalse; #endif /* If our running state is still valid, adjust run variables */ if (!FInvalLex(vplexs)) { long dwz = wz - vplexs->pxchBuffer; vplexs->pxchTkStart += dwz; vplexs->pxchNext += dwz; vplexs->pxchRun += dwz; vplexs->pxchBuffer += dwz; vplexs->cpIp = cpIp; vplexs->cpLim = ichMac; vplexs->cchRemain = vplexs->pxchBuffer + vplexs->cpLim - vplexs->pxchNext; } /* Else rescan back up to IP */ else if (!FResetEm((vplexs->cpIp = cpIp) - 1, wz, ichMac)) return fFalse; /* Inject and eval any complete tokens up to IP */ while (FValidIrul(irul = IrulFromTk(MsoTkLexTextCpLim(vplexs, cpIp)))) EmEvalTkIrul(irul); /* Evaluate any pending actions */ if (_pacttbl->pactPending) DoPendingActions(); /* All typed characters must now have been seen by the lexer */ if (vplexs->cchLookahead > 0) vplexs->cchLookahead = 0; } #endif // } #if FEATURE_TEXT // { /* P U S H I R U L T K F O R M A T P E N D I N G */ /*---------------------------------------------------------------------------- %%Function: PushIrultkFormatPending %%Contact: daleg Push any pending format tokens into appropriate queues. ----------------------------------------------------------------------------*/ void PushIrultkFormatPending(void) { MSORULTK *prultk; debugEM1(8, "Checking for formatting before CP %ld\n", CpLexTokenFirst(vplexs)); prultk = PrultkFormatFromIrultk(vplexs, vplexs->rultkhFormat.irultkMin); while (vplexs->rultkhFormat.irultkMin != vplexs->rultkhFormat.irultkLim && (prultk->cpFirst < CpLexTokenFirst(vplexs) + DcpLexToken(vplexs) || (DcpLexToken(vplexs) == 0 && prultk->cpFirst <= CpLexTokenFirst(vplexs)))) { debugEM2(2, "FORMAT : %-20.20s %ld\n", LpchIrulName(prultk->tk), prultk->lValue); debugEM1(6, " at CP %ld\n", prultk->cpFirst); /* Push format token into appropriate queue (resets depth) */ MsoSignalEventIrul(IrulFromTk(prultk->tk), prultk->lValue); /* Move to next cache record, wrapping around if necessary */ IncrFormatPrultk(vplexs, &prultk, &vplexs->rultkhFormat.irultkMin); } } #endif // } #if FEATURE_TEXT // { /* F R E S E T E M */ /*---------------------------------------------------------------------------- %%Function: FResetEm %%Contact: daleg Reset the Event Monitor rules and lexer due to an IP (cursor) change, or due to some form of invalidation. ----------------------------------------------------------------------------*/ int FResetEm( MSOCP cpIp, XCHAR *wz, int ichMac ) { MSOCP cpObject = 0; IRUL irul; /* Initialize lexer to point to start of buffer */ vplexs->pObjectIp = PObjectCur(); vplexs->pxchBuffer = vplexs->pxchBufferIp = vplexs->pxchRun = wz; MsoLexSetPos(vplexs, cpObject, 0); debugEM0(0, "====================================================\n"); debugEM3(0, " FResetEm: RESETTING: pObjectIp %x cpLine %ld cp %ld\n", vplexs->pObjectIp, cpObject, cpIp); debugEM0(0, "====================================================\n"); /* Reset rule base TOKEN state variables */ MsoClearEventsForRulevts(rulevtEmTOKEN, drulevtToken, (vpems->fInternalReset ? rultPersistentRule | rultAlwaysPersist : rultAlwaysPersist), fTrue, fFalse); vplexs->wInterval = CIntervalsRulevt(rulevtEmTOKEN); /* Reset lexer base state */ MsoResetLexState(vplexs, fTrue/*fFullReset*/); vplexs->cpLim = 0; vplexs->fInvalLexer = fFalse; /* Mark start of scan */ MsoCacheTkText(vplexs, irulSTART, fTrue); MsoScheduleIrul(irulSTART, fTrue); /* Mark start of token cache, but not as events */ MsoCacheTkText(vplexs, irulEND_OBJ, fTrue); vplexs->rultkhToken.irultkMin = vplexs->rultkhToken.irultkLim; /* Run only rules not marked as INTERACTIVE_ONLY */ SetCurrRulg(rulgEmALWAYS); /* Inject and eval any complete tokens up to IP */ while (FValidIrul(irul = IrulFromTk(MsoTkLexTextCpLim(vplexs, cpIp)))) EmEvalTkIrul(irul); /* Run only rules not marked as INTERACTIVE_ONLY */ SetCurrRulg(rulgEmINTERACTIVE_ONLY); /* Mark that we are synchronized */ vplexs->cchLookahead = 0; return fTrue; } /* F G E T T O K E N T E X T O B J E C T */ /*---------------------------------------------------------------------------- FGetTokenTextObject %%Contact: smueller Determine whether the text of the requested token needs to be fetched from the document. If so, do so, leaving the results in ppxch and pcch, and return fTrue. Otherwise, return fFalse. ----------------------------------------------------------------------------*/ int WIN_CALLBACK FGetTokenTextObject( MSORULTK *prultk, const XCHAR **ppxch, // RETURN int *pcch, // RETURN struct _MSOLEXS *plexs ) { if (plexs->pObject != NULL) { // NOT SUPPORTED YET return fTrue; } return fFalse; } /* F G E T N E X T L E X R U N */ /*---------------------------------------------------------------------------- %%Function: FGetNextLexRun %%Contact: daleg Return next run of text within the current object , and set the lexer run-state variables. For this demo, there ain't any, but we will show a commented-out sample. ----------------------------------------------------------------------------*/ int WIN_CALLBACK FGetNextLexRun(MSOCP cpLim, MSOLEXS *plexs) { int fStatus = fTrue; const XCHAR *pxchPrevEnd = plexs->pxchNext; /* If prev run at end of current object, move to next object */ if (FLexEndOfScan(vplexs)) { /* If still have a pending token, complete it first */ if (DcpLexCurr(vplexs) > 0) return fFalse; /* Create exactly one inter-object "created" tkEND_OBJ character */ if (plexs->fCreateEndObjCh) { /* Make this run "created" text, i.e. no dcp */ fStatus = fFalse; plexs->cpRun += plexs->ccpRun; plexs->ichRun += plexs->cchRun; plexs->cchRun = 1; plexs->ccpRun = 0; #ifdef READY /* Mark run as "created", so dcp calcs will work properly */ plexs->fAdjustTokenCps = fTrue; plexs->dcpCreated += 1; if (plexs->cpFirstCreated == 0L) plexs->cpFirstCreated = plexs->cpRun; #endif /* READY */ } /* Else get next object's text */ else { if (!FGetNextLexObject(cpLim, plexs)) return fFalse; /* If in object of IP has passed upper lim of scan, block lexer */ if (plexs->pObject == plexs->pObjectIp && cpLim != msocpMax && cpLim <= 0 /* plexs->cpRun */) fStatus = fFalse; } } /* Else move to next run */ else { plexs->cpRun += plexs->ccpRun; plexs->ichRun += plexs->cchRun; #ifdef PORT_THIS plexs->cchRun = vcchEditText - plexs->ichRun; #endif /* PORT_THIS */ plexs->ccpRun = plexs->cchRun; // Reset buffer pointer if run in a different buffer #ifdef PORT_THIS plexs->pxchBuffer = vszEditText; #endif /* PORT_THIS */ } /* Set Run length and pointer */ plexs->cchRemain = plexs->cchRun; plexs->pxchNext = (plexs->pxchRun = plexs->pxchBuffer + plexs->ichRun); AssertSz0(pxchPrevEnd == plexs->pxchNext || pxchPrevEnd == plexs->pxchTkStart, "Discontiguous runs!"); /* If run starts new text (line), reset non-cached tk start pointer */ if (pxchPrevEnd == plexs->pxchTkStart) plexs->pxchTkStart = plexs->pxchNext; return fStatus; } /* F G E T N E X T L E X O B J E C T */ /*---------------------------------------------------------------------------- %%Function: FGetNextLexObject %%Contact: daleg Set the "run" state variables to the first run of a new object, including the text buffer, and the run lengths. ----------------------------------------------------------------------------*/ int WIN_CALLBACK FGetNextLexObject(MSOCP cpLim, MSOLEXS *plexs) { // If this is the first time thru, do initialization stuff if (plexs->ichRun == iNil) { // YOUR INITS HERE } // Fetch new object text plexs->pObject = PObjectCur(); // Fetch new text (in our case, it is globally static) plexs->pxchBuffer = vszEditText; plexs->cchRun = plexs->cpLim = vcchEditText; plexs->pxchRun = plexs->pxchBuffer; // Set up other state variables plexs->ichRun = 0; plexs->cpRun = 0; plexs->cpObject = 0; plexs->ccpRun = plexs->cchRun; SetCpLexTokenFirst(vplexs, SetCpLexTokenNext(vplexs, 0)); return fTrue; } /* F L E X F O R C E C O M P L E T E */ /*---------------------------------------------------------------------------- %%Function: FLexForceComplete %%Contact: daleg Force the current token to complete within the lexer. This is a callback function that gets called when we wish to cause the lexer to finish a token without peeking at the next character. This is generally when we are moving the IP out of a cell in a table, and wish to perform automatic actions anyway. Once we have completed the token, we clear the callback flag, to resume normal operation. ----------------------------------------------------------------------------*/ int WIN_CALLBACK FLexForceComplete(MSOCP cpLim, MSOLEXS *plexs) { XCHAR wch; /* If in the middle of a token complete it if next is EOO or delim */ // REVIEW daleg: This should check for more than just spaces after if (plexs->iuState > 0 && (cpLim == vplexs->cpLim || (wch = *vplexs->pxchNext) == xchSpace)) return fTrue; /* Do not call this routine next time */ plexs->pfnlexrunForceComplete = NULL; /* Force an END_OBJ token (event) if we are at the cell boundary */ return (cpLim == vplexs->cpLim); } #endif // } #if YY_BASE // { /* P A C T P C A */ /*---------------------------------------------------------------------------- %%Function: PactPca %%Contact: daleg Create a Delayed-Action record, using a MSOCA to define the edit range. ----------------------------------------------------------------------------*/ MSOACT *PactPca( MSOACTTBL *pacttbl, int actt, MSOCA *pca, ... ) { va_list ap; MSOACT *pact; /* Safety first: make sure we have an action structure */ if (!pacttbl) return NULL; /* Start varargs */ va_start(ap, pca); /* Create a new Delayed Action record, and push arg list into it */ pact = MsoPactAp(pacttbl, actt, (sizeof(MSOCA) + sizeof(long) - 1)/sizeof(long), ap); /* End varargs */ va_end(ap); /* Calculate starting CP */ pact->rec1_ca.ca = *pca; /* Insert the MSOACT record into the edit queue in CP sorted order */ MsoInsertPact(pact, &pacttbl->pactPending); return pact; } #if YY_DELAYED // { long WIN_CALLBACK DcpDoAct( MSOACT *pact, MSOACTTBL *pacttbl, long *pdcp, MSOCA *pca, MSOACT **ppactNext, int *pfDiscard ); /* D O P E N D I N G A C T I O N S */ /*---------------------------------------------------------------------------- %%Function: DoPendingActions %%Contact: daleg Execute pending actions in delay action queue. ----------------------------------------------------------------------------*/ void DoPendingActions(void) { _pacttbl->cpFirstEditPrev = -1; _pacttbl->dcpEditPrev = 0; _pacttbl->cpLimEdit = 0; MsoReversePact(&_pacttbl->pactPending); MsoDcpDoActs(&_pacttbl->pactPending, _pacttbl, 0, fTrue, -1, DcpDoAct); } /* D C P D O A C T */ /*---------------------------------------------------------------------------- %%Function: DcpDoAct %%Contact: daleg Execute the action given by the MSOACT record. ----------------------------------------------------------------------------*/ long WIN_CALLBACK DcpDoAct( MSOACT *pact, MSOACTTBL *pacttbl, long *pdcp, MSOCA *pca, MSOACT **ppactNext, int *pfDiscard ) { switch (pact->rec1.actt) { #include "emact.c_" } return 0; } #endif // } #endif // } #if FEATURE_DEMO // { /* D C P R E P L A C E T E X T */ /*---------------------------------------------------------------------------- %%Function: DcpReplaceText %%Contact: daleg Replace the text range given by the range of chars with the new string. ----------------------------------------------------------------------------*/ int DcpReplaceText( void *pObject, int cpFirst, int cpLim, char *sz ) { int cch = CchSz(sz); int dcp = cch - (cpLim - cpFirst); int cchOrig; char rgch[cbEditText]; MSOCP cpIp; /* Get current edit control value */ cchOrig = GetDlgItemText(vhWndDlg, IDC_EDIT1, rgch, cbEditText); /* Do not attempt to expand beyond control's capacity. */ if (cchOrig + dcp >= cbEditText) return 0; /* Replace the string */ CopyRgb(rgch + cpLim, rgch + cpLim + dcp, cchOrig - cpLim + 1); CopyRgbNo(sz, rgch + cpFirst, cch); /* Set the edit control value with the new string, preserving the IP */ vfSettingDlgItem = fTrue; // Prevent recursion SendDlgItemMessage(vhWndDlg, IDC_EDIT1, EM_GETSEL, 0, (LPARAM)&cpIp); SendDlgItemMessage(vhWndDlg, IDC_EDIT1, WM_SETTEXT, 0, (LPARAM)&rgch[0]); SendDlgItemMessage(vhWndDlg, IDC_EDIT1, EM_SETSEL, cpIp + dcp, cpIp + dcp); vcchEditText += dcp; vfSettingDlgItem = fFalse; debugEM0(2, "Replaced text\n"); return dcp; } #endif // } #if FEATURE_TEXT // { /* F C H E C K I F M U S T R E S E T */ /*---------------------------------------------------------------------------- %%Function: FCheckIfMustReset %%Contact: daleg Do a primitive check to see if we should invalidate our running rulebase state, and do a full reset scan. THIS IS NOT A CANONICAL ROUTINE, but there should be something equivalent in each app. ----------------------------------------------------------------------------*/ int FCheckIfMustReset(XCHAR wch, int ichMac, MSOCP cpIp) { if (wch == xchBackspace) return fTrue; /* If user typed a new character, emit character event */ /* REVIEW: pasting will result in multiple new characters, of which we only notice the last */ if (ichMac > vcchPrev) { Assert (cpIp > 0); /* Without notification of IP moves, there is no way to accurately identify when lexer needs invalidating; for safety, we could do so on every character. For demonstrating the lexer, we'll do so only when the IP didn't move forward by exactly one character, which is a decent approximation of the right time. */ /* REVIEW: find a more pleasant way to deal with this, like subclassing the edit control to get precise control over notifications. */ if (cpIp != vcpIpPrev + 1) return fTrue; } return fFalse; } #endif // } #if FEATURE_DEMO // { /* N C W R E G I S T E R C L A S S E S */ /*---------------------------------------------------------------------------- %%Function: nCwRegisterClasses %%Contact: daleg Register window classes ----------------------------------------------------------------------------*/ int nCwRegisterClasses(void) { WNDCLASS wndclass; memset(&wndclass, 0x00, sizeof(WNDCLASS)); /* load WNDCLASS with window's characteristics */ wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW; wndclass.lpfnWndProc = WndProc; /* Extra storage for Class and Window objects */ wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = vhInst; wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); /* Create brush for erasing background */ wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wndclass.lpszMenuName = vszAppName; /* Menu Name is App Name */ wndclass.lpszClassName = vszAppName; /* Class Name is App Name */ if (!RegisterClass(&wndclass)) return -1; return (0); } /* C W C E N T E R */ /*---------------------------------------------------------------------------- %%Function: cwCenter %%Contact: daleg Center the main window. ----------------------------------------------------------------------------*/ void cwCenter(hWnd, top) HWND hWnd; int top; { POINT pt; RECT swp; RECT rParent; int iwidth; int iheight; /* get the rectangles for the parent and the child */ GetWindowRect(hWnd, &swp); GetClientRect(vhWndMain, &rParent); /* calculate the height and width for MoveWindow */ iwidth = swp.right - swp.left; iheight = swp.bottom - swp.top; /* find the center point and convert to screen coordinates */ pt.x = (rParent.right - rParent.left) / 2; pt.y = (rParent.bottom - rParent.top) / 2; ClientToScreen(vhWndMain, &pt); /* calculate the new x, y starting point */ pt.x = pt.x - (iwidth / 2); pt.y = pt.y - (iheight / 2); /* top will adjust the window position, up or down */ if (top) pt.y = pt.y + top; /* move the window */ MoveWindow(hWnd, pt.x, pt.y, iwidth, iheight, FALSE); } /* C W U N R E G I S T E R C L A S S E S */ /*---------------------------------------------------------------------------- %%Function: CwUnRegisterClasses %%Contact: daleg Un-register the windows classes. ----------------------------------------------------------------------------*/ void CwUnRegisterClasses(void) { WNDCLASS wndclass; memset(&wndclass, 0x00, sizeof(WNDCLASS)); UnregisterClass(vszAppName, vhInst); } #endif // } #if FEATURE_DEAD // { /* A S S E R T L S Z P R O C */ /*---------------------------------------------------------------------------- %%Function: AssertLszProc %%Contact: daleg Print assertion message, and prompt for whether to (f)ail, or (i)gnore. ----------------------------------------------------------------------------*/ int AssertLszProc( const char *szExtra, const char *szFile, int line ) { Fail("ASSERTION FAILED: %s IN %s line %d\n", szExtra, szFile, line); return 1; } /* F A I L */ /*---------------------------------------------------------------------------- %%Function: Fail %%Contact: daleg Emit a failure message and exit. ----------------------------------------------------------------------------*/ void __cdecl Fail(const char *sz, ...) { va_list ap; char szBuf[256]; /* Start variable arglist */ va_start(ap, sz); wvsprintf(szBuf, sz, ap); OutputDebugString("FATAL ERROR: "); OutputDebugString(szBuf); OutputDebugString("\n"); /* End variable arglist */ va_end(ap); // _asm int 3; exit(1); } #endif // } #if FEATURE_DEAD // { /* F N E N C L P C H */ /*---------------------------------------------------------------------------- %%Function: FNeNcLpch %%Contact: daleg Compare two strings, case insensitive. ----------------------------------------------------------------------------*/ BOOL FNeNcLpch( register const uchar *pch1, register const uchar *pch2, register int cch ) { while (cch-- > 0) { if (ChUpper(*pch1++) != ChUpper(*pch2++)) return fTrue; } return fFalse; } #endif // }