The following public member functions are provided as part of the tpriProc class:

static int Create(int create = 0);

Attach the current process to a tpriProc class object.

static int Destroy();

Detach the current process from its tpriProc class object.
static int PrIni(int argc, char **argv);

Initialize the current process based on the command line and the default parameters read from the initialization file.
static int PrWait();

• Sleep until any of the following events occur:

1. The next timer interval has expired.

2. An Activate for this process is requested.

3. A Resume for this process occurs.

static int Activate(char *appName);

Request the process manager to activate the specified process. 

static int Resume(char *appName = NULL);

tatic int Resume(int startOrder);

static int Resume(HANDLE hResume);

Wake the specified process if it is currently sleeping.

static int Suspend(char *appName);

static int Suspend(int startOrder);

Suspend a process so that it does not awake from the next call to PrWait().

static int Deactivate(char *appName = NULL);

Request that the process manager to deactivate the specified process.

int countRunningProcs();

Return the number of currently running processes.

static HANDLE openResumeHandle(char *appName);

Open a handle to allow for fast resumes of another process.

static int closeResumeHandle(HANDLE hResume);

Close a resume handled opened with openResumeHandle(..).

static int getAppName(char *pBuf, unsigned int szBuf);

Export the application name of the current process to the supplied buffer.

static int getAppName(char *pBuf, unsigned int szBuf, int startOrder);

Export the application name of the current process to the supplied buffer.

static int getBinName(char *pBuf, unsigned int szBuf,char *appName = NULL);

Export the binary file name of the specified process to the supplied buffer.

static float getIntervalPct(char *appName = NULL);

Return the current value of the percent interval utilized for the specified process.

static float getIntervalPctMax(char *appName = NULL);

Return the current value of the maximum percent interval utilized for the specified process.

static int getDbgLevel(char *appName = NULL);

Return the debug level for the specified process.

static int setDbgLevel(char *appName, int dbglvl);

Set the debug level for the specified process.

static tpriProcGroup getProcGroup(char *appName = NULL);

Return the process group identifier for the specified process.

static DWORD getPid (char *appName = NULL);

Return the process ID for the specified process.

static int getRestart(char *appName = NULL);

Return the auto-restart flag for the specified process.

static int setRestart(char *appName, int restart);

Set the auto-restart flag for the specified process.

static long getRepRate(char *appName = NULL);

Return the periodic repetition rate for the specified process (ms).

static int getRunMode(char *appName = NULL);

Return the run mode (Win32, RTSS) for the specified process.

static tpriProcState getState(char *appName = NULL);

Return the current state for the specified process.

static inline tpriProcState getMgrState();

Return the current state of the process manager.

static int getStartOrder(char *appName = NULL);

Return the start order for the specified process.

static __int64 getStateTime64(char *appName = NULL);

Return the amount of time the specified process has been in its current state (100 ns increments).

static long getStateTime(char *appName = NULL);

Return the amount of time the specified process has been in its current state (1 second increments).

static const char *getStateDesc(tpriProcState state);

Return a description of the specified state.

static const char *getStateDesc(char *appName = NULL);

Return a description of the current state for the specified process.

static int exportProdef(prodef *pprodef, char *appName = NULL);

static int exportProdef(prodef *pprodef, int startOrder);

Export a copy of the entire process definition of the specified process.

static inline void setState(tpriProcState newState);

Set the state for the current process.

static void setDispStatus(const char *fmt, ...);

Set the display status string for the current process.

static int getDispStatus(char *pBuf, unsigned int szBuf, char *appName = NULL);

Export the current display status for the specified process.

static int clearErrorState(char *appName = NULL);

Clear the error state associated with the specified process.

static time_t time(time_t *timer);

Return the current time (seconds since 1/1/1970 12:00 am UTC).

static struct tm *lcltime(struct tm *ltm);

Return the current local time.

static void ftime(struct _timeb *timeptr);

Return the current time (seconds and milliseconds since 1/1/1970 12:00 am UTC).

static inline void setWDog(int wd);

Set the watchdog flag associated with the current process.

The tpriGsm class facilitates the mapping and access of shared memory segments within a Tsentry process.  For the most part, this class need not be directly used, as the data dictionary provides higher-level functions to automate the use of all global memory segments; however for specific applications, more specialized functionality may be required and thus a direct interface to the tpriGsm class is provided.

The following public member functions are provided as part of the tpriGsm class:

tpriGsm(char *gsmName, int gsmSize = 0);

Create and/or map a shared memory segment with the given name and size.

tpriGsm(char *gsmName, void *pVaddr, int gsmSize);

Wrap a tpriGsm object around an existing memory segment.

~tpriGsm();

Destroy a tpriGsm object.

void *getVaddr(int offset = 0);

Return the virtual address of the shared memory segment at the given byte offset.

int getStatus();

Return the current status of the shared memory segment.

int getLastError();

Return the most recent error associated with the shared memory segment.

char *getName();

Return the name of the shared memory segment.

void mapGsm(char *gsmName, int gsmSize);

Map the shared memory segment into the current process under the specified name.

int clearGsm();

Zero the entire shared memory segment.

int saveGsm(char *fileName);

Write a binary copy of the shared memory segment to the specified disk file.

int restoreGsm(char *fileName);

Read a binary copy of the shared memory segment from the specified disk file.

The data dictionary allows global common variables to be referenced by their string name.  At runtime, the Data Dictionary is itself maintained in a shared memory segment, and thus the tpriGsmDDCom class is derived from the tpriGsm class.

The following public member functions are provided as part of the tpriGsmDDCom class above and beyond the default tpriGsm member functions:

static int Create(int create = 0);

Start the data dictionary for the current process.

static int Destroy();

Shut down the data dictionary for the current process.

static char *getVarName(char *pName);

Parse the true variable name from a possibly augmented (with <, >, =, etc. characters) name.

static void *getVarPtr(char *pName, long *pSize = NULL,

    unsigned short *pVType = NULL,

 long *pOffset = NULL);

Return a pointer to the specified variable in memory and optionally return the variable’s size, type, and offset.

static long getVarSize(char *pName);

Return the size of the specified variable.

static VARIANT getVariant(char *pName, void **pPtr = NULL, long *pSize = NULL);

Return a VARIANT object containing the current value of the specified variable, and optionally return parameters to use to update the variant.

static int updateVariant(VARIANT *var, void *ptr, long size);

Update the specified variant using the parameters returned from getVariant(..).

static int writeVariant(VARIANT *var, void *ptr, long size, VARIANT *orig);

Write the value of the specified variant back to the memory associated with the original variant.

static unsigned short getVarType(char *pName);

Return the data type of the specified variable.

static const char *getVarTypeName(char *pName);

Return a string description of the data type of the specified variable.

static unsigned long getVarGsmMask(char *pName);

Return the GSM Mask bitmask for the specified variable.

static const void *getVarInitPtr(char *pName);

Return a pointer to the initial value associated with the specified variable.

static const void *getVarMinPtr(char *pName);

Return a pointer to the minimum value associated with the specified variable.

static const void *getVarMaxPtr(char *pName);

Return a pointer to the maximum value associated with the specified variable.

static const char *getVarFmt(char *pName);

Return a pointer to the formatting string associated with the specified variable.

static const char *getVarDesc(char *pName);

Return a pointer to the description associated with the specified variable.

static const char *fmtVarInit(char *pName);

Return a pointer to a string containing the initial value of the specified variable formatted according to it’s formatting string.

static const char *fmtVarMin(char *pName);

Return a pointer to a string containing the minimum value of the specified variable formatted according to it’s formatting string.

static const char *fmtVarMax(char *pName);

Return a pointer to a string containing the maximum value of the specified variable formatted according to it’s formatting string.

static int setVarInit(char *pName, void *pData);

Set the initial value of the specified variable.

static int setVarMin(char *pName, void *pData);

Set the minimum value of the specified variable.

static int setVarMax(char *pName, void *pData);

Set the maximum value of the specified variable.

static int setVarFmt(char *pName, char *pFmt);

Set the formatting string of the specified variable.

static int setVarDesc(char *pName, char *pDesc);

Set the description of the specified variable.

static int setVarData(char *pName, void *pData);

Set the current value of the specified variable.

static int getStructInfo(char *pName, long *size,

 unsigned short *vType, long *offset);

Return various structure information about the specified variable.

static int traverseTree(char *pName,

unsigned long mask = GSMDEFMASK_ALL);

Traverse the data dictionary tree and export the name of each leaf to the specified buffer.

static int searchTree(char *strSearch, char *pName);

Search the data dictionary tree for the given string and return the name of the first variable containing the search string.

static tpriGsm *findTpriGsm(char *gsmName);

Return a pointer to the tpriGsm object associated with the specified GSM name.

static void *mapGsm(char *varName, int create /* = 0 */);

Map or create the specifed GSM region.

static int attachGsm(tpriGsm **ppGsm, char *varName,

  char *varType, char *mask,

  char *ascFile, int takeCtrl /* = 1 */);

Attach an existing tpriGsm object into the data dictionary.

static int mapAllGsm(int create = 0);

Map all GSM regions into the current process.

static int restoreGsm(char *gsmName, char *fileName = NULL);

Perform a binary restore of the specified GSM from an existing disk file.

static int restorePersist(char *varName,

  char *fileName = NULL);

static int restorePersist(char *varName,

  tpriIniFile *pIniFile);

Restore the given variable by name from the specified file.

static int restoreAllPersist(char *fileName = NULL);

Restore all variables in the specified file by name.

static int restorePersistByList(char *listFile, char *listSect,

        char *varFile = NULL);

Restore a list of variables identified in one file from a second data file.  The variable list should be stored in [listSect] of the file listFile with one variable name per line.  The variable data will be restored from the file varsFile or, if NULL, in the persistent data file specified for each variable's global common in the data dictionary variable initialization file.

static int saveGsm(char *gsmName, char *fileName = NULL);

Perform a binary save of the specified GSM to a disk file.

static int savePersist(char *varName, char *fileName = NULL);

static int savePersist(char *varName, tpriIniFile *pIniFile);

Save the given variable by name from the specified file.

static int saveAllPersist(char *fileName = NULL);

Save all variables in the specified file by name.

static int savePersistByList(char *listFile, char *listSect,

     char *varFile = NULL);

Save a list of variables identified in one file from a second data file.  The variable list should be stored in [listSect] of the file listFile with one variable name per line.  The variable data will be stored in the file varsFile or, if NULL, in the persistent data file specified for each variable's global common in the data dictionary variable initialization file.

The tpriLogMsg class provides a way for processes to post text messages to global queues for later processing or asynchronous display.  The available queues are defined at system startup time through an ini file.  In addition, there is always a default queue named “LogMsg” to which any process may post messages.  Messages in this default queue are displayed on the NtRtMgr console.  While only a finite number of messages are kept in memory (specifically, the last 512), the NtRtMgr automatically logs messages posted to these queues to files on the disk.

DumpHex is a utility function that uses the LogMsg function to display the contents of a memory area in both hex and ascii formats.  

An entry in the system initialization file (i.e. that file which is passed on the command line to the NtRtMgr) specifies the LogMsg specific initialization file.  The following entry must be found in the [General] section of the system initialization file:

# Define the LogMsg initialization file

Logs=D:\locNtRt\sys\pif\sysLogs.ini

An example of a sysLogs.ini file follows:

#  LogMsg Initialization File
 
[General]
# Specify the disk log directory for the default "LogMsg" queue.
LogMsgDir=D:\locNtRt\sys\Logs

# Specify the default maximum number of days to keep files in
# the above directory.
#LogMsgMaxDays=90

[Queues]
#Specify any additional queues.
#Queue Name    #Disk log directory       #Max Days
OprMsgD:\locNtRt\sys\Logs       100

The following are examples of log message calls

// this is a normal LogMsg call
LogMsg("myFunction", DBDEBUG, "Log this message\n");

// this LogMsg call does the same thing as the above call
LogMsg("myFunction", "LogMsg" DBDEBUG, "Log this message\n");

// this LogMsg call sends the message instead to the OprMsg queue
LogMsg("myFunction", "OprMsg" DBDEBUG, "Log this message\n");

// this LogMsg call sends the message to both queues
LogMsg("myFunction", "LogMsg&OprMsg" DBDEBUG, "Log this message\n");

The following structure is used to define a single log message stored in any one of the message queues:

#define MAX_LOGMSG_NAME       32       // max size of process/function name
#define MAX_LOGMSG_CHARS      256      // max size of single message
#define MAX_LOGMSGS  512      // Max messages in a queue

struct s_LogMsg
   {
   long idx;// index of message
   struct timestamp 
      {
      long seconds;  // seconds since 1/1/1970
      long nanoseconds;       // nanoseconds past seconds
      } dt; // time of message
   char proc[MAX_LOGMSG_NAME];// name of process that generated message
   char func[MAX_LOGMSG_NAME];// name of function that generated message
   char msg[MAX_LOGMSG_CHARS];// message text
   };

The following code sequentially processes messages from a tpriLogMsg queue.

static int msgIdx = -1;
   int lastIdx;
   s_LogMsg msgInfo;

   // check for any new messages
   lastIdx = tpriLogMsg::getLastIdx("MsgQueue");
   if (lastIdx >= (msgIdx + MAX_LOGMSGS))
      {
      if (msgIdx >= 0)
{
// we lost some messages
LogMsg("Tc1CsfMsg", DBERR, "Lost >= %d messages from MsgQueue\n",
   lastIdx - msgIdx);
}

      // just start up again with the latest
      msgIdx = lastIdx;
      }

   while (lastIdx > msgIdx)
      {
      // get the next message
      msgIdx += 1;
      fstatus = tpriLogMsg::getLogMsg("MsgQueue", msgIdx, &msgInfo);
      if (fstatus != 0)
{
LogMsg("Tc1CsfMsg", DBERR, "Error %d retrieving MsgQueue[%d]\n",
   fstatus, msgIdx);
}
      else
{
// process the message ...
}
      }

This class defines basic .ini file operations, such as opening the file, finding a section (denoted '[SectionName]", retrieving lines from the file, and closing them when finished.

The following public member functions are provided as part of the tpriIniFile class:

• tpriIniFile(char *pfileName);
Constructor for the ini file class, passed file name as character string.

• tpriIniFile(FILE *fp);
Constructor for the ini file class, passed file descriptor.

• tpriIniFile(char *pBuf,int nBytes);
Constructor for the ini file class; passed file as array of characters.

• ~tpriIniFile();
Destructor for the ini file class.

• int findSection(char *sectionName);
Find a section within the file and prepare to read the lines immediately following.

• int getLineCount(char *sectionName);
Get the count of lines in a given section.

• int getNextLine(char *pLine, int szLine);
Get the next valid (non-comment, non-whitespace) line in the ini file.

• int getKeyValue(char *keyName, char *defValue, char *pValue, int szValue);
Get a key within the current section.

• int getKeyValues (char *keyName, char *defValue, char *pValue, int szValue, const char *fmt, int cnt, _);
Get a key within the curent section. Decode using the format "fmt" and return values in passed variables.

• int getKeyValue(char *sectionName, char *keyName, char *defValue, char *pValue, int szValue);
Get the value associated with a section/key in the ini file.

• int getKeyValues (char *sectionName, char *keyName, char *defValue, char *pValue, int szValue, const char *fmt, int cnt, _);
Get the value associated with a section/key in the ini file. Decode using the format "fmt" and return values in passed variables.

• int getKeyValueEnv(char *keyName, char *defValue, char *pValue, int szValue);
Get a key within the current section and translate any environment variables out of the value.

• int getKeyValueEnv(char *sectionName, char *keyName, char *defValue, char *pValue, int szValue);
Get the value associated with a section/key in the ini file and translate any of the environment variables out of the value.

• int setKeyValue(char *sectionName, char *keyName, char *pValue);
Set the value associated with a section/key in the ini file.

• int writeLine(char *cStr);
Write a line to the ini file.

• int cleanSection(char *sectionName);
Clean all the lines of data out of a section.

• int deleteSection(char *sectionName);
Delete an entire section from the ini file.

• int deleteKey(char *sectionName, char *keyName);
Delete the specified key from the specified section.

• int deleteLine();
Delete a line from the ini file.

• int commit();
Commit any changes back to disk.

• inline int getError();
Get error/return status.

• inline const char *getBuffer();
Return pointer to ini file buffer.

• inline int getSize();
Return file size in bytes.

• static int getLineCount(char *sectionName, char *fileName);
Return the number of lines in a given section.

• static int getKeyValue(char *sectionName, char *keyName, char *defValue, char *pValue, int szValue, char *fileName);
Get the value associated with a section/key in the ini file.

• static int getKeyValues (char *sectionName, char *keyName, char *defValue, char *pValue, int szValue, char *filename, const char *fmt, int cnt, _);
Get the value associated with a section/key in the ini file "filename". Decode using the format "fmt" and return values in passed variables.

• static int getKeyValueEnv(char *sectionName, char *keyName, char *defValue, char *pValue, int szValue, char *fileName);
Get the value associated with a section/key in the ini file and translate any environment variables out of the value.

• static int setKeyValue(char *sectionName, char *keyName, char *pValue, char *fileName);
Set the value associated with a section/key in the ini file.

• static int cleanSection(char *sectionName, char *fileName);
Clean all the lines of data out of a section in an ini file.

• static int deleteSection(char *sectionName, char *fileName);
Delete an entire section in an ini file.

• static int deleteKey(char *sectionName, char *keyName, char *fileName);
Delete the specified key from the specified section in an ini file.

• static char *extractIniString(char *pbuf);
Extract a string from an ini initialization line. If the first non-whitespace character is a double quotes, the string is assumed to be contained within a pair of quotes. Otherwise, the string is space delimited.

These functions encompass basic timer functions. These functions may be called by any application task to set and test timers. The timer values are allocated and maintained in user defined variables and are tested by user calls. 

The following public functions are provided as part of the tpriTimer support:

• TIMERVAL SetUTimer (int us);
Return the value of a timer that will expire in 'us' microseconds.
If us = 0, turn timer off

• TIMERVAL SetMTimer (int ms);
Return the value of a timer that will expire in 'ms' milliseconds.
If ms = 0, turn timer off

• TIMERVAL SetSTimer (int s);
Return the value of a timer that will expire in 's' seconds.
If s = 0, turn timer off

• TIMERVAL AddUTimer (TIMERVAL timer, int us);
Return the value of a timer that is set to expire 'us' microseconds after (if 'us' is positive) or before (if 'us' is negative) the timer value passed in 'timer'.  The current passed 'timer' may be scheduled to expire in the future or may have already expired.  If 'timer' is off (inactive), set the timer to expire 'us' microseconds into the future.

• TIMERVAL AddMTimer (int ms);
Return the value of a timer that is set to expire 'ms' milliseconds after (if 'ms' is positive) or before (if 'ms' is negative) the timer value passed in 'timer'.  The current passed 'timer' may be scheduled to expire in the future or may have already expired. If 'timer' is off (inactive), set the timer to expire 'us' microseconds into the future.

• TIMERVAL AddSTimer (int s);
Return the value of a timer that is set to expire 's' seconds after (if 's' is positive) or before (if 's' is negative) the timer value passed in 'timer'.  The current passed 'timer' may be scheduled to expire in the future or may have already expired.  If 'timer' is off (inactive), set the timer to expire 'us' microseconds into the future.

• __int64 RemUTimer (TIMERVAL timer);
Return the value of the time in microseconds remaining on timer 'timer'.  If the timer has already expired, return the number of microseconds in the past as a negative number.  If the timer is off (inactive), return a value of zero.

• TIMERVAL AddMTimer (int ms);
Return the value of the time in milliseconds remaining on timer 'timer'.  If the timer has already expired, return the number of milliseconds in the past as a negative number.  If the timer is off (inactive), return a value of zero.

• TIMERVAL AddSTimer (int s);
Return the value of the time in seconds remaining on timer 'timer'.  If the timer has already expired, return the number of seconds in the past as a negative number.  If the timer is off (inactive), return a value of zero

• int TstTimer(TIMERVAL timer);
Test for current status of the timer 'timer'
Return value as as follows:
+1 = Timer still active and not timed out yet
0  = Timer is off (inactive)
-1 = Timer has timed out