易語言源碼被騰訊TP破壞后如何修復

小編給大家分享一下易語言源碼被騰訊TP破壞后如何修復，希望大家閱讀完這篇文章之后都有所收獲，下面讓我們一起去探討吧！

DLL命令表

.版本 2
.DLL命令 CopyTo_系統信息段, , , "RtlMoveMemory"
  .參數 Dest, 系統信息段
  .參數 Src, 字節集
  .參數 Length
.DLL命令 CopyTo_SectionInfo, , , "RtlMoveMemory"
  .參數 Dest, _SectionInfo
  .參數 Src, 字節集
  .參數 Length
.DLL命令 CopyFrom_SectionInfo, , , "RtlMoveMemory"
  .參數 Dest, 字節集
  .參數 Src, _SectionInfo
  .參數 Length
.DLL命令 CopyFrom_SectionHeader, , , "RtlMoveMemory"
  .參數 Dest, 字節集
  .參數 Src, _SectionHeader
  .參數 Length
.DLL命令 Sizeof_, 整數型, , "GlobalSize"
  .參數 p, 系統信息段
.DLL命令 strcpy_bytes, , , "lstrcpyA"
  .參數 dest, 字節型, 數組
  .參數 src, 文本型
.DLL命令 LoadLibraryA, 整數型, "kernel32.dll", "LoadLibraryA"
  .參數 FilePath, 文本型
.DLL命令 GetProcAddress, 整數型, "kernel32.dll", "GetProcAddress"
  .參數 hLib
  .參數 Name, 文本型
.DLL命令 GetModuleHandleA, 整數型, "kernel32.dll", "LoadLibraryA"
  .參數 FilePath, 文本型
.DLL命令 DragAcceptFiles_, , "shell32.dll", "DragAcceptFiles", , 登記窗口是否接受托動文件的內容
  .參數 hwnd, 整數型
  .參數 fAccept, 整數型
.DLL命令 SetWindowLong_, 整數型, "user32", "SetWindowLongA", , 在窗口結構中為指定的窗口設置信息 指定數據的前一個值
  .參數 hwnd, 整數型, , 欲為其取得信息的窗口的句柄
  .參數 nIndex, 整數型, , 請參考GetWindowLong函數的nIndex參數的說明
  .參數 dwNewLong, 整數型, , 由nIndex指定的窗口信息的新值;
.DLL命令 SetProp_, 整數型, "user32", "SetPropA", , 增加或修改屬性列項
  .參數 hwnd, 整數型
  .參數 lpString, 文本型
  .參數 hData, 整數型
.DLL命令 GetProp_, 整數型, "user32", "GetPropA", , 從窗口屬性表列中返回數據句柄
  .參數 hwnd, 整數型
  .參數 lpString, 文本型
.DLL命令 CallWindowProc_, 整數型, "user32", "CallWindowProcA", , 將消息傳答窗口函數
  .參數 lpPrevWndFunc, 整數型
  .參數 hwnd, 整數型
  .參數 msg, 整數型
  .參數 wParam, 整數型
  .參數 lParam, 整數型
.DLL命令 DragQueryFile_, 整數型, "shell32.dll", "DragQueryFileA", , 返回托動的文件名
  .參數 HDROP, 整數型
  .參數 UINT, 整數型
  .參數 lpStr, 文本型, 傳址
  .參數 ch, 整數型
.DLL命令 DragFinish_, , "shell32.dll", "DragFinish", , 釋放分配用于托動文件的內容
  .參數 hDrop, 整數型
.DLL命令 RemoveProp_, 整數型, "user32", "RemovePropA", , 刪除屬性列入口
  .參數 hwnd, 整數型
  .參數 lpString, 文本型

常量數據表

.版本 2
.常量 GWL_WNDPROC, "-4"
.常量 WM_DROPFILES, "563"
.常量 __輸出塊數據, "假"
.常量 __輸出屬性值, "假"
.常量 __輸出Section列表, "假"
.常量 __檢查效驗值, "假"
.常量 文件類型_源代碼, "1", 公開
.常量 文件類型_模塊, "3", 公開
.常量 編譯類型_Windows窗口程序, "0", 公開
.常量 編譯類型_Windows控制臺程序, "1", 公開
.常量 編譯類型_Windows動態鏈接庫, "2", 公開
.常量 編譯類型_Windows易語言模塊, "1000", 公開
.常量 編譯類型_Linux控制臺程序, "10000", 公開
.常量 編譯類型_Linux易語言模塊, "11000", 公開
.常量 系統信息段, "“系統信息段”"
.常量 用戶信息段, "“用戶信息段”"
.常量 程序資源段, "“程序資源段”"
.常量 程序段, "“程序段”"
.常量 初始模塊段, "“初始模塊段”"
.常量 可丟失程序段, "“可丟失程序段”"
.常量 編輯信息段1_Maby, "“編輯信息段1”"
.常量 編輯信息段2, "“編輯信息段2”"
.常量 輔助信息段1, "“輔助信息段1”"
.常量 輔助信息段2, "“輔助信息段2”"
.常量 易模塊記錄段, "“易模塊記錄段”"
.常量 sizeof_系統信息段, "60"
.常量 sizeof_SectionHeader, "8"
.常量 sizeof_SectionInfo, "92"
.常量 sizeof_DWORD, "4"
.常量 Magic_加密源碼, "1162630231", , "WTLE"
.常量 Magic_文件標志1, "1415007811", , "CNWT"
.常量 Magic_文件標志2, "1196576837", , "EPRG"
.常量 Magic_Section, "353465113", , 19 73 11 15
.常量 no_key_ec_node, "117469977", , 07 00 73 19
.常量 xF0000000, "4026531840", , 0xF0000000
.常量 x00FFFFFF, "16777215", , 0x00FFFFFF
.常量 程序段_變量_屬性_靜態, "1", 公開
.常量 程序段_變量_屬性_參考, "2", 公開
.常量 程序段_變量_屬性_傳址, "2", 公開
.常量 程序段_變量_屬性_可空, "4", 公開
.常量 程序段_變量_屬性_數組, "8", 公開
.常量 程序段_變量_屬性_公開, "256", 公開
.常量 程序段_函數_屬性_公開, "8", 公開
.常量 程序段_數據類型_屬性_公開, "1", 公開
.常量 程序段_DLL_屬性_公開, "2", 公開
.常量 資源段_常量_頁面_常量, "1"
.常量 資源段_常量_頁面_圖片, "2"
.常量 資源段_常量_頁面_聲音, "3"
.常量 資源段_常量_類型_空白, "22"
.常量 資源段_常量_類型_數值, "23"
.常量 資源段_常量_類型_邏輯, "24"
.常量 資源段_常量_類型_日期, "25"
.常量 資源段_常量_類型_文本, "26"
.常量 資源段_常量_屬性_未檢查, "1", 公開
.常量 資源段_常量_屬性_公開, "2", 公開
.常量 資源段_常量_屬性_長文本常量, "16", 公開
.常量 數據類型_空白型, "0", 公開, 0x00000000
.常量 數據類型_字節型, "-2147483391", 公開, 0x80000101
.常量 數據類型_短整數, "-2147483135", 公開, 0x80000201
.常量 數據類型_整數型, "-2147482879", 公開, 0x80000301
.常量 數據類型_長整數型, "-2147482623", 公開, 0x80000401
.常量 數據類型_小數型, "-2147482367", 公開, 0x80000501
.常量 數據類型_雙精度小數, "-2147482111", 公開, 0x80000601
.常量 數據類型_邏輯型, "-2147483646", 公開, 0x80000002
.常量 數據類型_日期時間型, "-2147483645", 公開, 0x80000003
.常量 數據類型_文本型, "-2147483644", 公開, 0x80000004
.常量 數據類型_字節集, "-2147483643", 公開, 0x80000005
.常量 數據類型_子程序指針, "-2147483642", 公開, 0x80000006
.常量 op4_1, "1"
.常量 op4_23, "23"
.常量 op4_24, "24"
.常量 op4_25, "25"
.常量 op4_26, "26"
.常量 op4_27, "27"
.常量 op4_28, "28"
.常量 op4_29, "29"
.常量 op4_30, "30"
.常量 op4_31, "31"
.常量 op4_32, "32"
.常量 op4_33, "33"
.常量 op4_34, "34"
.常量 op4_35, "35"
.常量 op1_33, "33"
.常量 op1_54, "54"
.常量 op1_55, "55"
.常量 op1_56, "56"
.常量 op1_57, "57"
.常量 op1_58, "58"
.常量 op1_59, "59"

自定義數據類型表

.版本 2
.數據類型 ProSet
  .成員 讀取代碼, 邏輯型
  .成員 讀取資源, 邏輯型
.數據類型 系統信息段, 公開
  .成員 編譯版本1, 短整數型
  .成員 編譯版本2, 短整數型
  .成員 Unknow_1
  .成員 Unknow_2
  .成員 未知類型
  .成員 文件類型
  .成員 Unknow_3
  .成員 編譯類型
  .成員 Unknow_9, , , "8"
.數據類型 用戶信息段, 公開
  .成員 程序名稱, 文本型
  .成員 程序備注, 文本型
  .成員 作者, 文本型
  .成員 郵政編碼, 文本型
  .成員 聯系地址, 文本型
  .成員 電話, 文本型
  .成員 傳真, 文本型
  .成員 電子信箱, 文本型
  .成員 主頁, 文本型
  .成員 其他, 文本型
  .成員 版本號1
  .成員 版本號2
.數據類型 資源段, 公開
  .成員 窗體, 資源段_窗體, , "1"
  .成員 常量, 資源段_常量, , "1"
  .成員 reserve
.數據類型 資源段_窗體, 公開
  .成員 段頭, 塊段頭
  .成員 未知1
  .成員 未知2
  .成員 左邊, 整數型
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 元素, 資源段_窗體_元素, , "1"
.數據類型 資源段_窗體_元素, 公開
  .成員 保留
.數據類型 資源段_常量, 公開
  .成員 標志符
  .成員 Offset
  .成員 dwLength
  .成員 屬性, 短整數型
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 數據, 變體型
  .成員 是否為長文本, 邏輯型
  .成員 結果, 文本型
.數據類型 程序段, 公開
  .成員 頭信息, 程序段_頭信息
  .成員 代碼頁, 程序段_代碼頁, , "1"
  .成員 函數組, 程序段_函數, , "1"
  .成員 全局變量, 程序段_變量, , "1"
  .成員 數據類型, 程序段_數據類型, , "1"
  .成員 Dll, 程序段_Dll, , "1"
.數據類型 程序段_數據類型, 公開
  .成員 段頭, 塊段頭
  .成員 屬性
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 成員組, 程序段_變量, , "1"
.數據類型 程序段_Dll, 公開
  .成員 段頭, 塊段頭
  .成員 屬性
  .成員 返回類型, 整數型
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 文件名, 文本型
  .成員 命令名, 文本型
  .成員 參數組, 程序段_變量, , "1"
.數據類型 程序段_頭信息, 公開
  .成員 VerFlag1
  .成員 Unk1
  .成員 Unk2_1, 字節集
  .成員 Unk2_2, 字節集
  .成員 Unk2_3, 字節集
  .成員 支持庫信息, 文本型, , "1"
  .成員 Flag1
  .成員 Flag2
  .成員 Unk3_Op, 字節集
  .成員 調試命令行, 文本型
  .成員 ICO圖標, 字節集
.數據類型 塊段頭, 公開
  .成員 dwID
  .成員 dwUnk
.數據類型 程序段_代碼頁, 公開
  .成員 段頭, 塊段頭
  .成員 Unk1
  .成員 基類
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 函數組標志, 整數型, , "1"
  .成員 頁面變量, 程序段_變量, , "1"
.數據類型 程序段_函數, 公開
  .成員 段頭, 塊段頭
  .成員 類型
  .成員 屬性
  .成員 返回類型
  .成員 名稱, 文本型
  .成員 備注, 文本型
  .成員 變量, 程序段_變量, , "1"
  .成員 參數, 程序段_變量, , "1"
  .成員 數據1, 字節集
  .成員 數據2, 字節集
  .成員 數據3, 字節集
  .成員 數據4, 字節集
  .成員 數據5, 字節集
  .成員 代碼, 字節集
.數據類型 程序段_代碼行
  .成員 dwFuncId
  .成員 類型, , , , -4=？？；-3=DLL指令；-2=用戶子程序；-1=空；>=0時，則為支持庫索引列表
  .成員 未驗證代碼, 文本型
  .成員 備注, 文本型
.數據類型 程序段_變量, 公開
  .成員 標志符, 整數型
  .成員 Offset
  .成員 dwLength
  .成員 數據類型
  .成員 屬性, 短整數型
  .成員 數組維數, 字節型
  .成員 數組下標值, , , "1"
  .成員 名稱, 文本型
  .成員 備注, 文本型
.數據類型 初始模塊段, 公開
  .成員 保留
.數據類型 可丟失程序段, 公開
  .成員 保留
.數據類型 編輯信息段1, 公開
  .成員 保留
.數據類型 編輯信息段2, 公開
  .成員 保留
.數據類型 輔助信息段1, 公開
  .成員 保留
.數據類型 輔助信息段2, 公開
  .成員 保留
.數據類型 易模塊記錄段, 公開
  .成員 保留
.數據類型 _FileHeader
  .成員 Magic1, 整數型
  .成員 Magic2, 整數型
.數據類型 _SectionHeader
  .成員 Magic, 整數型
  .成員 Info_CheckSum, 整數型
.數據類型 _SectionInfo
  .成員 Key, 字節型, , "4"
  .成員 Name, 字節型, , "30"
  .成員 reserve_fill_1, 短整數型
  .成員 Index, 整數型
  .成員 Flag1, 整數型, , , 1=ec info
  .成員 Data_CheckSum, 整數型
  .成員 DataLength, 整數型
  .成員 reserve_item, 整數型, , "10"
.數據類型 分析選項, 公開
  .成員 禁讀_主要頁面, 邏輯型
  .成員 禁讀_程序代碼, 邏輯型
  .成員 禁讀_資源數據, 邏輯型

修復分析的代碼

.版本 2
.程序集 修復分析
.程序集變量 g_LastError, 文本型
.子程序 分析_取最后錯誤文本, 文本型
返回 (g_LastError)
.子程序 分析_設置錯誤文本
.參數 text, 文本型
g_LastError ＝ text
.子程序 Error
.參數 text, 文本型
輸出調試文本 (“[Error]” ＋ text)
分析_設置錯誤文本 (text)
.如果 (是否為調試版 ())
  輸出調試文本 (“[Error]” ＋ text)
.否則
  信息框 (text, #錯誤圖標, “LD提示：”, )
.如果結束
.子程序 RepairLog
.參數 text, 文本型
輸出調試文本 (text)
.子程序 分析_易文件, 邏輯型
.參數 文件路徑, 文本型
.參數 文件密碼, 文本型, 可空
.參數 __修復文件, 邏輯型, 可空
.參數 分析選項, 分析選項, 可空
.參數 系統信息段, 系統信息段, 可空
.參數 用戶信息段, 用戶信息段, 可空
.參數 程序資源段, 資源段, 可空
.參數 程序段, 程序段, 可空
.參數 初始模塊段, 初始模塊段, 可空
.參數 可丟失程序段, 可丟失程序段, 可空
.參數 編輯信息段1, 編輯信息段1, 可空
.參數 編輯信息段2, 編輯信息段2, 可空
.參數 輔助信息段1, 輔助信息段1, 可空
.參數 輔助信息段2, 輔助信息段2, 可空
.參數 易模塊記錄段, 易模塊記錄段, 可空
.局部變量 file, 讀取
.局部變量 Block_Data, 字節集
.局部變量 Block_Name, 文本型
.局部變量 FileHead, _FileHeader
.局部變量 是否有密碼, 邏輯型
是否有密碼 ＝ file.is_have_password (文件路徑)
.如果真 (file.Open (文件路徑, __修復文件, 文件密碼) ＝ 假)
  Error (“打開文件失敗”)
  返回 (假)
.如果真結束
FileHead ＝ file.Read_FileHeader ()
.如果真 (FileHead.Magic1 ≠ #Magic_文件標志1)
  .如果 (是否有密碼 ＝ 假)
    Error (“頭標志1錯誤”)
  .否則
    Error (“密碼錯誤或頭標志1錯誤”)
  .如果結束
  file.Close ()
  返回 (假)
.如果真結束
.如果真 (FileHead.Magic2 ≠ #Magic_文件標志2)
  .如果 (是否有密碼 ＝ 假)
    Error (“頭標志2錯誤”)
  .否則
    Error (“密碼錯誤或頭標志2錯誤”)
  .如果結束
  file.Close ()
  返回 (假)
.如果真結束
Block_Data ＝ { }
.判斷循環首 (真)
  .如果真 (__修復文件)
    Repair_NodeInfo (file, 取字節集長度 (Block_Data))
  .如果真結束
  .如果真 (file.Read_Section (Block_Name, Block_Data) ＝ 假)
    跳出循環 ()
  .如果真結束
  .如果真 (#__輸出Section列表)
    輸出調試文本 (Block_Name)
  .如果真結束
  .判斷開始 (Block_Name ＝ “”)
    跳出循環 ()
  .判斷 (Block_Name ＝ #系統信息段)
    .如果真 (是否為空 (系統信息段) ＝ 假)
      系統信息段 ＝ 分析_系統信息段 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #用戶信息段)
    .如果真 (是否為空 (用戶信息段) ＝ 假)
      用戶信息段 ＝ 分析_用戶信息段 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #程序資源段)
    .如果真 (是否為空 (程序資源段) ＝ 假)
      程序資源段 ＝ 分析_資源段 (Block_Data, 分析選項)
    .如果真結束
  .判斷 (Block_Name ＝ #程序段)
    .如果真 (是否為空 (程序段) ＝ 假)
      程序段 ＝ 分析_程序段 (Block_Data, 分析選項)
    .如果真結束
  .判斷 (Block_Name ＝ #初始模塊段)
    .如果真 (是否為空 (系統信息段) ＝ 假)
      初始模塊段 ＝ 分析_初始模塊段 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #可丟失程序段)
    .如果真 (是否為空 (可丟失程序段) ＝ 假)
      可丟失程序段 ＝ 分析_可丟失程序段 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #編輯信息段1_Maby)
    .如果真 (是否為空 (編輯信息段1) ＝ 假)
      編輯信息段1 ＝ 分析_編輯信息段1 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #編輯信息段2)
    .如果真 (是否為空 (編輯信息段2) ＝ 假)
      編輯信息段2 ＝ 分析_編輯信息段2 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #輔助信息段1)
    .如果真 (是否為空 (輔助信息段1) ＝ 假)
      輔助信息段1 ＝ 分析_輔助信息段1 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #輔助信息段2)
    .如果真 (是否為空 (輔助信息段2) ＝ 假)
      輔助信息段2 ＝ 分析_輔助信息段2 (Block_Data)
    .如果真結束
  .判斷 (Block_Name ＝ #易模塊記錄段)
    .如果真 (是否為空 (易模塊記錄段) ＝ 假)
      易模塊記錄段 ＝ 分析_易模塊記錄段 (Block_Data)
    .如果真結束
  .默認
    Error (“未知段[” ＋ Block_Name ＋ “]”)
  .判斷結束
  .如果真 (#__輸出塊數據)
    創建目錄 (取運行目錄 () ＋ “\” ＋ Block_Name)
    .如果真 (Block_Data ≠ { })
      寫到文件 (取運行目錄 () ＋ “\” ＋ Block_Name ＋ “\” ＋ 輔_取文件名稱 (文件路徑) ＋ “.txt”, Block_Data)
    .如果真結束
  .如果真結束
.判斷循環尾 ()
file.Close ()
返回 (真)
.子程序 分析_易模塊記錄段, 易模塊記錄段
.參數 數據, 字節集
.局部變量 Info, 易模塊記錄段
返回 (Info)
.子程序 分析_輔助信息段1, 輔助信息段1
.參數 數據, 字節集
.局部變量 Info, 輔助信息段1
返回 (Info)
.子程序 分析_輔助信息段2, 輔助信息段2
.參數 數據, 字節集
.局部變量 Info, 輔助信息段2
返回 (Info)
.子程序 分析_編輯信息段1, 編輯信息段1
.參數 數據, 字節集
.局部變量 Info, 編輯信息段1
返回 (Info)
.子程序 分析_編輯信息段2, 編輯信息段2
.參數 數據, 字節集
.局部變量 Info, 編輯信息段2
返回 (Info)
.子程序 分析_可丟失程序段, 可丟失程序段
.參數 數據, 字節集
.局部變量 Info, 可丟失程序段
返回 (Info)
.子程序 分析_初始模塊段, 初始模塊段
.參數 數據, 字節集
.局部變量 Info, 初始模塊段
返回 (Info)
.子程序 分析_系統信息段, 系統信息段
.參數 數據, 字節集
.局部變量 Info, 系統信息段
CopyTo_系統信息段 (Info, 數據, #sizeof_系統信息段)
.如果真 (是否為調試版 ())
  .如果真 (Info.Unknow_1 ≠ 1 或 Info.Unknow_2 ≠ 1 或 Info.Unknow_3 ≠ 0 或 到字節集 (Info.Unknow_9) ≠ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 })
  .如果真結束
.如果真結束
返回 (Info)
.子程序 分析_用戶信息段, 用戶信息段
.參數 數據, 字節集
.局部變量 Info, 用戶信息段
.局部變量 offset
offset ＝ 1
Info.程序名稱 ＝ 取數據_數據文本 (數據, offset)
Info.程序備注 ＝ 取數據_數據文本 (數據, offset)
Info.作者 ＝ 取數據_數據文本 (數據, offset)
Info.郵政編碼 ＝ 取數據_數據文本 (數據, offset)
Info.聯系地址 ＝ 取數據_數據文本 (數據, offset)
Info.電話 ＝ 取數據_數據文本 (數據, offset)
Info.傳真 ＝ 取數據_數據文本 (數據, offset)
Info.電子信箱 ＝ 取數據_數據文本 (數據, offset)
Info.主頁 ＝ 取數據_數據文本 (數據, offset)
Info.其他 ＝ 取數據_數據文本 (數據, offset)
Info.版本號1 ＝ 取數據_整數 (數據, offset)
Info.版本號2 ＝ 取數據_整數 (數據, offset)
返回 (Info)
.子程序 Repair_NodeInfo, 邏輯型
.參數 file, 讀取
.參數 LastSize
.局部變量 Header, _SectionHeader
.局部變量 Info, _SectionInfo
.局部變量 extern, 字節集
.局部變量 bak
.局部變量 length
.局部變量 checksum
.局部變量 Repair, 邏輯型
.如果真 (file.IsEof ())
  返回 (假)
.如果真結束
bak ＝ file.GetPos ()
Header ＝ file.Read_SectionHeader ()
.如果真 (Header.Magic ≠ #Magic_Section)
  length ＝ 0 － #sizeof_SectionHeader － #sizeof_SectionInfo
  .判斷循環首 (file.IsEof () ＝ 假)
    file.MoveTo (#文件首, bak ＋ length)
    Header.Magic ＝ file.ReadInt ()
    .如果真 (Header.Magic ＝ #Magic_Section)
      跳出循環 ()
    .如果真結束
    length ＝ length ＋ 1
  .判斷循環尾 ()
  .如果真 (Header.Magic ≠ #Magic_Section)
    file.MoveTo (#文件首, bak)
    返回 (假)
  .如果真結束
  .如果 (length ≥ 0)
    file.MoveTo (#文件首, bak)
    extern ＝ file.ReadData (length)
    Info.DataLength ＝ length
    Info.Data_CheckSum ＝ GetCheckValue (extern)
    Info.Key [1] ＝ 204
    Info.Key [2] ＝ 204
    Info.Key [3] ＝ 204
    Info.Key [4] ＝ 204
    strcpy_bytes (Info.Name, “待修復”)
    Decode_Str (Info.Name, Info.Key)
    Header.Info_CheckSum ＝ GetSectionInfoCheckSum (Info)
    file.MoveTo (#文件首, bak)
    file.InsertSection (Header, Info)
    file.MoveTo (#文件首, bak)
    Header ＝ file.Read_SectionHeader ()
  .否則
  .如果結束
.如果真結束
Info ＝ file.Read_SectionInfo ()
extern ＝ file.ReadData (Info.DataLength)
checksum ＝ GetCheckValue (extern)
.如果真 (Info.Data_CheckSum ≠ checksum)
  Info.Data_CheckSum ＝ checksum
  Repair ＝ 真
.如果真結束
checksum ＝ GetSectionInfoCheckSum (Info)
.如果真 (Header.Info_CheckSum ≠ checksum)
  Header.Info_CheckSum ＝ checksum
  Repair ＝ 真
.如果真結束
.如果真 (Repair ＝ 真)
  file.MoveTo (#文件首, bak)
  file.Write_SectionHeader (Header)
  file.Write_SectionInfo (Info)
  Decode_Str (Info.Name, Info.Key)
  RepairLog (“[” ＋ 到文本 (Info.Name) ＋ “]損壞”)
.如果真結束
file.MoveTo (#文件首, bak)
返回 (真)
.子程序 Repair_Write
.參數 hFile
.參數 CheckAddr_Head
.參數 CheckAddr_Data
.參數 HeadAddr
.參數 HeadSize
.參數 DataAddr
.參數 DataSize
.局部變量 bak
.局部變量 bin, 字節集
bak ＝ 取讀寫位置 (hFile)
移動讀寫位置 (hFile, , DataAddr)
bin ＝ 讀入字節集 (hFile, DataSize)
移動讀寫位置 (hFile, , CheckAddr_Data)
.如果真 (寫出數據 (hFile, GetCheckValue (bin)) ＝ 假)
  Error (“修正失敗[數據]”)
.如果真結束
移動讀寫位置 (hFile, , HeadAddr)
bin ＝ 讀入字節集 (hFile, HeadSize)
移動讀寫位置 (hFile, , CheckAddr_Head)
.如果真 (寫出數據 (hFile, GetCheckValue (bin)) ＝ 假)
  Error (“修正失敗[頭]”)
.如果真結束
移動讀寫位置 (hFile, , bak)
.子程序 GetCheckValue, 整數型
.參數 data, 字節集
.局部變量 data_len
.局部變量 key, 字節集
.局部變量 key_len
.局部變量 i
.局部變量 ret_key
key_len ＝ 4
key ＝ 取空白字節集 (key_len)
data_len ＝ 取字節集長度 (data)
i ＝ 0
.判斷循環首 (i ＜ data_len)
  key [i ％ key_len ＋ 1] ＝ 位異或 (key [i ％ key_len ＋ 1], data [i ＋ 1])
  i ＝ i ＋ 1
.判斷循環尾 ()
ret_key ＝ 取字節集數據 (key, #整數型, )
返回 (ret_key)
.子程序 Decode_Str
.參數 data, 字節型, 數組
.參數 key, 字節型, 數組
.局部變量 key_i
.局部變量 key_len
.局部變量 i, 整數型
key_len ＝ 取數組成員數 (key)
key_i ＝ 1
.計次循環首 (取數組成員數 (data), i)
  data [i] ＝ 位異或 (data [i], key [key_i ％ key_len ＋ 1])
  key_i ＝ key_i ＋ 1
.計次循環尾 ()

數據

.版本 2
.程序集 數據
.子程序 GET_HIGHT_TYPE, 整數型
.參數 DWORD
返回 (右移 (位與 (DWORD, #xF0000000), 8 ＋ 8 ＋ 8 ＋ 4))
.子程序 GET_LINK_TYPE, 整數型
.參數 DWORD, 整數型
返回 (位與 (DWORD, #x00FFFFFF))
.子程序 取數據_字節, 短整數型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #字節型, offset))
.子程序 取數據_短整數, 短整數型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #短整數型, offset))
.子程序 取數據_整數, 整數型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #整數型, offset))
.子程序 取數據_邏輯, 邏輯型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #邏輯型, offset))
.子程序 取數據_雙精度小數, 雙精度小數型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #雙精度小數型, offset))
.子程序 取數據_日期時間, 日期時間型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #日期時間型, offset))
.子程序 取數據_文本數組
.參數 數據, 字節集
.參數 offset, , 參考
.參數 ret_arg, 文本型, 數組
.局部變量 wCount, 短整數型
.局部變量 i
wCount ＝ 取數據_短整數 (數據, offset)
重定義數組 (ret_arg, 假, wCount)
.計次循環首 (wCount, i)
  ret_arg [i] ＝ 取數據_數據文本 (數據, offset)
.計次循環尾 ()
.子程序 取數據_數據文本, 文本型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (到文本 (取數據_動態數據 (數據, offset)))
.子程序 取數據_標準文本, 文本型
.參數 數據, 字節集
.參數 offset, , 參考
返回 (取字節集數據 (數據, #文本型, offset))
.子程序 取數據_動態數據, 字節集
.參數 數據, 字節集
.參數 offset, , 參考
.局部變量 len
len ＝ 取數據_整數 (數據, offset)
返回 (取數據_指定數據 (數據, offset, len))
.子程序 取數據_指定數據, 字節集
.參數 數據, 字節集
.參數 offset, , 參考
.參數 length
.局部變量 data, 字節集
.如果真 (length ＜ 0)
  Error (“Read Data Error”)
  返回 ({ })
.如果真結束
.如果真 (length ＝ 0)
  返回 ({ })
.如果真結束
data ＝ 取字節集中間 (數據, offset, length)
offset ＝ offset ＋ length
返回 (data)
.子程序 取數據_跳過動態數據, 字節集
.參數 數據, 字節集
.參數 offset, , 參考
.局部變量 len
len ＝ 取數據_整數 (數據, offset)
offset ＝ offset ＋ len
返回 ({ })
.子程序 數據轉換, 文本型
.參數 數據, 字節集
.參數 offset, , 參考
.局部變量 i, 整數型
i ＝ 取字節集數據 (數據, #整數型, offset)
返回 (到文本 (readBytes (i, 數據, offset)))
.子程序 readBytes, 字節集
.參數 length, 整數型
.參數 data, 字節集
.參數 offset, , 參考
.局部變量 d, 字節集
d ＝ 取字節集中間 (data, offset, length)
offset ＝ offset ＋ length
返回 (d)

分析程序段

.版本 2
.程序集 分析程序段
.子程序 分析_程序段, 程序段
.參數 數據, 字節集
.參數 分析選項, 分析選項
.局部變量 offset
.局部變量 Info, 程序段
.局部變量 Count
.局部變量 i, 整數型
.局部變量 段組, 塊段頭, , "0"
offset ＝ 1
分析_程序段_基本信息 (數據, offset, Info.頭信息)
.如果真 (分析選項.禁讀_主要頁面 ＝ 假)
  Count ＝ 分析_塊_段頭 (數據, offset, 段組)
  重定義數組 (Info.代碼頁, 假, Count)
  .計次循環首 (Count, i)
    Info.代碼頁 [i].段頭 ＝ 段組 [i]
    分析_程序段_程序集 (數據, offset, Info.代碼頁 [i])
  .計次循環尾 ()
  Count ＝ 分析_塊_段頭 (數據, offset, 段組)
  重定義數組 (Info.函數組, 假, Count)
  .計次循環首 (Count, i)
    Info.函數組 [i].段頭 ＝ 段組 [i]
    分析_程序段_函數 (數據, offset, Info.函數組 [i], Info, 分析選項)
  .計次循環尾 ()
  分析_程序段_變量_數據 (Info.全局變量, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
  Count ＝ 分析_塊_段頭 (數據, offset, 段組)
  重定義數組 (Info.數據類型, 假, Count)
  .計次循環首 (Count, i)
    Info.數據類型 [i].段頭 ＝ 段組 [i]
    分析_程序段_數據類型 (數據, offset, Info.數據類型 [i])
  .計次循環尾 ()
  Count ＝ 分析_塊_段頭 (數據, offset, 段組)
  重定義數組 (Info.Dll, 假, Count)
  .計次循環首 (Count, i)
    Info.Dll [i].段頭 ＝ 段組 [i]
    分析_程序段_Dll (數據, offset, Info.Dll [i])
  .計次循環尾 ()
.如果真結束
返回 (Info)
.子程序 分析_程序段_數據類型
.參數 數據, 字節集
.參數 offset, , 參考
.參數 Info, 程序段_數據類型
.局部變量 Count
Info.屬性 ＝ 取數據_整數 (數據, offset)
Info.名稱 ＝ 取數據_數據文本 (數據, offset)
Info.備注 ＝ 取數據_數據文本 (數據, offset)
分析_程序段_變量_數據 (Info.成員組, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
.子程序 分析_程序段_Dll
.參數 數據, 字節集
.參數 offset, , 參考
.參數 Info, 程序段_Dll
.局部變量 Count
Info.屬性 ＝ 取數據_整數 (數據, offset)
Info.返回類型 ＝ 取數據_整數 (數據, offset)
Info.名稱 ＝ 取數據_數據文本 (數據, offset)
Info.備注 ＝ 取數據_數據文本 (數據, offset)
Info.文件名 ＝ 取數據_數據文本 (數據, offset)
Info.命令名 ＝ 取數據_數據文本 (數據, offset)
分析_程序段_變量_數據 (Info.參數組, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
.子程序 分析_塊_段頭, 整數型
.參數 數據, 字節集
.參數 offset, , 參考
.參數 List, 塊段頭, 數組
.局部變量 Length
.局部變量 Count
.局部變量 i, 整數型
Length ＝ 取數據_整數 (數據, offset)
Count ＝ Length ÷ 8
重定義數組 (List, 假, Count)
i ＝ offset
.計次循環首 (Count, i)
  List [i].dwID ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
.計次循環首 (Count, i)
  List [i].dwUnk ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
返回 (Count)
.子程序 分析_程序段_函數
.參數 數據, 字節集
.參數 offset, , 參考
.參數 Info, 程序段_函數
.參數 global, 程序段
.參數 分析選項, 分析選項
.局部變量 count, 整數型
Info.類型 ＝ 取數據_整數 (數據, offset)
Info.屬性 ＝ 取數據_整數 (數據, offset)
Info.返回類型 ＝ 取數據_整數 (數據, offset)
Info.名稱 ＝ 取數據_數據文本 (數據, offset)
Info.備注 ＝ 取數據_數據文本 (數據, offset)
分析_程序段_變量_數據 (Info.變量, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
分析_程序段_變量_數據 (Info.參數, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
.如果 (分析選項.禁讀_程序代碼)
  Info.數據1 ＝ 取數據_跳過動態數據 (數據, offset)
  Info.數據2 ＝ 取數據_跳過動態數據 (數據, offset)
  Info.數據3 ＝ 取數據_跳過動態數據 (數據, offset)
  Info.數據4 ＝ 取數據_跳過動態數據 (數據, offset)
  Info.數據5 ＝ 取數據_跳過動態數據 (數據, offset)
  Info.代碼 ＝ 取數據_跳過動態數據 (數據, offset)
.否則
  Info.數據1 ＝ 取數據_動態數據 (數據, offset)
  Info.數據2 ＝ 取數據_動態數據 (數據, offset)
  Info.數據3 ＝ 取數據_動態數據 (數據, offset)
  Info.數據4 ＝ 取數據_動態數據 (數據, offset)
  Info.數據5 ＝ 取數據_動態數據 (數據, offset)
  Info.代碼 ＝ 取數據_動態數據 (數據, offset)
  輸出調試文本 (選擇 (Info.名稱 ＝ “”, “sub_” ＋ 取十六進制文本 (Info.段頭.dwID), Info.名稱))
  分析_程序段_代碼 (Info.代碼, global)
.如果結束
.子程序 分析_程序段_代碼
.參數 數據, 字節集
.參數 Info, 程序段
.局部變量 offset
offset ＝ 1
.判斷循環首 (offset ≤ 取字節集長度 (數據) 且 offset ≠ -1)
  .如果真 (IsUnkType (取數據_字節 (數據, offset)) ＝ 假)
    到循環尾 ()
  .如果真結束
  .如果真 (位與 (取數據_字節 (數據, offset ＋ 6), 40) ＝ 32)
    到循環尾 ()
  .如果真結束
  分析_程序段_行 (數據, offset, Info)
  offset ＝ offset ＋ GetFEndLen3 (數據, offset)
.判斷循環尾 ()
.子程序 分析_程序段_行
.參數 數據, 字節集
.參數 offset
.參數 Info, 程序段
.局部變量 line, 程序段_代碼行
.局部變量 tmp
line.dwFuncId ＝ 取數據_整數 (數據, offset)
line.類型 ＝ 取數據_短整數 (數據, offset)
tmp ＝ 取數據_短整數 (數據, offset)
line.未驗證代碼 ＝ 取數據_數據文本 (數據, offset)
line.備注 ＝ 取數據_數據文本 (數據, offset)
.判斷開始 (line.類型 ≥ 0)
  輸出調試文本 (取支持庫信指令 (Info.頭信息, line.類型, line.dwFuncId), line.未驗證代碼, line.類型, tmp)
.判斷 (line.類型 ＝ -2)
  輸出調試文本 (取用戶定義指令 (Info.函數組, line.dwFuncId), line.未驗證代碼, line.類型, tmp)
.默認
  輸出調試文本 (取十六進制文本 (line.dwFuncId), line.未驗證代碼, line.類型, tmp)
.判斷結束
tmp ＝ 取數據_字節 (數據, offset)
.子程序 GetFHdrType1, 整數型
.參數 type, 字節型
.判斷開始 (type ≥ 106 且 type ≤ 117)
  返回 (4)
.判斷 (type ≥ 80 且 type ≤ 85)
  返回 (5)
.判斷 (type ≥ 54 且 type ≤ 59)
  返回 (2)
.判斷 (type ≥ 22 且 type ≤ 35)
  返回 (1)
.判斷 (type ＝ 1)
  返回 (3)
.默認
  返回 (0)
.判斷結束
.子程序 GetFEndLen1, 整數型
.參數 數據, 字節集
.參數 offset
.局部變量 tmp
.局部變量 bak_offset
bak_offset ＝ offset
tmp ＝ 取數據_字節 (數據, offset)
.如果真 (tmp ＝ #op1_54)
  返回 (1)
.如果真結束
tmp ＝ 取數據_整數 (數據, offset)
.判斷循環首 (真)
  tmp ＝ 取數據_字節 (數據, offset)
  .判斷開始 (tmp ＝ #op1_56)
    offset ＝ offset － 1 ＋ GetFEndLen1 (數據, offset)
  .判斷 (tmp ＝ #op1_57)
    tmp ＝ 取數據_整數 (數據, offset)
    tmp ＝ 取數據_整數 (數據, offset)
  .判斷 (tmp ＝ #op1_58)
    ' 到循環尾 ()
  .判斷 (tmp ＝ #op1_59)
    tmp ＝ 取數據_整數 (數據, offset)
  .判斷 (tmp ＝ #op1_33)
    offset ＝ offset ＋ GetFEndLen3 (數據, offset)
  .判斷 (tmp ＝ #op1_55)
    跳出循環 ()
  .默認
    輸出調試文本 (“unknow type cmd1:” ＋ 到文本 (tmp))
    跳出循環 ()
  .判斷結束
.判斷循環尾 ()
.如果真 (offset ＝ -1)
  暫停 ()
  返回 (0)
.如果真結束
返回 (offset － bak_offset)
.子程序 GetFEndLen4, 整數型
.參數 數據, 字節集
.參數 offset
.局部變量 tmp
.局部變量 bak_offset
.局部變量 tmp_str, 文本型
bak_offset ＝ offset
tmp ＝ 取數據_字節 (數據, offset)
.判斷開始 (tmp ＝ 0)
.判斷 (tmp ＝ #op4_1)
  ' //
.判斷 (tmp ＝ #op4_24)
  tmp ＝ 取數據_短整數 (數據, offset)
.判斷 (tmp ＝ #op4_26)
  tmp_str ＝ 取數據_數據文本 (數據, offset)
.判斷 (tmp ＝ #op4_28)
  tmp ＝ 取數據_整數 (數據, offset)
.判斷 (tmp ＝ #op4_27 或 tmp ＝ #op4_30)
  tmp ＝ 取數據_整數 (數據, offset)
.判斷 (tmp ＝ #op4_35)
  tmp ＝ 取數據_整數 (數據, offset)
  tmp ＝ 取數據_整數 (數據, offset)
.判斷 (tmp ＝ #op4_23 或 tmp ＝ #op4_25)
  tmp ＝ 取數據_整數 (數據, offset)
  tmp ＝ 取數據_整數 (數據, offset)
.判斷 (tmp ＝ #op4_29)
  offset ＝ offset ＋ GetFEndLen1 (數據, offset)
.判斷 (tmp ＝ #op4_33 或 tmp ＝ #op4_34)
  offset ＝ offset ＋ GetFEndLen3 (數據, offset)
.判斷 (tmp ＝ #op4_31)
  .判斷循環首 (取數據_字節 (數據, offset) ≠ #op4_32 且 offset ≠ -1)
    offset ＝ offset ＋ GetFEndLen4 (數據, offset)
  .判斷循環尾 ()
.判斷 (tmp ＝ 22)
.默認
  輸出調試文本 (“unknow type cmd4:” ＋ 到文本 (tmp))
.判斷結束
.如果真 (offset ＝ -1)
  返回 (1)
.如果真結束
返回 (offset － bak_offset)
.子程序 GetFEndLen3, 整數型
.參數 數據, 字節集
.參數 offset
.局部變量 bak_offset
.局部變量 tmp_str, 文本型
bak_offset ＝ offset
offset ＝ offset ＋ 8
tmp_str ＝ 取數據_數據文本 (數據, offset)
檢查 (offset ≠ -1)
tmp_str ＝ 取數據_數據文本 (數據, offset)
檢查 (offset ≠ -1)
offset ＝ offset ＋ GetFEndLen1 (數據, offset)
檢查 (offset ≠ -1)
offset ＝ offset ＋ GetFEndLen4_loop (數據, offset)
返回 (offset － bak_offset)
.子程序 GetFEndLen4_loop, 整數型
.參數 數據, 字節集
.參數 offset
.局部變量 bak_offset
bak_offset ＝ offset
.判斷循環首 (取數據_字節 (數據, offset ＋ 1 － 1) ≠ #op4_1)
  offset ＝ offset ＋ GetFEndLen4 (數據, offset)
.判斷循環尾 ()
offset ＝ offset ＋ 1
返回 (offset － bak_offset)
.子程序 IsUnkType, 邏輯型
.參數 type, 字節型
.判斷開始 (type ＝ 33)
  返回 (真)
.判斷 (GetFHdrType1 (type) ＝ 4 且 type ≠ 114 且 type ≠ 115 且 type ≠ 116 且 type ≠ 109 且 type ≠ 111 且 type ≠ 117)
  返回 (真)
.默認
  返回 (假)
.判斷結束
.子程序 分析_程序段_程序集
.參數 數據, 字節集
.參數 offset, , 參考
.參數 Info, 程序段_代碼頁
.局部變量 Bin, 字節集
.局部變量 i, 整數型
.局部變量 length
.局部變量 count
Info.Unk1 ＝ 取數據_整數 (數據, offset)
Info.基類 ＝ 取數據_整數 (數據, offset)
Info.名稱 ＝ 取數據_數據文本 (數據, offset)
Info.備注 ＝ 取數據_數據文本 (數據, offset)
length ＝ 取數據_整數 (數據, offset)
count ＝ length ÷ 4
重定義數組 (Info.函數組標志, 假, count)
.計次循環首 (count, i)
  Info.函數組標志 [i] ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
分析_程序段_變量_數據 (Info.頁面變量, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
.子程序 分析_程序段_變量_數據
.參數 list, 程序段_變量, 數組
.參數 count
.參數 數據, 字節集
.局部變量 offset
.局部變量 i
.局部變量 i2
.局部變量 text, 文本型
重定義數組 (list, 假, count)
.如果真 (count ＝ 0)
  返回 ()
.如果真結束
offset ＝ 1
.計次循環首 (count, i)
  list [i].標志符 ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
.計次循環首 (count, i)
  list [i].Offset ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
.計次循環首 (count, i)
  list [i].Offset ＝ list [i].Offset ＋ offset
.計次循環尾 ()
.計次循環首 (取數組成員數 (list), i)
  offset ＝ list [i].Offset
  list [i].dwLength ＝ 取數據_整數 (數據, offset)
  list [i].數據類型 ＝ 取數據_整數 (數據, offset)
  list [i].屬性 ＝ 取數據_短整數 (數據, offset)
  list [i].數組維數 ＝ 取數據_字節 (數據, offset)
  重定義數組 (list [i].數組下標值, 假, list [i].數組維數)
  .計次循環首 (list [i].數組維數, i2)
    list [i].數組下標值 [i2] ＝ 取數據_整數 (數據, offset)
  .計次循環尾 ()
  list [i].名稱 ＝ 取數據_標準文本 (數據, offset)
  list [i].備注 ＝ 取數據_標準文本 (數據, offset)
.計次循環尾 ()
.子程序 分析_程序段_基本信息
.參數 數據, 字節集
.參數 offset, , 參考
.參數 Info, 程序段_頭信息
Info.VerFlag1 ＝ 取數據_整數 (數據, offset)
Info.Unk1 ＝ 取數據_整數 (數據, offset)
Info.Unk2_1 ＝ 取數據_動態數據 (數據, offset)
Info.Unk2_2 ＝ 取數據_動態數據 (數據, offset)
Info.Unk2_3 ＝ 取數據_動態數據 (數據, offset)
取數據_文本數組 (數據, offset, Info.支持庫信息)
Info.Flag1 ＝ 取數據_整數 (數據, offset)
Info.Flag2 ＝ 取數據_整數 (數據, offset)
.如果真 (位與 (Info.Flag1, 1) ≠ 0)
  Info.Unk3_Op ＝ 取數據_指定數據 (數據, offset, 16)
.如果真結束
Info.ICO圖標 ＝ 取數據_動態數據 (數據, offset)
Info.調試命令行 ＝ 取數據_數據文本 (數據, offset)

分析資源段

.版本 2
.程序集 分析資源段
.子程序 分析_資源段, 資源段
.參數 數據, 字節集
.參數 分析選項, 分析選項
.局部變量 Info, 資源段
.局部變量 offset
.局部變量 i
.局部變量 Count
.局部變量 段組, 塊段頭, , "0"
offset ＝ 1
Count ＝ 分析_塊_段頭 (數據, offset, 段組)
重定義數組 (Info.窗體, 假, Count)
.計次循環首 (Count, i)
  Info.窗體 [i].段頭 ＝ 段組 [i]
  分析_資源段_窗體 (數據, offset, Info.窗體 [i])
.計次循環尾 ()
分析_資源段_常量 (Info.常量, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset), 分析選項)
Info.reserve ＝ 取數據_整數 (數據, offset)
返回 (Info)
.子程序 分析_資源段_窗體
.參數 數據, 字節集
.參數 offset, 整數型, 參考
.參數 info, 資源段_窗體
.局部變量 count
info.未知1 ＝ 取數據_整數 (數據, offset)
info.未知2 ＝ 取數據_整數 (數據, offset)
info.名稱 ＝ 取數據_數據文本 (數據, offset)
info.備注 ＝ 取數據_數據文本 (數據, offset)
分析_資源段_窗體_元素 (info.元素, 取數據_整數 (數據, offset), 取數據_動態數據 (數據, offset))
.子程序 分析_資源段_窗體_元素
.參數 list, 資源段_窗體_元素, 數組
.參數 count
.參數 數據, 字節集
重定義數組 (list, 假, count)
.如果真 (count ＝ 0)
  返回 ()
.如果真結束
.子程序 分析_資源段_常量
.參數 list, 資源段_常量, 數組
.參數 count
.參數 數據, 字節集
.參數 分析選項, 分析選項
.局部變量 offset
.局部變量 i
.局部變量 類型
重定義數組 (list, 假, count)
.如果真 (count ＝ 0)
  返回 ()
.如果真結束
offset ＝ 1
.計次循環首 (count, i)
  list [i].標志符 ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
.計次循環首 (count, i)
  list [i].Offset ＝ 取數據_整數 (數據, offset)
.計次循環尾 ()
.計次循環首 (count, i)
  list [i].Offset ＝ list [i].Offset ＋ offset
.計次循環尾 ()
.計次循環首 (取數組成員數 (list), i)
  offset ＝ list [i].Offset
  list [i].dwLength ＝ 取數據_整數 (數據, offset)
  list [i].屬性 ＝ 取數據_短整數 (數據, offset)
  list [i].名稱 ＝ 取數據_標準文本 (數據, offset)
  list [i].備注 ＝ 取數據_標準文本 (數據, offset)
  類型 ＝ GET_HIGHT_TYPE (list [i].標志符)
  .判斷開始 (類型 ＝ #資源段_常量_頁面_常量)
    類型 ＝ 取數據_字節 (數據, offset)
    .判斷開始 (類型 ＝ #資源段_常量_類型_空白)
    .判斷 (類型 ＝ #資源段_常量_類型_數值)
      list [i].數據.賦值 (取數據_雙精度小數 (數據, offset), )
    .判斷 (類型 ＝ #資源段_常量_類型_邏輯)
      list [i].數據.賦值 (取數據_邏輯 (數據, offset), )
    .判斷 (類型 ＝ #資源段_常量_類型_日期)
      list [i].數據.賦值 (取數據_日期時間 (數據, offset), )
    .判斷 (類型 ＝ #資源段_常量_類型_文本)
      list [i].數據.賦值 (數據轉換 (數據, offset), )
      list [i].是否為長文本 ＝ 位與 (取數據_短整數 (數據, offset), #資源段_常量_屬性_長文本常量) ≠ 0
    .默認
      Error (“未知常量類型[” ＋ 到文本 (類型) ＋ “]”)
    .判斷結束
    list [i].結果 ＝ “文本”
  .判斷 (類型 ＝ #資源段_常量_頁面_圖片)
    .如果 (分析選項.禁讀_資源數據)
      list [i].數據.賦值 (取數據_跳過動態數據 (數據, offset), )
    .否則
      list [i].數據.賦值 (取數據_動態數據 (數據, offset), )
    .如果結束
    list [i].結果 ＝ “圖片”
  .判斷 (類型 ＝ #資源段_常量_頁面_聲音)
    .如果 (分析選項.禁讀_資源數據)
      list [i].數據.賦值 (取數據_跳過動態數據 (數據, offset), )
    .否則
      list [i].數據.賦值 (取數據_動態數據 (數據, offset), )
    .如果結束
    list [i].結果 ＝ “聲音”
  .默認
    Error (“未知常量頁面[” ＋ 到文本 (類型) ＋ “]”)
  .判斷結束
  .如果真 (#__輸出屬性值)
    .如果真 (list [i].屬性 ≠ 0)
      輸出調試文本 (list [i].名稱 ＋ “.屬性=” ＋ 到文本 (list [i].屬性))
    .如果真結束
  .如果真結束
.計次循環尾 ()

讀取

.版本 2
.程序集 讀取
.程序集變量 m_hFile
.子程序 is_have_password, 邏輯型, 公開
.參數 path, 文本型
.局部變量 result, 邏輯型
.局部變量 FileHead, _FileHeader
.局部變量 hFile
hFile ＝ 打開文件 (path, #讀入, )
.如果真 (hFile ≤ 0)
  返回 (假)
.如果真結束
FileHead ＝ raw_Read_FileHeader (hFile)
result ＝ FileHead.Magic1 ＝ #Magic_加密源碼
關閉文件 (hFile)
返回 (result)
.子程序 raw_Open, 整數型
.參數 path, 文本型
.參數 Write, 邏輯型, 可空
.參數 password, 文本型
.局部變量 type
.局部變量 hFile
.局部變量 是否有密碼, 邏輯型
.如果 (Write)
  type ＝ #改讀
.否則
  type ＝ #讀入
.如果結束
.如果 (is_have_password (path))
  hFile ＝ 打開加密文件 (path, type, , password, 8)
  移動讀寫位置 (hFile, #現行位置, 8 ＋ 32)
.否則
  hFile ＝ 打開文件 (path, type, )
.如果結束
返回 (hFile)
.子程序 Open, 邏輯型, 公開
.參數 path, 文本型
.參數 Write, 邏輯型, 可空
.參數 password, 文本型
m_hFile ＝ raw_Open (path, Write, password)
返回 (m_hFile ＞ 0)
.子程序 Close, , 公開
關閉文件 (m_hFile)
m_hFile ＝ 0
.子程序 IsEof, 邏輯型, 公開
返回 (是否在文件尾 (m_hFile, ))
.子程序 GetPos, 整數型, 公開
返回 (取讀寫位置 (m_hFile))
.子程序 MoveTo, , 公開
.參數 Type
.參數 Pos
移動讀寫位置 (m_hFile, Type, Pos)
.子程序 ReadInt, 整數型, 公開
.局部變量 v
讀入數據 (m_hFile, v)
返回 (v)
.子程序 ReadData, 字節集, 公開
.參數 length
返回 (讀入字節集 (m_hFile, length))
.子程序 Read_FileHeader, _FileHeader, 公開
返回 (raw_Read_FileHeader (m_hFile))
.子程序 Read_SectionHeader, _SectionHeader, 公開
返回 (raw_Read_SectionHeader (m_hFile))
.子程序 Read_SectionInfo, _SectionInfo, 公開
返回 (raw_Read_SectionInfo (m_hFile))
.子程序 Read_Section, 邏輯型, 公開
.參數 Block_Name, 文本型, 參考
.參數 Block_Data, 字節集, 參考
.局部變量 Bin, 字節集
.局部變量 header, _SectionHeader
.局部變量 Info, _SectionInfo
.如果真 (IsEof ())
  返回 (假)
.如果真結束
header ＝ Read_SectionHeader ()
.如果真 (header.Magic ≠ #Magic_Section)
  Error (“SectionHeader標志錯誤”)
  返回 (假)
.如果真結束
Info ＝ Read_SectionInfo ()
.如果真 (header.Info_CheckSum ≠ GetSectionInfoCheckSum (Info))
  .如果真 (#__檢查效驗值)
    Error (“SectionInfo效驗值錯誤”)
    返回 (假)
  .如果真結束
.如果真結束
.如果 (到字節集 (Info.Key) ≠ { 25, 115, 0, 7 })
  Decode_Str (Info.Name, Info.Key)
.否則
.如果結束
Block_Name ＝ 到文本 (Info.Name)
Block_Data ＝ ReadData (Info.DataLength)
.如果真 (Info.Data_CheckSum ≠ GetCheckValue (Block_Data))
  .如果真 (#__檢查效驗值)
    Error (“SectionInfo效驗值錯誤”)
    返回 (假)
  .如果真結束
.如果真結束
返回 (真)
.子程序 Write_SectionHeader, , 公開
.參數 Header, _SectionHeader
raw_Write_SectionHeader (m_hFile, Header)
.子程序 Write_SectionInfo, , 公開
.參數 info, _SectionInfo
raw_Write_SectionInfo (m_hFile, info)
.子程序 InsertSection, , 公開
.參數 header, _SectionHeader
.參數 info, _SectionInfo
.局部變量 bin, 字節集
bin ＝ 取空白字節集 (#sizeof_SectionHeader)
CopyFrom_SectionHeader (bin, header, #sizeof_SectionHeader)
插入字節集 (m_hFile, bin)
bin ＝ 取空白字節集 (#sizeof_SectionInfo)
CopyFrom_SectionInfo (bin, info, #sizeof_SectionInfo)
插入字節集 (m_hFile, bin)

RAW

.版本 2
.程序集 raw
.子程序 raw_Read_FileHeader, _FileHeader
.參數 hFile
.局部變量 FileHead, _FileHeader
讀入數據 (hFile, FileHead.Magic1)
讀入數據 (hFile, FileHead.Magic2)
返回 (FileHead)
.子程序 raw_Read_SectionHeader, _SectionHeader
.參數 hFile
.局部變量 header, _SectionHeader
讀入數據 (hFile, header.Magic)
讀入數據 (hFile, header.Info_CheckSum)
返回 (header)
.子程序 raw_Write_SectionHeader
.參數 hFile
.參數 NodeCheck, _SectionHeader
寫出數據 (hFile, NodeCheck.Magic)
寫出數據 (hFile, NodeCheck.Info_CheckSum)
.子程序 raw_Read_SectionInfo, _SectionInfo
.參數 hFile
.局部變量 Info, _SectionInfo
.局部變量 Bin, 字節集
.局部變量 bak, 整數型
Bin ＝ 讀入字節集 (hFile, #sizeof_SectionInfo)
CopyTo_SectionInfo (Info, Bin, #sizeof_SectionInfo)
返回 (Info)
.子程序 raw_Write_SectionInfo
.參數 hFile
.參數 SectionInfo, _SectionInfo
.局部變量 bin, 字節集
bin ＝ 取空白字節集 (#sizeof_SectionInfo)
CopyFrom_SectionInfo (bin, SectionInfo, #sizeof_SectionInfo)
寫出字節集 (hFile, bin)
.子程序 GetSectionInfoCheckSum, 整數型
.參數 Info, _SectionInfo
.局部變量 bin, 字節集
bin ＝ 取空白字節集 (#sizeof_SectionInfo)
CopyFrom_SectionInfo (bin, Info, #sizeof_SectionInfo)
返回 (GetCheckValue (bin))

輔助

.版本 2
.程序集 輔助
.子程序 輔_取文件名稱, 文本型
.參數 txt, 文本型
.局部變量 addr
.局部變量 next
addr ＝ 倒找文本 (txt, “\”, , 假)
next ＝ 尋找文本 (txt, “/”, , 假)
.如果真 (next ≠ -1)
  addr ＝ next
.如果真結束
.如果真 (addr ≠ -1)
  返回 (文本替換 (txt, 1, addr, ))
.如果真結束
返回 (txt)
.子程序 CALL, 整數型
.參數 dest
.參數 arg1, , 可空
.參數 arg2, , 可空
.參數 arg3, , 可空
.參數 arg4, , 可空
.參數 arg5, , 可空
返回 (_RawCall (dest, arg1, arg2, arg3, arg4, arg5))
.子程序 _RawCall, 整數型
.參數 dest
.參數 arg1
.參數 arg2
.參數 arg3
.參數 arg4
.參數 arg5
置入代碼 ({ 201, 88, 135, 4, 36, 255, 224 })
返回 (0)
.子程序 read_offset_memory, 整數型
.參數 ptr
.參數 offset
置入代碼 ({ 139, 69, 8, 139, 77, 12, 139, 4, 8, 201, 194, 8, 0 })
返回 (0)
.子程序 輔_取支持庫信指令, 文本型
.參數 hLib
.參數 fid
.局部變量 addr
.局部變量 count, 整數型
.局部變量 ptr
.局部變量 last_paddr, , 靜態
.局部變量 last_lib, , 靜態
.如果 (last_lib ≠ hLib)
  addr ＝ GetProcAddress (hLib, “GetNewInf”)
  .如果真 (addr ＝ 0)
    返回 (“”)
  .如果真結束
  addr ＝ CALL (addr)
  .如果真 (addr ＝ 0)
    返回 (“”)
  .如果真結束
  last_lib ＝ hLib
  last_paddr ＝ addr
.否則
  addr ＝ last_paddr
.如果結束
count ＝ read_offset_memory (addr, 100)
.如果真 (fid ＞ count)
  返回 (“”)
.如果真結束
ptr ＝ read_offset_memory (addr, 104)
ptr ＝ read_offset_memory (ptr, 36 × fid ＋ 0)
返回 (指針到文本 (ptr))
.子程序 取支持庫信指令, 文本型
.參數 basic, 程序段_頭信息
.參數 index
.參數 fid
.局部變量 hLib
.局部變量 str_list, 文本型, , "0"
index ＝ index ＋ 1
.如果真 (index ≤ 0 或 index ＞ 取數組成員數 (basic.支持庫信息))
  返回 (“”)
.如果真結束
str_list ＝ 分割文本 (basic.支持庫信息 [index], 字符 (#回車鍵), )
hLib ＝ GetModuleHandleA (str_list [1])
.如果真 (hLib ＝ 0)
  hLib ＝ GetModuleHandleA (str_list [1] ＋ “.fne”)
  .如果真 (hLib ＝ 0)
    hLib ＝ LoadLibraryA (str_list [1] ＋ “.fne”)
    .如果真 (hLib ＝ 0)
      hLib ＝ LoadLibraryA (取文本注冊項 (#現行用戶, “Software\FlySky\E\Install\Path”, ) ＋ str_list [1] ＋ “.fne”)
    .如果真結束
  .如果真結束
.如果真結束
.如果真 (hLib ＝ 0)
  返回 (“”)
.如果真結束
返回 (輔_取支持庫信指令 (hLib, fid))
.子程序 取用戶定義指令, 文本型
.參數 list, 程序段_函數, 數組
.參數 id
.局部變量 i, 整數型
.計次循環首 (取數組成員數 (list), i)
  .如果真 (list [i].段頭.dwID ＝ id)
    .如果 (list [i].名稱 ≠ “”)
      返回 (list [i].名稱)
    .否則
      返回 (“sub_” ＋ 取十六進制文本 (id))
    .如果結束
  .如果真結束
.計次循環尾 ()
返回 (“unk_” ＋ 取十六進制文本 (id))

其它

.版本 2
.支持庫 spec
.程序集 其他
.子程序 拖放文件
.參數 hwnd, 整數型
.參數 接收參數指針, 整數型
DragAcceptFiles_ (hwnd, 1)
SetProp_ (hwnd, “OriginalWndProc”, SetWindowLong_ (hwnd, #GWL_WNDPROC, 到整數 (&WndProc)))
SetProp_ (hwnd, “lpFunction”, 接收參數指針)
.子程序 接收參數
.參數 數量, 整數型
.參數 文件名組, 文本型, , 以"|"分割
.局部變量 i, 整數型
.局部變量 tmp, 文本型, , "0"
tmp ＝ 分割文本 (文件名組, “|”, )
_啟動窗口.地址編輯框.內容 ＝ tmp [1]
.子程序 WndProc, 整數型
.參數 hwnd, 整數型
.參數 msg, 整數型
.參數 wParam, 整數型
.參數 lParam, 整數型
.判斷開始 (msg ＝ #WM_DROPFILES)
  Query (wParam, GetProp_ (hwnd, “lpFunction”))
  返回 (0)
.默認
.判斷結束
返回 (CallWindowProc_ (GetProp_ (hwnd, “OriginalWndProc”), hwnd, msg, wParam, lParam))
.子程序 Query
.參數 hDrop, 整數型
.參數 接收參數的子程序指針, 整數型
.局部變量 n, 整數型
.局部變量 i, 整數型
.局部變量 length, 整數型
.局部變量 tmp, 文本型
.局部變量 fileNames, 文本型
n ＝ DragQueryFile_ (hDrop, 4294967295, 字符 (0), 0)
.計次循環首 (n, i)
  length ＝ DragQueryFile_ (hDrop, i － 1, 字符 (0), 0)
  tmp ＝ 取空白文本 (length)
  DragQueryFile_ (hDrop, i － 1, tmp, length ＋ 1)
  .判斷開始 (i ≠ 1)
    fileNames ＝ fileNames ＋ “|” ＋ tmp
  .默認
    fileNames ＝ tmp
  .判斷結束
.計次循環尾 ()
調用子程序_ (接收參數的子程序指針, 真, , n, 取變量數據地址_文本型 (fileNames))
DragFinish_ (hDrop)
.子程序 調用子程序_, 邏輯型
.參數 子程序指針或子程序地址
.參數 是否為C調用, 邏輯型, 可空
.參數 返回值, , 參考 可空
.參數 參數1, , 可空
.參數 參數2, , 可空
.參數 參數3, , 可空
.參數 參數4, , 可空
.參數 參數5, , 可空
.參數 參數6, , 可空
.參數 參數7, , 可空
.參數 參數8, , 可空
.參數 參數9, , 可空
.參數 參數10, , 可空
.參數 參數11, , 可空
.參數 參數12, , 可空
.參數 參數13, , 可空
.參數 參數14, , 可空
.參數 參數15, , 可空
置入代碼 ({ 86, 81, 51, 201, 81, 177, 15, 139, 245, 129, 198, 152, 0, 0, 0, 131, 238, 8, 139, 198, 139, 0, 133, 192, 116, 8, 139, 70, 252, 80, 131, 69, 244, 4, 226, 235, 255, 85, 8, 139, 77, 20, 137, 1, 51, 192, 57, 69, 12, 116, 3, 3, 101, 244, 89, 89, 94 })
返回 (真)
.子程序 取變量數據地址_文本型, 整數型
.參數 變量, 文本型, 參考
置入代碼 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

修復被破壞文件啟動窗口的代碼

.版本 2
.程序集 窗口程序集_啟動窗口
.子程序 __啟動窗口_創建完畢
拖放文件 (地址編輯框.取窗口句柄 (), 到整數 (&接收參數))
.子程序 _選擇文件按鈕_被單擊
通用對話框1.打開 ()
地址編輯框.內容 ＝ 通用對話框1.文件名
.子程序 _修復按鈕_被單擊
.如果真 (分析_易文件 (地址編輯框.內容, 密碼編輯框.內容, 真))
  信息框 (“已修復完成！”, 0, “提示：”, )
.如果真結束

運行結果：

看完了這篇文章，相信你對“易語言源碼被騰訊TP破壞后如何修復”有了一定的了解，如果想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！