LPARAMETERS tcIDXName
IF PCOUNT() <  1  OR VARTYPE(m.tcIDXName) # "C" OR ;
  EMPTY(m.tcIDXName) OR !FILE(m.tcIDXName)
 tcIDXName = GETFILE("Index:idx")
ENDIF
IF EMPTY(m.tcIDXName) OR !FILE(m.tcIDXName)
 ReportError(PROGRAM(), "Файл индекса не найден")
 RETURN .F.
ENDIF
PRIVATE lcIDX, lnKeyLen
LOCAL lnType, llIsCompact, lnRootPointer, lnLen, lcKey
* Считаем весь файл в переменную
lcIDX = FILETOSTR(m.tcIDXName)
* Определим/проверим тип IDX-а
lnType = ASC(SUBSTR(m.lcIDX,  15 ,  1 ))
IF BITTEST(m.lnType,  0 )
 ReportError(PROGRAM(), "UNIQUE индекс - можем восстановить лишь часть 
записей")
ENDIF
IF BITTEST(m.lnType,  6 )
 ReportError(PROGRAM(), "COMPOUND индексный файл  - временно не 
подерживается")
 RETURN .F.
ENDIF
* COMPACT индекс
llIsCompact = BITTEST(m.lnType,  5 )
IF !m.llIsCompact
 ReportError(PROGRAM(), "Не COMPACT индексный файл  - временно не 
подерживается")
 RETURN .F.
ENDIF
* Определим длинну ключа
lnRootPointer = Char2DWord(SUBSTR(m.lcIDX,  1 ,  4 ))
lnKeyLen = Char2Word(SUBSTR(m.lcIDX,  13 ,  2 ))
* Длинна ключевого выражения (учитывая нуль-терминатор)
lnLen = Char2Word(SUBSTR(m.lcIDX,  511 ,  2 ))
* Достанем само ключевое выражение
lcKey = SUBSTR(m.lcIDX,  513 , lnLen -  1 )
? "Key expression : " + m.lcKey
* Тут потом добавим извлечение FOR-выражения

* В данном курсоре мы и будем собирать извлекаемую информацию
CREATE CURSOR Result (nRecno I, cKey C(m.lnKeyLen))
ProcessNode(SUBSTR(m.lcIDX, m.lnRootPointer +  1 ,  512 ))
RETURN .T.

PROCEDURE ProcessNode
 LPARAMETERS tcNode AS String, m.tcKey AS String
  * Собственно пытается разобрать указанный узел
  * Заполняет курсор Result если это leafe-узел
  * Рекурсивно вызывает процедуру, если это промежуточный узел
  LOCAL lnType, lnKeyCnt
  lnType = Char2Word(SUBSTR(m.tcNode,  1 ,  2 ))
  lnKeyCnt = Char2Word(SUBSTR(m.tcNode,  3 ,  2 ))
  IF BITTEST(lnType,  1 )
   LOCAL lnRNMask, lnDupMask, lnTrailMask, ;
     lnRNBits, lnDupBits, lnTrailBits, lnEntrySize, lcPrevKey, ;
     lnPos, ln1, lcKey, lnRN, lnTrail, lnDup
   * leafe - заполним курсор
   * Предполагаем COMPACT стуктуру!
   lnRNMask = Char2DWord(SUBSTR(m.tcNode,  15 ,  4 ))
   lnDupMask = ASC(SUBSTR(m.tcNode,  19 ,  1 ))
   lnTrailMask = ASC(SUBSTR(m.tcNode,  20 ,  1 ))
   lnRNBits = ASC(SUBSTR(m.tcNode,  21 ,  1 ))
   lnDupBits = ASC(SUBSTR(m.tcNode,  22 ,  1 ))
   lnTrailBits = ASC(SUBSTR(m.tcNode,  23 ,  1 ))
   lnEntrySize = ASC(SUBSTR(m.tcNode,  24 ,  1 ))
   * Цикл по каждой из "запией" в данном узле
   lcPrevKey = m.tcKey
   lnPos =  0 
   FOR ln1 =  0  TO m.lnKeyCnt -  1 
    lcKey = SUBSTR(m.tcNode,  25  + m.ln1 * m.lnEntrySize, m.lnEntrySize)
    lnRN = BITAND(Char2DWord(SUBSTR(m.lcKey,  1 , CEILING(m.lnRNBits/ 8 ))), 
lnRNMask)
    lnTrail = BITRSHIFT(Char2DWord(SUBSTR(m.lcKey, FLOOR(m.lnRNBits/ 8 ) +  1 , 
 3 )), m.lnRNBits %  8 )
    lnDup = BITAND(m.lnTrail, m.lnDupMask)
    lnTrail = BITAND(BITRSHIFT(m.lnTrail, m.lnDupBits), m.lnTrailMask)
    lnPos = m.lnPos - (m.lnKeyLen - m.lnDup - m.lnTrail)
    lcKey = LEFT(m.lcPrevKey, m.lnDup) + ;
      SUBSTR(m.tcNode,  513  + m.lnPos, m.lnKeyLen - m.lnDup - m.lnTrail) + ;
      SPACE(m.lnTrail)
    INSERT INTO Result (nRecno, cKey) VALUES (m.lnRN, CPCONVERT ( 866 ,  1251 , 
m.lcKey))
    lcPrevKey = m.lcKey
   ENDFOR
  ENDIF
  IF BITTEST(lnType,  0 )
   LOCAL ln1, lcKey, lnRN, lnNextNode
   * промежуточный узел - заполним курсор
   * и рекурсовно вызовем эту же процедуру для узлов нижнего уровня
   * Предполагаем REGULAR (не compact) структуру!
   FOR ln1 =  0  TO m.lnKeyCnt -  1 
    lcKey = SUBSTR(m.tcNode,  13  + m.ln1 * (m.lnKeyLen +  8 ), m.lnKeyLen)
    lnRN = Char2DWord(SwapString(SUBSTR(m.tcNode,  13  + m.lnKeyLen + m.ln1 * 
(m.lnKeyLen +  8 ),  4 )))
*    INSERT INTO Result (nRecno, cKey) VALUES (m.lnRN, m.lcKey)
    lnNextNode = Char2DWord(SwapString(SUBSTR(m.tcNode,  17  + m.lnKeyLen + 
m.ln1 * (m.lnKeyLen +  8 ),  4 )))
    IF m.lnNextNode +  512  <= LEN(m.lcIDX)
     * Ссылка на следующий узел верна (узел существует)
     ProcessNode(SUBSTR(m.lcIDX, m.lnNextNode +  1 ,  512 ), m.lcKey)
    ENDIF
   ENDFOR
  ENDIF
 RETURN .T.
ENDPROC
FUNCTION Char2Word(tcInput AS String) AS Integer
 * Преобразует строку представляющую WORD (intel-порядка, т.е. big-endian)
 RETURN ASC(SUBSTR(m.tcInput,  1 ,  1 )) +  256  * ASC(SUBSTR(m.tcInput,  2 ,  1 ))
ENDFUNC
FUNCTION Char2DWord(tcInput AS String) AS Integer
 * Преобразует строку представляющую DWORD (intel-порядка, т.е. big-endian)
 RETURN ASC(SUBSTR(m.tcInput,  1 ,  1 )) +  256  * ASC(SUBSTR(m.tcInput,  2 ,  1 )) + 
;
    256 ^ 2  * ASC(SUBSTR(m.tcInput,  3 ,  1 )) +  256 ^ 3  * ASC(SUBSTR(m.tcInput,  4 , 
 1 ))
ENDFUNC
FUNCTION SwapString(tcInput AS String) AS String
 * Переворачивает строку (меняет порядок байт на обратный)
 LOCAL lcOutput, lnLen, ln1
 lcOutput = ""
 lnLen = LEN(m.tcInput)
 FOR ln1 =  0  TO m.lnLen -  1 
  lcOutput = m.lcOutput + SUBSTR(m.tcInput, m.lnLen - ln1,  1 )
 ENDFOR
 RETURN m.lcOutput
ENDFUNC