/*
  SRPLUGIN.HPP
  Plugin API for S&R 2.5

  Copyright (c) Ivan Sintyurin (http://www.moris.ru/~spinoza, spinoza@mail.ru)
*/

#ifndef __srplugin_hpp
#define __srplugin_hpp

#if defined(__BORLANDC__)
  #pragma option -a2
#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__)
  #pragma pack(2)
  #if defined(__LCC__)
    #define _export __declspec(dllexport)
  #endif
#else
  #pragma pack(push,2)
  #if _MSC_VER
    #define _export
  #endif
#endif

#define MAKE_SANDRVERSION(major,minor,build) (((major)<<8) | (minor) | ((build)<<16))
const DWORD SANDR_VERSION=MAKE_SANDRVERSION(2,5,0);

#define MATCHESNUM 0x10

struct SRPluginInfo
{
  DWORD StructSize;
  DWORD Flags;
  char  MenuString[64];
  DWORD SR_MinVer; // минимальная версия S&R, на которую рассчитан плагин,
                   // влияет на запуск функции Run плагина (в формате
                   // SANDR_VERSION)
  DWORD SR_MaxVer; // максимальная версия S&R, на которую рассчитан плагин
                   // (если SR_MaxVer=0, то Run будет вызываться под всеми
                   // версиями S&R, начиная с SR_MinVer)
};

enum SRPI_FLAGS        // флаги для SRPluginInfo
{
   SRPIF_PANEL  = 0x00000001,
   SRPIF_CONFIG = 0x00000002,
   SRPIF_EDITOR = 0x00000004,
   SRPIF_VIEWER = 0x00000008,
};

const int MAXNAMESIZE=512;

typedef DWORD CSearchRegExp;
typedef DWORD CReplaceRegExp;
typedef DWORD CFileSearch;
typedef DWORD CSchemes;
typedef DWORD EXTENDEDSEARCHOPTIONS;
typedef DWORD CFileMask;
typedef DWORD CMatchHash;
typedef DWORD CFileSecurity;
typedef DWORD CFileAttributes;

struct SMatch
{
  int s,e;
};

// структура содержит некоторые данные по работе программы
struct SRWORKSTATUS
{
  char  file1[MAXNAMESIZE];
  char  file2[MAXNAMESIZE];
  DWORD ExitCode;      // 0 или код, вызвавший прекращение работы
  DWORD LastError;     // системный код ошибки (GetLastError)
  DWORD Reserved;      // должно быть 0
};

enum SRW_ERROR_CODE    // Коды ошибок для SRWORKSTATUS.ExitCode
{
  SRWE_OK          =0, // Все OK, нормальное завершение работы
  SRWE_OPENFILE    =1, // Ошибка открытия файла            (имя файла в .file1)
  SRWE_READFILE    =2, // Ошибка чтения из файла           (имя файла в .file1)
  SRWE_ALLOC       =3, // Не удалось выделить память
  SRWE_OPENTEMPFILE=4, // Не удалось открыть временный файл(имя файла в .file2)
  SRWE_WRITEFILE   =5, // Ошибка записи в файл             (имя файла в .file2)
  SRWE_RENAMEFILE  =6, // Ошибка переименования            (.file1 в .file2)
  SRWE_ESCAPE      =7, // Работа прервана пользователем/нажата Esc/
  SRWE_RRE_FILL    =8, // Ошибка формирования буфера замены
                       // (например в CReplaceRegExp)
};

enum FM_FLAGS          // флаги для FM_Set
{
  FMF_SILENT            = 0x00000001,
  FMF_FORBIDEXCLUDE     = 0x00000002,
  FMF_EXPANDENVIRONMENT = 0x00000004,
  FMF_DELETEENDSLASH    = 0x00000008,
  FMF_DONOTSKIPPATH     = 0x00000010,
};

enum FS_SET_FLAGS     // флаги для FS_Set
{
  FSSF_PROCESSSUBDIR  = 0x00000008,
  FSSF_PROCESSDIR     = 0x00000010,
  FSSF_SILENT         = 0x00000020,
  FSSF_ONLYDIR        = 0x00000040,
};

enum FS_SEARCHMODE { FSSM_SELECTION, FSSM_MASK, FSSM_LIST };

enum FS_ERROR_CODE       // возвращается из FS_Set
{
  FSE_SUCCESS,           // нет ошибок
  FSE_FILEMASK,          // некорректная маска файлов
  FSE_NEEDREALFILEPANEL, // требуется обычная файловая панель
  FSE_DIRLIST,           // некорректный список каталогов
  FSE_ARGUMENT,          // неправильный параметр
  FSE_ALLOC,             // проблема выделения памяти
  FSE_WRONGSEARCHMODE,   // указан неправильный режим поиска
  FSE_EXCLUDEDIRMASK,    // некорректная маска каталогов-исключений
  FSE_ERROR=0xFFFFFFFF,  // внутренняя ошибка
};

enum CHARACTER_SET_TYPE // тип кодировки
{
  CST_OEM, CST_ANSI, CST_UNICODE, CST_FAR, CST_ALL
};

// структура содержит настройки по некоторой кодировке
struct CHARACTERSET
{
  DWORD CodePage;  // CHARACTER_SET_TYPE
  int   TableNum;  // Номер таблицы ФАРа
};

enum SRP_OPENFROM {SRPO_PANEL, SRPO_CONFIG, SRPO_EDITOR, SRPO_VIEWER};

//////////////////////////////////////////////////////////////////////////////
enum SR_COMMAND_TYPE{
  SRC_GETVERSION,
  SRC_GETSTRING,
  SRC_GETSETTING,
  SRC_QUESTION,
  SRC_GOTOFILE,
  SRC_ERRORMSG,
  SRC_GETSYSTEMMSG,
  SRC_ASKPROCESSROFILE,
};

enum SR_STRING_ID{
  SRSTR_MASKHIST,
  SRSTR_SEARCHHIST,
  SRSTR_REPLACEHIST,
  SRSTR_DIRECTORYHIST,
  SRSTR_SAVETOFILEHIST,
};

enum SR_SETTING_ID{
  SRSET_NOSLASH,
  SRSET_PSIS,
};

struct SR_CMD_GetString
{
  SR_STRING_ID id;      // тип строки
  char        *Dest;    // указатель на буфер для получения строки
  DWORD        MaxSize; // размер этого буфера, в буфер будет скопировано
                        // символов (MaxSize-1)
  DWORD        Size;    // получит размер строки (с учетом завершающего нуля)
};

struct SR_CMD_GetSetting
{
  SR_SETTING_ID id;     // тип числа
  DWORD         Value;  // получит число
};

struct SR_CMD_Question
{
  const char *Title; // заголовок вопроса
  const char *Line1; // первая,
  const char *Line2; // вторая
  const char *Line3; // и третья строка сообщения
  DWORD Flags; // Flags - такие же, как и для простых сообщений FarMessage
};

struct SR_CMD_ErrorMsg
{
  const struct SRWORKSTATUS *srws;
  BOOL   Warning; // тип сообщения - warning (TRUE) или problem (FALSE)
};

struct SR_CMD_GetSystemMsg
{
  BOOL  UseGetLastError; // Если FALSE, то код ошибки берется из Error,
                         // иначе - путем вызова GetLastError()
  DWORD Error;           // код ошибки (учитывается, если UseGetLastError=FALSE)
  char *Dest;            // указатель на буфер, в который будут записаны
                         // полученные строки. После каждой строки пишется
                         // символ 0x00, после последней строки - два символа
                         // 0x00
  DWORD DestSize;        // размер Dest. Должен быть не меньше 3
  DWORD LineSize;        // требуемый размер строки. Получамые при работе
                         // строки могут иметь и меньший размер из-за того,
                         // что убираются лишние пробелы и функция пытается
                         // не разрезать пополам слова, которые оказываются
                         // на стыке строк. Если LineSize равно 0, то разбиение
                         // на строки не производится
};

struct SR_CMD_AskProcessROFile
{
  const char *FileName;
  const char *Info;
  const char *Question;
  BOOL  OnlyYesNo;
};

typedef DWORD (WINAPI *SRAPI_CMD)(
  SR_COMMAND_TYPE CMD,
  void *Param
);

//////////////////////////////////////////////////////////////////////////////
typedef int (WINAPI *SRAPI_VIEWERCONTROL)(
  int Command,
  void *Param
);

/////////////////////////////////////////////////////////////////////////////
typedef void (WINAPI *SRAPI_INITLOCMSG)(const char *ModuleName, char *Dest);

typedef char*(WINAPI *SRAPI_LOCMSG)(
  const char *MsgFileName,
  const char *MsgName,
  char *Dest,
  int maxsize
);

//////////////////////////////////////////////////////////////////////////////
// объект: расширенные параметры поиска
typedef EXTENDEDSEARCHOPTIONS*(WINAPI *SRAPI_ESO_CREATE)(void);
typedef void (WINAPI *SRAPI_ESO_DELETE)(EXTENDEDSEARCHOPTIONS **eso);
typedef BOOL (WINAPI *SRAPI_ESO_GETMODE)(const EXTENDEDSEARCHOPTIONS *eso);

typedef void (WINAPI *SRAPI_ESO_SETMODE)(
  EXTENDEDSEARCHOPTIONS *eso,
  BOOL Mode
);

// идентификаторы расширенных параметров поиска
enum ESO_PARAM_ID{
  ESO_ID_MINSIZE=1,  // минимальный размер файла
  ESO_ID_MAXSIZE,    // максимальный размер файла
  ESO_ID_PRCMINSIZE, // учитывать ESO_ID_MINSIZE
  ESO_ID_PRCMAXSIZE, // учитывать ESO_ID_MAXSIZE
  ESO_ID_MINTIME,    // обрабатывать файлы с датой такой или позже
  ESO_ID_MAXTIME,    // обрабатывать файлы с датой такой или меньше
  ESO_ID_PRCMINTIME, // учитывать ESO_ID_MINTIME
  ESO_ID_PRCMAXTIME, // учитывать ESO_ID_MACTIME
  ESO_ID_TIMETYPE,   // тип даты (ESO_TIME_TYPE)
  ESO_ID_ATTRIBUTES, // атрибуты нужных файлов (AttributesSet)
};

// тип даты файла (см. ESO_PARAM_ID)
enum ESO_TIME_TYPE{
  ESO_TIME_CREATION,
  ESO_TIME_ACCESS,
  ESO_TIME_WRITE,
};

// атрибуты файлов (см. ESO_PARAM_ID)
struct AttributesSet
{
  BOOL  Process;    // Если TRUE. то обрабатывать атрибуты
  BOOL  SearchInReparsePoint; // входить в "каталоги-связи"
  DWORD Archive;    // Каждое следующее поле принимает одно из значений:
  DWORD Hidden;     // 0 - атрибут должен быть сброшен
  DWORD ReadOnly;   // 1 - атрибут должен быть установлен
  DWORD System;     // любое другое значение - атрибут игнорируется
  DWORD Compressed;
  DWORD Encrypted;
};

typedef BOOL (WINAPI *SRAPI_ESO_GETPARAM)(
  const EXTENDEDSEARCHOPTIONS *eso,
  DWORD Param_ID,
  void *Value
);

typedef BOOL (WINAPI *SRAPI_ESO_SETPARAM)(
  EXTENDEDSEARCHOPTIONS *eso,
  DWORD Param_ID,
  void *Value
);

typedef void (WINAPI *SRAPI_ESO_COPY)(
  const EXTENDEDSEARCHOPTIONS *src,
  EXTENDEDSEARCHOPTIONS *dest
);

typedef BOOL (WINAPI *SRAPI_ESO_EDIT)(EXTENDEDSEARCHOPTIONS *eso);

typedef BOOL (WINAPI *SRAPI_ESO_LOAD)(
  const char *RootKey,
  const char *Key,
  EXTENDEDSEARCHOPTIONS *eso
);

typedef BOOL (WINAPI *SRAPI_ESO_SAVE)(
  const char *RootKey,
  const char *Key,
  const EXTENDEDSEARCHOPTIONS *eso
);

typedef BOOL (WINAPI *SRAPI_ESO_COMPAREWFD)(
  const EXTENDEDSEARCHOPTIONS *eso,
  const WIN32_FIND_DATA *wfd
);

//////////////////////////////////////////////////////////////////////////////
// регулярные выражения для поиска
typedef CSearchRegExp*(WINAPI *SRAPI_RE_CREATE)(void);
typedef void (WINAPI *SRAPI_RE_DELETE)(CSearchRegExp **re);

typedef BOOL (WINAPI *SRAPI_RE_SETEXPR)(
  CSearchRegExp *re,
  char *Expr,
  struct CharTableSet *CTS,
  DWORD Reserved
);

typedef BOOL (WINAPI *SRAPI_RE_SEARCH)(
  const CSearchRegExp *sre,
  const char *datastart,
  const char *textstart,
  const char *textend,
  struct SMatch *match,
  DWORD *matchcount,
  CMatchHash *hmatch,
  DWORD Reserved
);

typedef BOOL (WINAPI *SRAPI_RE_MATCH)(
  const CSearchRegExp *sre,
  const char *datastart,
  const char *textstart,
  const char *textend,
  struct SMatch *match,
  DWORD *matchcount,
  CMatchHash *hmatch,
  DWORD Reserved
);

typedef int (WINAPI *SRAPI_RE_LASTERROR)(const CSearchRegExp *sre);

//! Possible compile and runtime errors returned by LastError.
enum REError{
  //! No errors
  errNone=0,
  //! RegExp wasn't even tried to compile
  errNotCompiled,
  //! expression contain syntax error
  errSyntax,
  //! Unbalanced brackets
  errBrackets,
  //! Max recursive brackets level reached. Controled in compile time
  errMaxDepth,
  //! Invalid options combination
  errOptions,
  //! Reference to nonexistent bracket
  errInvalidBackRef,
  //! Invalid escape char
  errInvalidEscape,
  //! Invalid range value
  errInvalidRange,
  //! Quantifier applyed to invalid object. f.e. lookahed assertion
  errInvalidQuantifiersCombination,
  //! Size of match array isn't large enough.
  errNotEnoughMatches,
  //! Attempt to match RegExp with Named Brackets, and no storage class provided.
  errNoStorageForNB,
  //! Reference to undefined named bracket
  errReferenceToUndefinedNamedBracket,
  //! Only fixed length look behind assertions are supported
  errVariableLengthLookBehind,
};

typedef int (WINAPI *SRAPI_RE_ERRORPOSITION)(const CSearchRegExp *sre);
typedef int (WINAPI *SRAPI_RE_GETBRACKETSCOUNT)(const CSearchRegExp *sre);

//////////////////////////////////////////////////////////////////////////////
// регулярные выражения для замены
typedef CReplaceRegExp*(WINAPI *SRAPI_RRE_CREATE)(struct SRWORKSTATUS *srws);
typedef void (WINAPI *SRAPI_RRE_DELETE)(CReplaceRegExp **rre);

typedef BOOL (WINAPI *SRAPI_RRE_SETEXPR)(
  CReplaceRegExp *rre,
  const char *Expr,
  const CharTableSet *ctsin,
  const CharTableSet *ctsout,
  DWORD Reserved
);

typedef BOOL (WINAPI *SRAPI_RRE_CHECKLENGTH)(const CReplaceRegExp *rre);

typedef int  (WINAPI *SRAPI_RRE_FILL)(
  CReplaceRegExp *rre,
  SMatch *Match,
  const DWORD TotalMatches,
  const BYTE *fromBuf,
  const WIN32_FIND_DATA *wfd,
  const char *Root,
  CMatchHash *mthsh,
  DWORD Reserved
);

typedef const BYTE*(WINAPI *SRAPI_RRE_GETBUFFER)(const CReplaceRegExp *rre);
typedef void (WINAPI *SRAPI_RRE_SETCOUNTER)(CReplaceRegExp *rre, int value);
typedef int  (WINAPI *SRAPI_RRE_GETCOUNTER)(const CReplaceRegExp *rre);

//////////////////////////////////////////////////////////////////////////////
// класс для поиска объектов по дискам
typedef void (WINAPI *FSPROCESSITEMCALLBACK)(
  WIN32_FIND_DATA *wfd,
  void *UserData
);

typedef void (WINAPI *FSPROCESSCHANGEDIRCALLBACK)(
  void *UserData,
  DWORD *Param,
  int Reason
);

typedef void (WINAPI *SHOWPROGRESS)(const char *Name);

typedef CFileSearch*(WINAPI *SRAPI_FS_CREATE)(void);
typedef void (WINAPI *SRAPI_FS_DELETE)(CFileSearch **fs);

typedef DWORD (WINAPI *SRAPI_FS_SET)(
  CFileSearch *fs,
  DWORD searchmode,
  DWORD Flags,
  const EXTENDEDSEARCHOPTIONS *eso,
  const char *root,
  const char *mask,
  const struct PanelInfo *panelInfo,
  struct SRWORKSTATUS *srws,
  DWORD Reserved
);

typedef void (WINAPI *SRAPI_FS_SEARCH)(
  CFileSearch *fs,
  void *UserData,
  FSPROCESSCHANGEDIRCALLBACK prcCDcb,
  SHOWPROGRESS showprogress,
  FSPROCESSITEMCALLBACK pf,
  DWORD Reserved
);

typedef const char * (WINAPI *SRAPI_FS_GETROOT)(const CFileSearch *fs);

//////////////////////////////////////////////////////////////////////////////
// работа со "схемами"
typedef BOOL (WINAPI *LOADSCHEME)(void *dest, const char *key);
typedef BOOL (WINAPI *SAVESCHEME)(const void *src, const char *key);
typedef int (WINAPI *EDITSCHEME)(void *data,  const char *Name);

typedef CSchemes*(WINAPI *SRAPI_SCHEME_CREATE)(
  const char *RootKey,
  const char *Key,
  const char *Name,
  const char *Total,
  const char *Title,
  void *original,
  void *copy,
  LOADSCHEME loadscheme,
  SAVESCHEME savescheme,
  EDITSCHEME EditScheme,
  DWORD Reserved
);

typedef void (WINAPI *SRAPI_SCHEME_DELETE)(CSchemes **scheme);
typedef int  (WINAPI *SRAPI_SCHEME_MENU)(CSchemes *scheme, int DefaultPos);
typedef BOOL (WINAPI *SRAPI_SCHEME_ADD)(CSchemes *scheme, const void *src);

//////////////////////////////////////////////////////////////////////////////
// работа с настройками
typedef BOOL (WINAPI *SRAPI_WRITESTR)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  const char *ValueData
);

typedef int  (WINAPI *SRAPI_READSTR)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  char *ValueData,
  const char *Default,
  DWORD DataSize
);

typedef BOOL (WINAPI *SRAPI_WRITEDWORD)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  DWORD ValueData
);

typedef int  (WINAPI *SRAPI_READDWORD)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  DWORD Default
);

typedef BOOL (WINAPI *SRAPI_WRITEBYTES)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  const BYTE *ValueData,
  DWORD ValueSize
);

typedef int  (WINAPI *SRAPI_READBYTES)(
  const char *RootKey,
  const char *Key,
  const char *ValueName,
  BYTE *ValueData,
  const BYTE *Default,
  DWORD DataSize
);

typedef BOOL (WINAPI *SRAPI_DELETEKEY)(
  const char *RootKey,
  const char *Key
);

//////////////////////////////////////////////////////////////////////////////
// работа с масками файлов
typedef CFileMask*(WINAPI *SRAPI_FM_CREATE)(void);

typedef void (WINAPI *SRAPI_FM_DELETE)(
  CFileMask **fm
);

typedef BOOL (WINAPI *SRAPI_FM_SET)(
  CFileMask *fm,
  const char *Masks,
  DWORD Flags
);

typedef BOOL (WINAPI *SRAPI_FM_COMPARE)(
  const CFileMask *fm,
  const char *Name
);


//////////////////////////////////////////////////////////////////////////////
// работа с правами доступа
typedef CFileSecurity *(WINAPI *SRAPI_CFSEC_CREATE)(void);

typedef void (WINAPI *SRAPI_CFSEC_DELETE)(
  CFileSecurity **fsec
);

typedef BOOL (WINAPI *SRAPI_CFSEC_GETSECURITY)(
  CFileSecurity *fsec,
  const char *FileName
);

typedef BOOL (WINAPI *SRAPI_CFSEC_SETSECURITY)(
  CFileSecurity *fsec,
  const char *FileName
);

//////////////////////////////////////////////////////////////////////////////
// работа с файловыми атрибутами
typedef CFileAttributes *(WINAPI *SRAPI_CFATTR_CREATE)(void);

typedef void (WINAPI *SRAPI_CFATTR_DELETE)(
  CFileAttributes **fattr
);

typedef DWORD (WINAPI *SRAPI_CFATTR_GETATTR)(
  CFileAttributes *fattr,
  const char *FileName
);

typedef BOOL (WINAPI *SRAPI_CFATTR_SETATTR)(
  CFileAttributes *fattr,
  const char *FileName,
  DWORD NewAttr
);

//////////////////////////////////////////////////////////////////////////////
// таблицы символов
enum CHARACTERSET_FLAGS { CSF_ENABLEUNICODE=0x0001, CSF_ENABLEALL=0x0002 };

typedef BOOL (WINAPI *SRAPI_CS_LOAD)(
  const struct CHARACTERSET *CS,
  struct CharTableSet *CTS
);

typedef BOOL (WINAPI *SRAPI_CS_CHOOSE)(
  struct CHARACTERSET *CS,
  DWORD  Flags
);

//////////////////////////////////////////////////////////////////////////////
// работа с CMatchHash
typedef CMatchHash*(WINAPI *SRAPI_CHASH_CREATE)();
typedef void (WINAPI *SRAPI_CHASH_DELETE)(CMatchHash **chash);

typedef int (WINAPI *SRAPI_CHASH_EXISTS)(
  CMatchHash *chash,
  const char *Key
);

typedef SMatch *(WINAPI *SRAPI_CHASH_SETITEM)(
  CMatchHash *chash,
  const char *Key,
  const SMatch *Value
);

typedef SMatch *(WINAPI *SRAPI_CHASH_GETITEMADDR)(
  CMatchHash *chash,
  const char*Key
);

typedef void (WINAPI *SRAPI_CHASH_FIRST)(CMatchHash *chash);
typedef SMatch *(WINAPI *SRAPI_CHASH_GETNEXT)(CMatchHash *chash);
typedef void (WINAPI *SRAPI_CHASH_EMPTY)(CMatchHash *chash);

//////////////////////////////////////////////////////////////////////////////
struct SRPluginStartupInfo
{
  DWORD                       StructSize;
  SRAPI_CMD                   Cmd;
  SRAPI_INITLOCMSG            InitLocMsg;
  SRAPI_LOCMSG                LocMsg;
  DWORD                       Reserved1[2];

//////////////////////////////////////////////////////////////////////////////
// Viewer API
  SRAPI_VIEWERCONTROL         ViewerControl;
  DWORD                       Reserved2[2];

//////////////////////////////////////////////////////////////////////////////
// объект: расширенные параметры поиска
  SRAPI_ESO_CREATE            ESO_Create;
  SRAPI_ESO_DELETE            ESO_Delete;
  SRAPI_ESO_GETMODE           ESO_GetMode;
  SRAPI_ESO_SETMODE           ESO_SetMode;
  SRAPI_ESO_GETPARAM          ESO_GetParam;
  SRAPI_ESO_SETPARAM          ESO_SetParam;
  SRAPI_ESO_COPY              ESO_Copy;
  SRAPI_ESO_EDIT              ESO_Edit;
  SRAPI_ESO_LOAD              ESO_Load;
  SRAPI_ESO_SAVE              ESO_Save;
  SRAPI_ESO_COMPAREWFD        ESO_CompareWithWFD;
  DWORD                       Reserved3[1];

//////////////////////////////////////////////////////////////////////////////
// регулярные выражения для поиска
  SRAPI_RE_CREATE             RE_Create;
  SRAPI_RE_DELETE             RE_Delete;
  SRAPI_RE_SETEXPR            RE_SetExpr;
  SRAPI_RE_SEARCH             RE_Search;
  SRAPI_RE_MATCH              RE_Match;
  SRAPI_RE_LASTERROR          RE_LastError;
  SRAPI_RE_ERRORPOSITION      RE_ErrorPosition;
  SRAPI_RE_GETBRACKETSCOUNT   RE_GetBracketsCount;
  DWORD                       Reserved4[2];

//////////////////////////////////////////////////////////////////////////////
// регулярные выражения для замены
  SRAPI_RRE_CREATE            RRE_Create;
  SRAPI_RRE_DELETE            RRE_Delete;
  SRAPI_RRE_SETEXPR           RRE_SetExpr;
  SRAPI_RRE_CHECKLENGTH       RRE_CheckLength;
  SRAPI_RRE_FILL              RRE_Fill;
  SRAPI_RRE_GETBUFFER         RRE_GetBuffer;
  SRAPI_RRE_SETCOUNTER        RRE_SetCounter;
  SRAPI_RRE_GETCOUNTER        RRE_GetCounter;
  DWORD                       Reserved5[2];

//////////////////////////////////////////////////////////////////////////////
// класс для поиска объектов по дискам
  SRAPI_FS_CREATE             FS_Create;
  SRAPI_FS_DELETE             FS_Delete;
  SRAPI_FS_SET                FS_Set;
  SRAPI_FS_SEARCH             FS_Search;
  SRAPI_FS_GETROOT            FS_GetRoot;
  DWORD                       Reserved6[2];

//////////////////////////////////////////////////////////////////////////////
// работа со "схемами"
  SRAPI_SCHEME_CREATE         SCHEME_Create;
  SRAPI_SCHEME_DELETE         SCHEME_Delete;
  SRAPI_SCHEME_MENU           SCHEME_Menu;
  SRAPI_SCHEME_ADD            SCHEME_Add;
  DWORD                       Reserved7[2];

//////////////////////////////////////////////////////////////////////////////
// работа с настройками
  SRAPI_WRITESTR              WriteStr;
  SRAPI_READSTR               ReadStr;
  SRAPI_WRITEDWORD            WriteDWORD;
  SRAPI_READDWORD             ReadDWORD;
  SRAPI_WRITEBYTES            WriteBytes;
  SRAPI_READBYTES             ReadBytes;
  SRAPI_DELETEKEY             DeleteKey;
  DWORD                       Reserved8[2];

//////////////////////////////////////////////////////////////////////////////
// работа с масками файлов
  SRAPI_FM_CREATE             FM_Create;
  SRAPI_FM_DELETE             FM_Delete;
  SRAPI_FM_SET                FM_Set;
  SRAPI_FM_COMPARE            FM_Compare;
  DWORD                       Reserved9[2];

//////////////////////////////////////////////////////////////////////////////
// таблицы символов
  SRAPI_CS_LOAD               CS_Load;
  SRAPI_CS_CHOOSE             CS_Choose;
  DWORD                       Reserved10[2];

//////////////////////////////////////////////////////////////////////////////
// работа с CMatchHash
  SRAPI_CHASH_CREATE          Hash_Create;
  SRAPI_CHASH_DELETE          Hash_Delete;
  SRAPI_CHASH_EXISTS          Hash_Exists;
  SRAPI_CHASH_SETITEM         Hash_SetItem;
  SRAPI_CHASH_GETITEMADDR     Hash_GetItemAddr;
  SRAPI_CHASH_FIRST           Hash_First;
  SRAPI_CHASH_GETNEXT         Hash_GetNext;
  SRAPI_CHASH_EMPTY           Hash_Empty;
  DWORD                       Reserved11[2];

//////////////////////////////////////////////////////////////////////////////
// работа с правами доступа
  SRAPI_CFSEC_CREATE          FSec_Create;
  SRAPI_CFSEC_DELETE          FSec_Delete;
  SRAPI_CFSEC_GETSECURITY     FSec_GetSecurity;
  SRAPI_CFSEC_SETSECURITY     FSec_SetSecurity;
  DWORD                       Reserved12[2];

//////////////////////////////////////////////////////////////////////////////
// работа с файловыми атрибутами
  SRAPI_CFATTR_CREATE         FAttr_Create;
  SRAPI_CFATTR_DELETE         FAttr_Delete;
  SRAPI_CFATTR_GETATTR        FAttr_GetAttr;
  SRAPI_CFATTR_SETATTR        FAttr_SetAttr;
  DWORD                       Reserved13[2];

  DWORD                       Reserved14[10];
};

#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__GNUC__) || defined(__WATCOMC__)
#ifdef __cplusplus
extern "C"{
#endif
// Exported Functions

extern "C"
{
  void WINAPI _export GetInfo (struct SRPluginInfo *SRPInfo);
  void WINAPI _export Start (const struct PluginStartupInfo *Info,
                             const struct SRPluginStartupInfo *srInfo);
  void WINAPI _export Exit ();
  int WINAPI _export Run (DWORD OpenFrom, DWORD Reserved1, DWORD Reserved2);
}

#ifdef __cplusplus
};
#endif
#endif

#if defined(__BORLANDC__)
  #pragma option -a.
#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__)
  #pragma pack()
#else
  #pragma pack(pop)
#endif

#endif // __srplugin_hpp
