OSservices.cpp File Reference

#include "FirstIncludes.h"
#include <direct.h>
#include <windows.h>
#include <Lmcons.h>
#include <conio.h>
#include <ctype.h>
#include <errno.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#include "MemoryDebug.h"
#include "OSservices.h"
#include "ImageIO.h"
#include "KKStr.h"

Go to the source code of this file.

Macros
#define	_FILE_OFFSET_BITS   64
#define	INVALID_FILE_ATTRIBUTES   ((DWORD)-1)
#define	INVALID_FILE_ATTRIBUTES   ((DWORD)-1)

Functions
bool	osFileNameMatchesSearchFields (const KKStr &fileName, KKStrListPtr searchFields)
int	osLocateEnvStrStart (const KKStr &str, kkint32 startIdx)
KKStrListPtr	osParseSearchSpec (const KKStr &searchSpec)

Variables
bool	backGroundProcess = false

Macro Definition Documentation

#define _FILE_OFFSET_BITS   64

Definition at line 7 of file OSservices.cpp.

#define INVALID_FILE_ATTRIBUTES   ((DWORD)-1)

#define INVALID_FILE_ATTRIBUTES   ((DWORD)-1)

Function Documentation

bool osFileNameMatchesSearchFields	(	const KKStr &	fileName,
		KKStrListPtr	searchFields
	)

Definition at line 180 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Len(), KKB::KKStr::operator==(), and KKB::KKStr::Str().

{
  if  (!searchFields)
    return  true;

  if  (searchFields->QueueSize () < 1)
    return true;

  KKStrConstPtr  field = searchFields->IdxToPtr (0);

  if  (searchFields->QueueSize () == 1)
  {
    if  (*field == "*")
      return  true;

    if  (*field == fileName)
      return true;
    else
      return false;
  }
 
  bool  lastFieldAStar = false;

  const char*  cp = fileName.Str ();
  kkuint32     lenLeftToCheck = fileName.Len ();

  kkint32  fieldNum;

  for  (fieldNum = 0;  fieldNum < searchFields->QueueSize ();  fieldNum++)
  {
    const KKStr&  field = *(searchFields->IdxToPtr (fieldNum));
    
    if  (field == "*")
    {
      lastFieldAStar = true;
    }
    else
    {
      if  (lastFieldAStar)
      {
        // Since last was a '*'  then we can skip over characters until we find a sequence that matches field

        bool  matchFound = false;

        while  ((!matchFound)  &&  (lenLeftToCheck >= field.Len ()))
        {
          if  (strncmp (cp, field.Str (), field.Len ()) == 0)
          {
            matchFound = true;
            // lets move cp beyond where we found field in fileName
            cp = cp + field.Len ();
            if  (field.Len() > lenLeftToCheck)
              lenLeftToCheck = 0;
            else
              lenLeftToCheck = lenLeftToCheck - field.Len ();
          }
          else
          {
            ++cp;
            --lenLeftToCheck;
          }
        }

        if  (!matchFound)
        {
          // There was no match any were else in the rest of the fileName.
          // way that this fileName is a match.
          return  false;
        }
      }
      else
      {
        // Since last field was  NOT   a '*' the next field->Len () characters better be an exact match
        if  (lenLeftToCheck < field.Len ())
        {
          // Not enough chars left in fileName to check,  can not possibly be a match
          return  false;
        }

        if  (strncmp (cp, field.Str (), field.Len ()) != 0)
        {
          // The next field->Len ()  chars were not a match.  This means that fileName is
          // not a match.
          return  false;
        }
        else
        {
          cp = cp + field.Len ();
          lenLeftToCheck = lenLeftToCheck - field.Len ();
        }
      }

      lastFieldAStar = false;
    }
  }


  if  (lenLeftToCheck > 0)
  {
    // Since there are some char's left in fileName that we have not checked,  then 
    // the last field had better been a '*'
    if  (lastFieldAStar)
      return true;
    else
      return false;
  }
 
  return true;
}  /* osFileNameMatchesSearchFields */

int osLocateEnvStrStart	(	const KKStr &	str,
		kkint32	startIdx
	)

Searches a string starting from a specified index for the start of an Environment String Specification.

                       1         2         3         4         5         6
ex:          0123456789012345678901234567890123456789012345678901234567890123456789 
      str = "TrainingDirectory\${LarcosHomeDir}\Classifiers\${CurTrainLibrary"

 idx = osLocateEnvStrStart (str, 0);  // returns 18
 idx = osLocateEnvStrStart (str, 34)  // returns 47

Parameters

str	Starting that is to be searched.
startIdx	Index search is to start at.

Returns

Index of 1st character of a Environment String specifier or -1 if none was found.

Parameters

startIdx

Index in 'str' to start search from.

Definition at line 948 of file OSservices.cpp.

References KKB::KKStr::Len(), and KKB::KKStr::Str().

Referenced by KKB::osSubstituteInEnvironmentVariables().

{
  int  x = startIdx;
  int  y = startIdx + 1;
  int  len = str.Len ();
  const char*  s = str.Str ();

  while  (y < len)
  {
    if  (s[y] == 0)
      return -1;

    if  (s[x] == '$')
    {
      if  ((s[y] == '(')  ||  (s[y] == '{')  ||  (s[y] == '['))
        return  x;
    }

    ++x;
    ++y;
  }

  return  -1;
}  /* LocateEnvStrStart */

KKStrListPtr osParseSearchSpec

(

const KKStr &

searchSpec

)

Definition at line 131 of file OSservices.cpp.

References KKB::KKStr::Empty(), and KKB::KKStrList::KKStrList().

{
  KKStrListPtr  searchFields = new KKStrList (true);

  if  (searchSpec.Empty ())
  {
    searchFields->PushOnBack (new KKStr ("*"));
    return  searchFields;
  }

# ifdef  USE_SECURE_FUNCS
    char*  workStr = _strdup (searchSpec.Str ());
# else
    char*  workStr = strdup (searchSpec.Str ());
# endif
  
  char*  cp = workStr;

  char*  startOfField = cp;

  while  (*cp != 0)
  {
    if  (*cp == '*')
    {
      *cp = 0;
      if  (startOfField != cp)
         searchFields->PushOnBack (new KKStr (startOfField));

      searchFields->PushOnBack (new KKStr ("*"));
      startOfField = cp + 1;
    }
    cp++;
  }
  
  if  (cp != startOfField)
  {
    // There is one last field that we need to add,  meaning that there was no '*'s  or
    // that the last char in the searchField was not a '*'.
    searchFields->PushOnBack (new KKStr (startOfField));
  }

  delete  workStr;

  return  searchFields;
}  /*  osParseSearchSpec */

Variable Documentation

bool backGroundProcess = false

Definition at line 1495 of file OSservices.cpp.

Referenced by KKB::osIsBackGroundProcess(), KKB::osRunAsABackGroundProcess(), and KKB::osWaitForEnter().