KeyFC欢迎致辞，点击播放
资源、介绍、历史、Q群等新人必读
KeyFC 社区总索引		 如果你找到这个笔记本，请把它邮寄给我们的回忆
KeyFC 漂流瓶传递活动 Since 2011		  

請教如何解開SEEN.TXT

[ 16771 查看 / 11 回复 ]

返回列表 12
发新话题 回复该主题
Prz
头像

千砂与美纱的神隐

  • - 根性组 -
  • 来自：国立万年小学校
  • 人家是女孩子的说
  • 生日：2003-06-01
  • 注册： 2002-09-18
  • 精华：15
  • 学分：0 个
  • 好人卡：40 张
  • 好感度：550
  • [爸爸国]
2007-07-17 13:52 |只看该用户 11#
t T

回复: 請教如何解開SEEN.TXT

原帖由 Serw 于 2007-7-17 13:23:00 发表
问题是上文还有你的AVG32脚本解析工具都只能得到指令, 看不到操作数的格式. 比如 $1C        Jump        无条件跳转, 最后会跳转到什么地方? $37        Var        Bit变量赋值 是给哪个变量赋什么值?


快速的回顾了一下我的解析器的源码，每一个指令的参数在解析器内部好像都分析出来了的。
我记得当时是因为没有工夫去写详细的界面，于是没有把所有的信息都显示出来(但是解析器二进制窗口中你点每条指令就会把对应的参数源码显示出来，这样很方便用眼睛瞄得:D)

鉴于楼上应该已经能够解包SEEN了，我这里只把对解开后的每个脚本的解析代码列出来:
  1. // Copyright 2001-2004 Misha @ Keyfc.net

  2. // 仅供个人研究学习，严禁他用

  3. // 未经作者许可，请勿转载



  5. Unit SCENUnpack;



  7. Interface



  9. Uses SysUtils, ComCtrls, Contnrs, MD5Service;



  11. Const

  12.   ScenFileSignature: String = 'TPC32';



  14. ResourceString

  15.   SeenScriptSignError = '脚本签名错误';

  16.   SeenHeaderMenuCountError = '脚本菜单数量错误 (%d)';

  17.   SeenHeaderSubMenuCountError = '脚本子菜单数量错误 (%d:%d)';

  18.   SeenHeaderSubMenuMaxError = '脚本子菜单最值错误 (%d-%d:%d)';

  19.   SeenHeaderSubMenuLoopError = '脚本循环子菜单标记数量错误 (%d-%d-%d:%d)';

  20.   SeenHeaderGetTextError = '错误的行号';

  21.   SeenCMDTextExtractNIL = '无效文字提取过程';

  22.   SeenCMDNIL = '空指令序列';

  23.   SeenCMDSelectListError = '选项列表没有开始';

  24.   SeenCMDSumError = '不能识别的求和指令';

  25.   SeenCMDValueHeaderError = '无效数值头';

  26.   SeenCMDConditionLevelOverflow = '太多的条件嵌套';

  27.   SeenCMDConditionLOperPosError = '无效的逻辑指令位置';

  28.   SeenCMDConditionPropertyUnExp = '意外的属性指令';

  29.   SeenCMDConditionPropertyPosError = '无效的属性指令位置';

  30.   SeenCMDConditionPropertyError = '无效的属性指令参数';

  31.   SeenCMDConditionError = '无效的条件指令';

  32.   SeenCMDFStringConditionError = '同一分支出现多个条件';

  33.   SeenCMDFString10hSubCMDError = '无效的字符串格式 ($10子指令)';

  34.   SeenCMDFStringError = '无效的字符串格式';



  36.   SeenCMDExplainDetailUnImp = '$%.2x:$%.2x 的详细资料 (不可用功能)';

  37.   SeenCMDFaultHeader = '出错命令:';

  38.   SeenCMDExpEmpty = '空指令记录';



  40.   SeenCMDExpCat01 = '全部脚本结束';

  41.   SeenCMDExpCat02 = '等待鼠标点击, 然后换行或者清除文字';

  42.   SeenCMDExpCat03 = '换行 {...}';

  43.   SeenCMDExpCat04 = '等待点击, 然后继续脚本';

  44.   SeenCMDExpCat05 = '文本窗口操作 {...}';

  45.   SeenCMDExpCat06 = '特效文本 {...}';

  46.   SeenCMDExpCat07 = '图像/PDT文件操作 {...}';

  47.   SeenCMDExpCat08 = '动画操作 {...}';

  48.   SeenCMDExpCat09 = '声音/媒体操作 {...}';

  49.   SeenCMDExpCat10 = '变量文字写入 {...}';

  50.   SeenCMDExpCat11 = '图像渐变操作 {...}';

  51.   SeenCMDExpCat12 = '条件转移';

  52.   SeenCMDExpCat13 = '指令转移 {...}';

  53.   SeenCMDExpCat14 = '图像摇动 {...}';

  54.   SeenCMDExpCat15 = '文字颜色';

  55.   SeenCMDExpCat16 = '等待 {...}';

  56.   SeenCMDExpCat17 = '脚本内嵌入';

  57.   SeenCMDExpCat18 = '无条件跳转';

  58.   SeenCMDExpCat19 = '查询表格条件嵌入';

  59.   SeenCMDExpCat20 = '查询表格条件跳转';

  60.   SeenCMDExpCat21 = '嵌入返回';

  61.   SeenCMDExpCat22 = 'Bit变量赋值';

  62.   SeenCMDExpCat23 = 'Bit变量复制';

  63.   SeenCMDExpCat24 = '整数变量赋值';

  64.   SeenCMDExpCat25 = '整数变量 +';

  65.   SeenCMDExpCat26 = '整数变量 -';

  66.   SeenCMDExpCat27 = '整数变量 *';

  67.   SeenCMDExpCat28 = '整数变量 /';

  68.   SeenCMDExpCat29 = '整数变量 %';

  69.   SeenCMDExpCat30 = '整数变量 AND';

  70.   SeenCMDExpCat31 = '整数变量 OR';

  71.   SeenCMDExpCat32 = '整数变量 XOR';

  72.   SeenCMDExpCat33 = '整数变量复制';

  73.   SeenCMDExpCat34 = '整数变量 + 整数变量';

  74.   SeenCMDExpCat35 = '整数变量 - 整数变量';

  75.   SeenCMDExpCat36 = '整数变量 * 整数变量';

  76.   SeenCMDExpCat37 = '整数变量 / 整数变量';

  77.   SeenCMDExpCat38 = '整数变量 % 整数变量';

  78.   SeenCMDExpCat39 = '整数变量 AND 整数变量';

  79.   SeenCMDExpCat40 = '整数变量 OR 整数变量';

  80.   SeenCMDExpCat41 = '整数变量 XOR 整数变量';

  81.   SeenCMDExpCat42 = 'Bit变量随机赋值';

  82.   SeenCMDExpCat43 = '整数变量随机赋值';

  83.   SeenCMDExpCat44 = '用户选择操作 {...}';

  84.   SeenCMDExpCat45 = '字符串操作 {...}';

  85.   SeenCMDExpCat46 = '多变量赋值 {...}';

  86.   SeenCMDExpCat47 = '多变量初始化 {...}';

  87.   SeenCMDExpCat48 = '多变量顺序复制 {...}';

  88.   SeenCMDExpCat49 = '获得脚本信息 {...}';

  89.   SeenCMDExpCat50 = '多变量统计操作 {...}';

  90.   SeenCMDExpCat51 = '系统杂项操作 {...}';

  91.   SeenCMDExpCat52 = '名称操作 {...}';

  92.   SeenCMDExpCat53 = '图像Get/Put操作 {...}';

  93.   SeenCMDExpCat54 = '图像处理 {...}';

  94.   SeenCMDExpCat55 = '写字符串到图像缓存';

  95.   SeenCMDExpCat56 = '图像缓存操作 {...}';

  96.   SeenCMDExpCat57 = '图像画面操作 {...}';

  97.   SeenCMDExpCat58 = '图像滚动切换';

  98.   SeenCMDExpCat59 = '多图像滚动处理 {...}';

  99.   SeenCMDExpCat60 = '区域信息操作 {...}';

  100.   SeenCMDExpCat61 = '鼠标操作 {...}';

  101.   SeenCMDExpCat62 = 'CG模式操作 {...}';

  102.   SeenCMDExpCat63 = '系统窗口状态操作 {...}';

  103.   SeenCMDExpCat64 = '系统窗口位置操作 {...}';

  104.   SeenCMDExpCat65 = '系统状态操作 {...}';

  105.   SeenCMDExpCat66 = '弹出菜单控制 {...}';

  106.   SeenCMDExpCat67 = '音量控制 {...}';

  107.   SeenCMDExpCat68 = 'Novel模式控制 {...}';

  108.   SeenCMDExpCat69 = '显示半角文字';

  109.   SeenCMDExpCat70 = '显示全角文字';

  110.   SeenCMDExpCatXX = '未知命令 $%.2x:$%.2x';



  112. Type

  113.   RMixInt = Record

  114.   Case Boolean of

  115.     True:  ( Bytes: Array[0..3] of Char );

  116.     False: ( AInt: Integer );

  117.   END;



  119.   RScenHeader = Record

  120.   Sign: Array [1..16] of Char;

  121.   Resv: Array [1..8] of Char;

  122.   LineCount: Integer;

  123.   END;



  125.   RScenMenu = Record

  126.   Start, LoopBack: Integer;

  127.   Num: Byte;



  129.   SubNum, ID, StrID: Array[1..8] of Byte;

  130.   SubCnt, SubCntMax, SubID, SubStrID: Array[1..8, 1..8] of Byte;

  131.   Flag: Array[1..8, 1..8, 1..8] of Byte;

  132.   SubStart: Array[1..8, 1..8, 1..8] of Integer;

  133.   Str: Array[0..71] of ANSIString;



  135.   Cur, CurSub, CurSubSub: Integer;

  136.   Bit, BitCnt, SubBit, SubBitCnt: Byte;

  137.   END;



  139.   RLine = Record

  140.   Index: Integer;

  141.   Text: ANSIString;

  142.   END;



  144.   RValue = Record

  145.   IsRegister: Boolean;

  146.   Spacing: Byte;

  147.   Value: Integer;

  148.   END;



  150.   RText = Record

  151.   IsRegister: Boolean;

  152.   IsIndirect: Boolean;

  153.   Value: Integer;

  154.   Spacing: Integer;

  155.   Text: ANSIString;

  156.   END;



  158.   SCondType = ( CPRInt, CPRBit, CPImm, CPAttr, CPLOp );



  160.   RCondRec = Record

  161.   CType:  SCondType;

  162.   CValue: Integer;

  163.   END;



  165.   RConR = Array of RCondRec;



  167.   RCond = Record

  168.   Spacing: Integer;

  169.   Condition: RConR;

  170.   END;



  172.   RSelect = Record

  173.   Text: ANSIString;

  174.   Condition: RConR;

  175.   END;



  177.   PPutLineProc = Procedure(Index: Integer; Text: ANSIString) of Object;



  179.   RScenCMD = Class

  180.   Private

  181.     Offset: Integer;

  182.     Source: ANSIString;



  184.     CMD, SCMD, SSCMD: Byte;



  186.     CMDIntR: Array[1..32] of RValue;

  187.     CMDStrR: Array[1..4]  of RText;

  188.     CMDStr:  Array[1..2]  of ANSIString;

  189.     CMDInt:  Array[1..16] of Integer;



  191.     CMDAInt:  Array of Integer;

  192.     CMDAByte: Array of Byte;

  193.     CMDAStr:  Array of ANSIString;



  195.     CMDAIntR:  Array of RValue;

  196.     CMDAIntDR: Array of Array of RValue;

  197.     CMDAStrR:  Array of RText;

  198.     CMDACond:  Array of RCond;

  199.     CMDASelR:  Array of RSelect;



  201.     Function IntReader(Pos: Integer): Integer;

  202.     Function ValueReader(Pos: Integer): RValue;

  203.     Function TextReader(Pos: Integer): RText;

  204.     Function Conditioner(Pos: Integer; ExpectAttr: Boolean = False): RCond;

  205.     Function ReadFString(Pos: Integer; ExpectAttr: Boolean = False): Integer;

  206.     Function Han2Zen(StrIn: ANSIString): ANSIString;



  208.     Procedure Fault(Error: String; Pos: Integer = 256);

  209.   Public

  210.     Constructor Create(OrigLen, LineMax: Integer; PutLine:PPutLineProc; Var CMDString: ANSIString);

  211.     Destructor  Destroy; Override;



  213.     Function  Explain(Detail: Boolean): String;

  214.     Procedure ExpressTree(Tree: TTreeView; Root: TTreeNode);



  216.     Property RAWText: ANSIString read Source;

  217.     Property Start: Integer read Offset;

  218.   END;



  220.   RCMDTerm = Class

  221.   Private

  222.     ErrorMSG: String;



  224.   Public

  225.     Constructor Create(LError: String);

  226.     Destructor Destroy; Override;



  228.     Property Error: String read ErrorMSG;

  229.   END;



  231.   TScenario = Class

  232.   Private

  233.     SourceLen: Integer;

  234.     SourceMD5: String;



  236.     Source: ANSIString;

  237.     Header: RScenHeader;

  238.     IndexedLines: Array of RLine;



  240.     MenuPad:  Integer;

  241.     Version:  Integer;

  242.     ExtraPad: Integer;

  243.     Counter:  Integer;

  244.     JumpBase: Integer;

  245.     StartPos: Integer;



  247.     Menu: RScenMenu;

  248.     CMDS: TObjectList;



  250.     Function IntReader(Pos: Integer): Integer;

  251.     Function GetLine(Index: Integer): RLine;

  252.     Procedure PutLine(Index: Integer; Text: ANSIString);

  253.   Public

  254.     Constructor Create(SeenFile: ANSIString);

  255.     Destructor Destroy; Override;



  257.     Property SLen: Integer read SourceLen;

  258.     Property SMD5: String  read SourceMD5;

  259.     Property RAWText: ANSIString read Source;



  261.     Property MPad:  Integer read MenuPad;

  262.     Property Ver:  Integer read Version;

  263.     Property ExPad: Integer read ExtraPad;

  264.     Property Cntr:  Integer read Counter;

  265.     Property JMase: Integer read JumpBase;

  266.     Property Start: Integer read StartPos;



  268.     Property SHeader: RScenHeader read Header;

  269.     Property SMenu: RScenMenu read Menu;

  270.     Property SCMDS: TObjectList read CMDS;

  271.     Property Lines[Index: Integer]: RLine read GetLine;

  272.   end;



  274. Implementation



  276. Constructor RCMDTerm.Create(LError: String);

  277.   BEGIN

  278.   Inherited Create;



  280.   ErrorMSG:= LError;

  281.   END;



  283. Destructor RCMDTerm.Destroy;

  284.   BEGIN

  285.   Inherited;

  286.   END;



  288. Constructor TScenario.Create(SeenFile: ANSIString);

  289.   Var

  290.   I, J, K, L: Integer;

  291.   Pos, Str, Loop: Integer;



  293.   CMDSerial: ANSIString;

  294.   CMDItem: RScenCMD;

  295.   BEGIN

  296.   Inherited Create;

  297.   Source:= SeenFile;

  298.   SourceLen:= Length(Source);

  299.   SourceMD5:= MD5(Source);



  301.   Move(PChar(Source)^,Header,Sizeof(RScenHeader));

  302.   IF Trim(String(Header.Sign)) <> ScenFileSignature then

  303.     Raise Exception.Create(SeenScriptSignError);



  305.   SetLength(IndexedLines,Header.LineCount);

  306.   For I:= 0 to Header.LineCount-1 do

  307.     IndexedLines[I].Index:= IntReader($21+I*4);



  309.   MenuPad:= Header.LineCount * 4 + $50;

  310.   Pos:= MenuPad+1;

  311.   Version:= IntReader(Pos);

  312.   if Version = 5 then ExtraPad:= 4

  313.                   else ExtraPad:= 0;



  315.   Menu.Num:= IntReader(Pos-$24);

  316.   Counter:= IntReader(Pos-$28)-1;



  318.   // Reading Menu...

  319.   Str:= 0;

  320.   if Menu.Num > 8 then

  321.     Raise Exception.Create(Format(SeenHeaderMenuCountError, [ Menu.Num ]));



  323.   For I:= 1 to Menu.Num do

  324.     BEGIN

  325.     Menu.ID[I]:= ORD(Source[Pos]);

  326.     Menu.SubNum[I]:= ORD(Source[Pos+1]);

  327.     Inc(Pos,2);

  328.     Menu.StrID[I]:= Str; Inc(Str);



  330.     if Menu.SubNum[I] > 8 then

  331.       Raise Exception.Create(Format(SeenHeaderSubMenuCountError, [ I, Menu.SubNum[I] ]));



  333.     For J:= 1 to Menu.SubNum[I] do

  334.       BEGIN

  335.       Menu.SubID[I][J]:= ORD(Source[Pos]);

  336.       Menu.SubCntMax[I][J]:= ORD(Source[Pos+1]);

  337.       Inc(Pos,2);

  338.       Menu.SubStrID[I][J]:= Str; Inc(Str);



  340.       if Menu.SubCntMax[I][J] > 8 then

  341.         Raise Exception.Create(Format(SeenHeaderSubMenuMaxError, [ I, J, Menu.SubCntMax[I][J] ]));



  343.       For K:= 1 to Menu.SubCntMax[I][J] do

  344.         BEGIN

  345.         Loop:= ORD(Source[Pos]); Inc(Pos);



  347.         if Loop > 8 then

  348.           Raise Exception.Create(Format(SeenHeaderSubMenuLoopError, [ I, J, K, Loop ]));



  350.         For L:= 1 to Loop do

  351.           BEGIN

  352.           Menu.Flag[I][J][K]:= ORD(Source[Pos]);

  353.           Inc(Pos,3);

  354.           END;

  355.         END;

  356.       END;

  357.     END;



  359.   For I:= 1 to Str do

  360.     BEGIN

  361.     Menu.Str[I]:= PChar(Copy(Source,Pos+1,SourceLen));

  362.     Inc(Pos,ORD(Source[Pos])+1);

  363.     END;



  365.   Menu.Start:= IntReader(MenuPad+ExtraPad+$F+1) - 1;

  366.   Loop:= Menu.Start + 1;

  367.   StartPos:= MenuPad + ExtraPad + $13;

  368.   IF Counter > 0 then

  369.     BEGIN

  370.     Menu.LoopBack:= Loop + 4;

  371.     For I:= 1 to Counter do

  372.       Inc(Loop,IntReader(StartPos + Loop + 1)+4);

  373.     END;



  375.   For I:= 1 to Menu.Num do

  376.     For J:= 1 to Menu.SubNum[I] do

  377.     For K:= 1 to Menu.SubCntMax[I][J] do

  378.       BEGIN

  379.       Menu.SubStart[I][J][K]:= Loop + 4;

  380.       Inc(Loop,IntReader(StartPos + Loop + 1)+4);

  381.       END;



  383.   Menu.Cur:= -1;

  384.   Menu.Bit:= 1;

  385.   Menu.BitCnt:= 0;

  386.   Menu.SubBit:= 1;

  387.   Menu.SubBitCnt:= 0;

  388.   JumpBase:= 0;



  390.   CMDS:= TObjectList.Create(True);

  391.   CMDSerial:= Copy(Source,StartPos+1,Length(Source));

  392.   L:= Length(CMDSerial);

  393.   Repeat

  394.     Try

  395.     CMDItem:= RScenCMD.Create(L, Header.LineCount, PutLine, CMDSerial);

  396.     CMDS.Add(CMDItem);

  397.     Except

  398.     On E:Exception do

  399.       BEGIN

  400.       CMDS.Add(RCMDTerm.Create(E.Message));

  401.       Break;

  402.       END;

  403.     END;

  404.   Until CMDSerial = '';

  405.   END;



  407. Destructor TScenario.Destroy;

  408.   BEGIN

  409.   FreeAndNIL(CMDS);

  410.   SetLength(IndexedLines,0);



  412.   Inherited;

  413.   END;



  415. Function TScenario.IntReader(Pos: Integer): Integer;

  416.   Var

  417.   Cache: RMixInt;

  418.   BEGIN

  419.   Cache.Bytes[0]:= Source[Pos];

  420.   Cache.Bytes[1]:= Source[Pos+1];

  421.   Cache.Bytes[2]:= Source[Pos+2];

  422.   Cache.Bytes[3]:= Source[Pos+3];

  423.   Result:= Cache.AInt;

  424.   END;



  426. Function TScenario.GetLine(Index: Integer): RLine;

  427.   BEGIN

  428.   IF Index < Length(IndexedLines) then

  429.     Result:= IndexedLines[Index]

  430.   else

  431.     BEGIN

  432.     Result.Index:= -1;

  433.     Result.Text:= SeenHeaderGetTextError;

  434.     END;

  435.   END;



  437. Procedure TScenario.PutLine(Index: Integer; Text: ANSIString);

  438.   BEGIN

  439.   IndexedLines[Index].Text:= Text;

  440.   END;



  442. Constructor RScenCMD.Create(OrigLen, LineMax: Integer; PutLine:PPutLineProc; Var CMDString: ANSIString);

  443.   Var

  444.   Counter: Integer;

  445.   SizeCache: Integer;

  446.   J, K, L, M: Integer;

  447.   BEGIN

  448.   Inherited Create;



  450.   Source:= CMDString;

  451.   SizeCache:= Length(Source);

  452.   Offset:= OrigLen - SizeCache;



  454.   IF NOT Assigned(PutLine) then Fault(SeenCMDTextExtractNIL,0);

  455.   IF CMDString = '' then Fault(SeenCMDNIL,0);



  457.   Counter:= 1;

  458.   CMD:= ORD(Source[Counter]);

  459.   Inc(Counter);

  460.   Try

  461.     Case CMD of

  462.     $00, $01, $03, $06, $1A, $22..$29, $65:

  463.       BEGIN

  464.       Dec(Counter);

  465.       END;

  466.     $02, $04, $20, $30:

  467.       BEGIN

  468.       SCMD:= ORD(Source[Counter]);

  469.       END;

  470.     $05, $7F:

  471.       BEGIN

  472.       CMDIntR[1]:= ValueReader(Counter);

  473.       Inc(Counter,CMDIntR[1].Spacing-1);

  474.       END;

  475.     $08:

  476.       BEGIN

  477.       SCMD:= ORD(Source[Counter]);

  478.       Inc(Counter);

  479.       Case SCMD of

  480.         $01:

  481.         BEGIN

  482.           Dec(Counter);

  483.         END;

  484.         $10, $11:

  485.         BEGIN

  486.           CMDIntR[1]:= ValueReader(Counter);

  487.           Inc(Counter,CMDIntR[1].Spacing-1);

  488.         END;

  489.         ELSE Dec(Counter);

  490.       END;

  491.       END;

  492.     $0B:

  493.       BEGIN

  494.       SCMD:= ORD(Source[Counter]);

  495.       Inc(Counter);

  496.       Case SCMD of

  497.         $01, $03, $05, $09, $10, $54:

  498.         BEGIN

  499.           CMDStrR[1]:= TextReader(Counter);

  500.           Inc(Counter,CMDStrR[1].Spacing);



  502.           CMDIntR[1]:= ValueReader(Counter);

  503.           Inc(Counter,CMDIntR[1].Spacing-1);

  504.         END;

  505.         $02, $04, $06:

  506.         BEGIN

  507.           CMDStrR[1]:= TextReader(Counter);

  508.           Inc(Counter,CMDStrR[1].Spacing);



  510.           For J:= 1 to 15 do

  511.           BEGIN

  512.             CMDIntR[J]:= ValueReader(Counter);

  513.             Inc(Counter,CMDIntR[J].Spacing);

  514.           END;



  516.           Dec(Counter);

  517.         END;

  518.         $08, $13, $30, $50:

  519.         BEGIN

  520.           Dec(Counter);

  521.         END;

  522.         $11:

  523.         BEGIN

  524.           CMDStrR[1]:= TextReader(Counter);

  525.           Inc(Counter,CMDStrR[1].Spacing-1);

  526.         END;

  527.         $22:

  528.         BEGIN

  529.           K:= ORD(Source[Counter]);



  531.           SetLength(CMDAStrR,K);

  532.           SetLength(CMDAByte,K);

  533.           SetLength(CMDAIntDR,K,7);

  534.           Inc(Counter);



  536.           CMDStrR[1]:= TextReader(Counter);

  537.           Inc(Counter,CMDStrR[1].Spacing);



  539.           CMDIntR[1]:= ValueReader(Counter);

  540.           Inc(Counter,CMDIntR[1].Spacing);



  542.           For J:= 0 to K-1 do

  543.           BEGIN

  544.             L:= ORD(Source[Counter]);

  545.             Inc(Counter);



  547.             CMDAByte[J]:= L;

  548.             CMDAStrR[J]:= TextReader(Counter);

  549.             Inc(Counter,CMDAStrR[J].Spacing);



  551.             Case L of

  552.             $01:

  553.               BEGIN

  554.               { NOTHING }

  555.               END;

  556.             $02:

  557.               BEGIN

  558.               CMDAIntDR[J][0]:= ValueReader(Counter);

  559.               Inc(Counter,CMDAIntDR[J][0].Spacing);

  560.               END;

  561.             $03:

  562.               BEGIN

  563.               For M:= 0 to 5 do

  564.                 BEGIN

  565.                 CMDAIntDR[J][M]:= ValueReader(Counter);

  566.                 Inc(Counter,CMDAIntDR[J][M].Spacing);

  567.                 END;

  568.               END;

  569.             $04:

  570.               BEGIN

  571.               For M:= 0 to 6 do

  572.                 BEGIN

  573.                 CMDAIntDR[J][M]:= ValueReader(Counter);

  574.                 Inc(Counter,CMDAIntDR[J][M].Spacing);

  575.                 END;

  576.               END;

  577.             END;

  578.           END;

  579.           Dec(Counter);

  580.         END;

  581.         $24:

  582.         BEGIN

  583.           K:= ORD(Source[Counter]);



  585.           SetLength(CMDAStrR,K);

  586.           SetLength(CMDAByte,K);

  587.           SetLength(CMDAIntDR,K,7);

  588.           Inc(Counter);



  590.           CMDIntR[1]:= ValueReader(Counter);

  591.           Inc(Counter,CMDIntR[1].Spacing);



  593.           CMDIntR[2]:= ValueReader(Counter);

  594.           Inc(Counter,CMDIntR[2].Spacing);



  596.           For J:= 0 to K-1 do

  597.           BEGIN

  598.             L:= ORD(Source[Counter]);

  599.             Inc(Counter);



  601.             CMDAByte[J]:= L;

  602.             CMDAStrR[J]:= TextReader(Counter);

  603.             Inc(Counter,CMDAStrR[J].Spacing);



  605.             Case L of

  606.             $01:

  607.               BEGIN

  608.               { NOTHING }

  609.               END;

  610.             $02:

  611.               BEGIN

  612.               CMDAIntDR[J][0]:= ValueReader(Counter);

  613.               Inc(Counter,CMDAIntDR[J][0].Spacing);

  614.               END;

  615.             $03:

  616.               BEGIN

  617.               For M:= 0 to 5 do

  618.                 BEGIN

  619.                 CMDAIntDR[J][M]:= ValueReader(Counter);

  620.                 Inc(Counter,CMDAIntDR[J][M].Spacing);

  621.                 END;

  622.               END;

  623.             $04:

  624.               BEGIN

  625.               For M:= 0 to 6 do

  626.                 BEGIN

  627.                 CMDAIntDR[J][M]:= ValueReader(Counter);

  628.                 Inc(Counter,CMDAIntDR[J][M].Spacing);

  629.                 END;

  630.               END;

  631.             END;

  632.           END;

  633.           Dec(Counter);

  634.         END;

  635.         $31, $32, $33, $52:

  636.         BEGIN

  637.           CMDIntR[1]:= ValueReader(Counter);

  638.           Inc(Counter,CMDIntR[1].Spacing-1);

  639.         END;

  640.         ELSE Dec(Counter);

  641.       END;

  642.       END;

  643.     $0C:

  644.       BEGIN

  645.       SCMD:= ORD(Source[Counter]);

  646.       Inc(Counter);

  647.       Case SCMD of

  648.         $10:

  649.         BEGIN

  650.           CMDStrR[1]:= TextReader(Counter);

  651.           Inc(Counter,CMDStrR[1].Spacing);



  653.           CMDIntR[1]:= ValueReader(Counter);

  654.           Inc(Counter,CMDIntR[1].Spacing-1);

  655.         END;

  656.         $18:

  657.         BEGIN

  658.           CMDStrR[1]:= TextReader(Counter);

  659.           Inc(Counter,CMDStrR[1].Spacing);



  661.           CMDIntR[1]:= ValueReader(Counter);

  662.           Inc(Counter,CMDIntR[1].Spacing);



  664.           CMDStrR[2]:= TextReader(Counter);

  665.           Inc(Counter,CMDStrR[2].Spacing-1);

  666.         END;

  667.         $12, $30, $20, $24:

  668.         BEGIN

  669.           CMDStrR[1]:= TextReader(Counter);

  670.           Inc(Counter,CMDStrR[1].Spacing);



  672.           K:= 1; L:= 0;

  673.           While Source[Counter] <> #00 do

  674.           BEGIN

  675.             SetLength(CMDAIntR,K);

  676.             CMDAIntR[L]:= ValueReader(Counter);

  677.             Inc(Counter,CMDAIntR[L].Spacing);

  678.             Inc(K); Inc(L);

  679.           END;

  680.           Dec(Counter);

  681.         END;

  682.         $13, $21, $25:

  683.         BEGIN

  684.           Dec(Counter);

  685.         END;

  686.         $16:

  687.         BEGIN

  688.           CMDStrR[1]:= TextReader(Counter);

  689.           Inc(Counter,CMDStrR[1].Spacing);



  691.           CMDIntR[1]:= ValueReader(Counter);

  692.           Inc(Counter,CMDIntR[1].Spacing);



  694.           CMDStrR[2]:= TextReader(Counter);

  695.           Inc(Counter,CMDStrR[2].Spacing);



  697.           CMDIntR[2]:= ValueReader(Counter);

  698.           Inc(Counter,CMDIntR[2].Spacing-1);

  699.         END;

  700.         ELSE Dec(Counter);

  701.       END;

  702.       END;

  703.     $0E:

  704.       BEGIN

  705.       SCMD:= ORD(Source[Counter]);

  706.       Inc(Counter);

  707.       Case SCMD of

  708.         $01, $02, $03, $30, $32, $34:

  709.         BEGIN

  710.           CMDStrR[1]:= TextReader(Counter);

  711.           Inc(Counter,CMDStrR[1].Spacing-1);

  712.         END;

  713.         $05, $06, $07, $31, $33, $35:

  714.         BEGIN

  715.           CMDStrR[1]:= TextReader(Counter);

  716.           Inc(Counter,CMDStrR[1].Spacing);



  718.           CMDIntR[1]:= ValueReader(Counter);

  719.           Inc(Counter,CMDIntR[1].Spacing-1);

  720.         END;

  721.         $10, $20, $21, $37, $39, $40:

  722.         BEGIN

  723.           CMDIntR[1]:= ValueReader(Counter);

  724.           Inc(Counter,CMDIntR[1].Spacing-1);

  725.         END;

  726.         $11, $12, $36, $38:

  727.         BEGIN

  728.           Dec(Counter);

  729.         END;

  730.         $22:

  731.         BEGIN

  732.           CMDIntR[1]:= ValueReader(Counter);

  733.           Inc(Counter,CMDIntR[1].Spacing);



  735.           CMDIntR[2]:= ValueReader(Counter);

  736.           Inc(Counter,CMDIntR[2].Spacing-1);

  737.         END;

  738.         $50, $51, $52, $53:

  739.         BEGIN

  740.           CMDStrR[1]:= TextReader(Counter);

  741.           Inc(Counter,CMDStrR[1].Spacing);



  743.           For J:= 1 to 4 do

  744.           BEGIN

  745.             CMDIntR[J]:= ValueReader(Counter);

  746.             Inc(Counter,CMDIntR[J].Spacing);

  747.           END;

  748.           Dec(Counter);

  749.         END;

  750.         $54, $55:

  751.         BEGIN

  752.           CMDStrR[1]:= TextReader(Counter);

  753.           Inc(Counter,CMDStrR[1].Spacing);



  755.           CMDStrR[2]:= TextReader(Counter);

  756.           Inc(Counter,CMDStrR[2].Spacing);



  758.           For J:= 1 to 4 do

  759.           BEGIN

  760.             CMDIntR[J]:= ValueReader(Counter);

  761.             Inc(Counter,CMDIntR[J].Spacing);

  762.           END;

  763.           Dec(Counter);

  764.         END;

  765.         ELSE Dec(Counter);

  766.       END;

  767.       END;

  768.     $10:

  769.       BEGIN

  770.       SCMD:= ORD(Source[Counter]);

  771.       Inc(Counter);

  772.       Case SCMD of

  773.         $01, $03:

  774.         BEGIN

  775.           CMDIntR[1]:= ValueReader(Counter);

  776.           Inc(Counter,CMDIntR[1].Spacing-1);

  777.         END;

  778.         $02:

  779.         BEGIN

  780.           CMDIntR[1]:= ValueReader(Counter);

  781.           Inc(Counter,CMDIntR[1].Spacing);



  783.           CMDIntR[2]:= ValueReader(Counter);

  784.           Inc(Counter,CMDIntR[2].Spacing-1);

  785.         END;

  786.         ELSE Dec(Counter);

  787.       END;

  788.       END;

  789.     $13:

  790.       BEGIN

  791.       SCMD:= ORD(Source[Counter]);

  792.       Inc(Counter);

  793.       Case SCMD of

  794.         $01, $10:

  795.         BEGIN

  796.           CMDIntR[1]:= ValueReader(Counter);

  797.           Inc(Counter,CMDIntR[1].Spacing-1);

  798.         END;

  799.         $02:

  800.         BEGIN

  801.           CMDIntR[1]:= ValueReader(Counter);

  802.           Inc(Counter,CMDIntR[1].Spacing);



  804.           CMDIntR[2]:= ValueReader(Counter);

  805.           Inc(Counter,CMDIntR[2].Spacing-1);

  806.         END;

  807.         $03, $11:

  808.         BEGIN

  809.           CMDIntR[1]:= ValueReader(Counter);

  810.           Inc(Counter,CMDIntR[1].Spacing);



  812.           CMDIntR[2]:= ValueReader(Counter);

  813.           Inc(Counter,CMDIntR[2].Spacing);



  815.           CMDIntR[3]:= ValueReader(Counter);

  816.           Inc(Counter,CMDIntR[3].Spacing-1);

  817.         END;

  818.         $04:

  819.         BEGIN

  820.           CMDIntR[1]:= ValueReader(Counter);

  821.           Inc(Counter,CMDIntR[1].Spacing);



  823.           CMDIntR[2]:= ValueReader(Counter);

  824.           Inc(Counter,CMDIntR[2].Spacing);



  826.           CMDIntR[3]:= ValueReader(Counter);

  827.           Inc(Counter,CMDIntR[3].Spacing);



  829.           CMDIntR[4]:= ValueReader(Counter);

  830.           Inc(Counter,CMDIntR[4].Spacing-1);

  831.         END;

  832.         ELSE Dec(Counter);

  833.       END;

  834.       END;

  835.     $15:

  836.       BEGIN

  837.       SetLength(CMDACond,1);

  838.       CMDACond[0]:= Conditioner(Counter);

  839.       Inc(Counter,CMDACond[0].Spacing);



  841.       CMDInt[1]:= IntReader(Counter);

  842.       Inc(Counter,3);

  843.       END;

  844.     $16:

  845.       BEGIN

  846.       SCMD:= ORD(Source[Counter]);

  847.       Inc(Counter);



  849.       CMDIntR[1]:= ValueReader(Counter);

  850.       Inc(Counter,CMDIntR[1].Spacing-1);

  851.       END;

  852.     $17, $18, $2C, $31:

  853.       BEGIN

  854.       SCMD:= ORD(Source[Counter]);

  855.       Inc(Counter);

  856.       Case SCMD of

  857.         $01:

  858.         BEGIN

  859.           CMDIntR[1]:= ValueReader(Counter);

  860.           Inc(Counter,CMDIntR[1].Spacing-1);

  861.         END;

  862.         ELSE Dec(Counter);

  863.       END;

  864.       END;

  865.     $19:

  866.       BEGIN

  867.       SCMD:= ORD(Source[Counter]);

  868.       Inc(Counter);

  869.       Case SCMD of

  870.         $01, $04, $06:

  871.         BEGIN

  872.           CMDIntR[1]:= ValueReader(Counter);

  873.           Inc(Counter,CMDIntR[1].Spacing-1);

  874.         END;

  875.         $02, $05:

  876.         BEGIN

  877.           CMDIntR[1]:= ValueReader(Counter);

  878.           Inc(Counter,CMDIntR[1].Spacing);



  880.           CMDIntR[2]:= ValueReader(Counter);

  881.           Inc(Counter,CMDIntR[2].Spacing-1);

  882.         END;

  883.         $03, $10, $11, $12, $13:

  884.         BEGIN

  885.           Dec(Counter);

  886.         END;

  887.         ELSE Dec(Counter);

  888.       END;

  889.       END;

  890.     $1B, $1C:

  891.       BEGIN

  892.       CMDInt[1]:= IntReader(Counter);

  893.       Inc(Counter,3);

  894.       END;

  895.     $1D, $1E:

  896.       BEGIN

  897.       M:= ORD(Source[Counter]);

  898.       CMDInt[1]:= M;

  899.       Inc(Counter);



  901.       CMDIntR[1]:= ValueReader(Counter);

  902.       Inc(Counter,CMDIntR[1].Spacing);



  904.       SetLength(CMDAInt,M);

  905.       For L:= 0 to M-2 do

  906.         BEGIN

  907.         CMDAInt[L]:= IntReader(Counter);

  908.         Inc(Counter,4);

  909.         END;



  911.       CMDInt[2]:= IntReader(Counter);

  912.       Inc(Counter,3);

  913.       END;

  914.     $2D:

  915.       BEGIN

  916.       SCMD:= ORD(Source[Counter]);

  917.       Inc(Counter);

  918.       Case SCMD of

  919.         $01, $02:

  920.         BEGIN

  921.           CMDIntR[1]:= ValueReader(Counter);

  922.           Inc(Counter,CMDIntR[1].Spacing-1);

  923.         END;

  924.         $03, $04:

  925.         BEGIN

  926.           CMDIntR[1]:= ValueReader(Counter);

  927.           Inc(Counter,CMDIntR[1].Spacing);



  929.           CMDIntR[2]:= ValueReader(Counter);

  930.           Inc(Counter,CMDIntR[2].Spacing-1);

  931.         END;

  932.         ELSE Dec(Counter);

  933.       END;

  934.       END;

  935.     $2E:

  936.       BEGIN

  937.       SCMD:= ORD(Source[Counter]);

  938.       Inc(Counter);

  939.       Case SCMD of

  940.         $01:

  941.         BEGIN

  942.           CMDIntR[1]:= ValueReader(Counter);

  943.           Inc(Counter,CMDIntR[1].Spacing-1);

  944.         END;

  945.         $02:

  946.         BEGIN

  947.           CMDIntR[1]:= ValueReader(Counter);

  948.           Inc(Counter,CMDIntR[1].Spacing);



  950.           CMDIntR[2]:= ValueReader(Counter);

  951.           Inc(Counter,CMDIntR[2].Spacing-1);

  952.         END;

  953.         ELSE Dec(Counter);

  954.       END;

  955.       END;

  956.     $2F:

  957.       BEGIN

  958.       SCMD:= ORD(Source[Counter]);

  959.       Inc(Counter);

  960.       Case SCMD of

  961.         $01:

  962.         BEGIN

  963.           CMDIntR[1]:= ValueReader(Counter);

  964.           Inc(Counter,CMDIntR[1].Spacing);



  966.           CMDIntR[2]:= ValueReader(Counter);

  967.           Inc(Counter,CMDIntR[2].Spacing);



  969.           CMDIntR[3]:= ValueReader(Counter);

  970.           Inc(Counter,CMDIntR[3].Spacing-1);

  971.         END;

  972.         ELSE Dec(Counter);

  973.       END;

  974.       END;

  975.     $37, $39, $3B..$43, $49..$51:

  976.       BEGIN

  977.       CMDIntR[1]:= ValueReader(Counter);

  978.       Inc(Counter,CMDIntR[1].Spacing);



  980.       CMDIntR[2]:= ValueReader(Counter);

  981.       Inc(Counter,CMDIntR[2].Spacing-1);

  982.       END;

  983.     $56:

  984.       BEGIN

  985.       CMDIntR[1]:= ValueReader(Counter);

  986.       Inc(Counter,CMDIntR[1].Spacing-1);

  987.       END;

  988.     $57:

  989.       BEGIN

  990.       CMDIntR[1]:= ValueReader(Counter);

  991.       Inc(Counter,CMDIntR[1].Spacing);



  993.       CMDIntR[2]:= ValueReader(Counter);

  994.       Inc(Counter,CMDIntR[2].Spacing);



  996.       CMDIntR[3]:= ValueReader(Counter);

  997.       Inc(Counter,CMDIntR[3].Spacing-1);

  998.       END;

  999.     $58:

  1000.       BEGIN

  1001.       SCMD:= ORD(Source[Counter]);

  1002.       Inc(Counter);

  1003.       Case SCMD of

  1004.         $01, $02:

  1005.         BEGIN

  1006.           CMDIntR[1]:= ValueReader(Counter);

  1007.           Inc(Counter,CMDIntR[1].Spacing);

  1008.          

  1009.           SSCMD:= ORD(Source[Counter]);

  1010.           Inc(Counter);

  1011.           Case SSCMD of

  1012.           $22:

  1013.             BEGIN

  1014.             L:= 0;

  1015.             IF Source[Counter] = #$00 then Inc(Counter);

  1016.             Repeat

  1017.               SetLength(CMDASelR,L+1);

  1018.               CMDASelR[L].Text:= '';



  1020.               M:= ReadFString(Counter, True);

  1021.               Inc(Counter,M);



  1023.               IF Length(CMDACond) = 1 then

  1024.               CMDASelR[L].Condition:= CMDACond[0].Condition;



  1026.               For J:= 0 to High(CMDAStrR) do

  1027.               CMDASelR[L].Text:= CMDASelR[L].Text + CMDAStrR[J].Text;



  1029.             IF Source[Counter] = #$00 then Inc(Counter);

  1030.             Until Source[Counter] = #$23;

  1031.             END;

  1032.           ELSE Fault(SeenCMDSelectListError,Counter);

  1033.           END;

  1034.         END;

  1035.         $04:

  1036.         BEGIN

  1037.           CMDIntR[1]:= ValueReader(Counter);

  1038.           Inc(Counter,CMDIntR[1].Spacing-1);

  1039.         END;

  1040.         ELSE Dec(Counter);

  1041.       END;

  1042.       END;

  1043.     $59:

  1044.       BEGIN

  1045.       SCMD:= ORD(Source[Counter]);

  1046.       Inc(Counter);



  1048.       CMDIntR[1]:= ValueReader(Counter);

  1049.       Inc(Counter,CMDIntR[1].Spacing);



  1051.       Case SCMD of

  1052.         $01:

  1053.         BEGIN

  1054.           CMDStrR[1]:= TextReader(Counter);

  1055.           Inc(Counter,CMDStrR[1].Spacing-1);

  1056.         END;

  1057.         $02, $04, $05, $08:

  1058.         BEGIN

  1059.           CMDIntR[2]:= ValueReader(Counter);

  1060.           Inc(Counter,CMDIntR[2].Spacing-1);

  1061.         END;

  1062.         $03, $06:

  1063.         BEGIN

  1064.           CMDIntR[2]:= ValueReader(Counter);

  1065.           Inc(Counter,CMDIntR[2].Spacing);



  1067.           CMDIntR[3]:= ValueReader(Counter);

  1068.           Inc(Counter,CMDIntR[3].Spacing-1);

  1069.         END;

  1070.         $07:

  1071.         BEGIN

  1072.           Dec(Counter);

  1073.         END;

  1074.         ELSE Dec(Counter);

  1075.       END;

  1076.       END;

  1077.     $5B:

  1078.       BEGIN

  1079.       SCMD:= ORD(Source[Counter]);

  1080.       Inc(Counter);



  1082.       CMDIntR[1]:= ValueReader(Counter);

  1083.       Inc(Counter,CMDIntR[1].Spacing);



  1085.       Case SCMD of

  1086.         $01, $02:

  1087.         BEGIN

  1088.           L:= 0;

  1089.           Repeat

  1090.           SetLength(CMDAIntR,L+1);

  1091.           CMDAIntR[L]:= ValueReader(Counter);

  1092.           Inc(Counter,CMDAIntR[L].Spacing);

  1093.           Until Source[Counter] = #$00;

  1094.         END;

  1095.         ELSE Dec(Counter);

  1096.       END;

  1097.       END;

  1098.     $5C, $5D:

  1099.       BEGIN

  1100.       SCMD:= ORD(Source[Counter]);

  1101.       Inc(Counter);



  1103.       CMDIntR[1]:= ValueReader(Counter);

  1104.       Inc(Counter,CMDIntR[1].Spacing);



  1106.       CMDIntR[2]:= ValueReader(Counter);

  1107.       Inc(Counter,CMDIntR[2].Spacing);



  1109.       CMDIntR[3]:= ValueReader(Counter);

  1110.       Inc(Counter,CMDIntR[3].Spacing-1);

  1111.       END;

  1112.     $5E:

  1113.       BEGIN

  1114.       SCMD:= ORD(Source[Counter]);

  1115.       Inc(Counter);



  1117.       CMDIntR[1]:= ValueReader(Counter);

  1118.       Inc(Counter,CMDIntR[1].Spacing-1);

  1119.       END;

  1120.     $5F:

  1121.       BEGIN

  1122.       SCMD:= ORD(Source[Counter]);

  1123.       Inc(Counter);

  1124.       Case SCMD of

  1125.         $01:

  1126.         BEGIN

  1127.           CMDIntR[1]:= ValueReader(Counter);

  1128.           Inc(Counter,CMDIntR[1].Spacing);



  1130.           L:= 0; M:= 0;

  1131.           SetLength(CMDAByte,L+1);

  1132.           CMDAByte[L]:= ORD(Source[Counter]);

  1133.           Inc(Counter); Inc(L);

  1134.           Repeat

  1135.           Case CMDAByte[L-1] of

  1136.             $01, $11:

  1137.             BEGIN

  1138.               SetLength(CMDAIntR,M+1);

  1139.               CMDAIntR[M]:= ValueReader(Counter);

  1140.               Inc(Counter,CMDAIntR[M].Spacing); Inc(M);

  1141.             END;

  1142.             $02, $12:

  1143.             BEGIN

  1144.               SetLength(CMDAIntR,M+2);

  1145.               CMDAIntR[M]:= ValueReader(Counter);

  1146.               Inc(Counter,CMDAIntR[M].Spacing); Inc(M);

  1147.               CMDAIntR[M]:= ValueReader(Counter);

  1148.               Inc(Counter,CMDAIntR[M].Spacing); Inc(M);

  1149.             END;

  1150.             ELSE Fault(SeenCMDSumError,Counter);

  1151.           END;



  1153.           SetLength(CMDAByte,L+1);

  1154.           CMDAByte[L]:= ORD(Source[Counter]);

  1155.           Inc(Counter); Inc(L);

  1156.           Until CMDAByte[L-1] = 0;

  1157.           Dec(Counter);

  1158.         END;

  1159.         $10:

  1160.         BEGIN

  1161.           CMDIntR[1]:= ValueReader(Counter);

  1162.           Inc(Counter,CMDIntR[1].Spacing);



  1164.           CMDIntR[2]:= ValueReader(Counter);

  1165.           Inc(Counter,CMDIntR[2].Spacing);



  1167.           CMDIntR[3]:= ValueReader(Counter);

  1168.           Inc(Counter,CMDIntR[3].Spacing-1);

  1169.         END;

  1170.         $20:

  1171.         BEGIN

  1172.           M:= ORD(Source[Counter]);

  1173.           CMDInt[1]:= M;

  1174.           Inc(Counter);



  1176.           CMDIntR[1]:= ValueReader(Counter);

  1177.           Inc(Counter,CMDIntR[1].Spacing);



  1179.           CMDIntR[2]:= ValueReader(Counter);

  1180.           Inc(Counter,CMDIntR[2].Spacing);



  1182.           SetLength(CMDAIntR,M);

  1183.           For L:= 0 to M-1 do

  1184.           BEGIN

  1185.             CMDAIntR[L]:= ValueReader(Counter);

  1186.             Inc(Counter,CMDAIntR[L].Spacing);

  1187.           END;

  1188.           Dec(Counter);

  1189.         END;

  1190.         ELSE Dec(Counter);

  1191.       END;

  1192.       END;

  1193.     $60:

  1194.       BEGIN

  1195.       SCMD:= ORD(Source[Counter]);

  1196.       Inc(Counter);

  1197.       Case SCMD of

  1198.         $02, $03:

  1199.         BEGIN

  1200.           CMDIntR[1]:= ValueReader(Counter);

  1201.           Inc(Counter,CMDIntR[1].Spacing-1);

  1202.         END;

  1203.         $04:

  1204.         BEGIN

  1205.           M:= ReadFString(Counter);

  1206.           Inc(Counter, M);

  1207.         END;

  1208.         $05, $20:

  1209.         BEGIN

  1210.           Dec(Counter)

  1211.         END;

  1212.         $30, $31, $35, $36, $37:

  1213.         BEGIN

  1214.           CMDIntR[1]:= ValueReader(Counter);

  1215.           Inc(Counter,CMDIntR[1].Spacing);



  1217.           CMDIntR[2]:= ValueReader(Counter);

  1218.           Inc(Counter,CMDIntR[2].Spacing-1);

  1219.         END;

  1220.         ELSE Dec(Counter);

  1221.       END;

  1222.       END;

  1223.     $61:

  1224.       BEGIN

  1225.       SCMD:= ORD(Source[Counter]);

  1226.       Inc(Counter);

  1227.       Case SCMD of

  1228.         $01:

  1229.         BEGIN

  1230.           For L:= 1 to 10 do

  1231.           BEGIN

  1232.             CMDIntR[L]:= ValueReader(Counter);

  1233.             Inc(Counter,CMDIntR[L].Spacing);

  1234.           END;

  1235.           Dec(Counter);

  1236.         END;

  1237.         $02, $03, $20:

  1238.         BEGIN

  1239.           CMDIntR[1]:= ValueReader(Counter);

  1240.           Inc(Counter,CMDIntR[1].Spacing-1);

  1241.         END;

  1242.         $04:

  1243.         BEGIN

  1244.           Dec(Counter);

  1245.         END;

  1246.         $10,$11,$12:

  1247.         BEGIN

  1248.           CMDIntR[1]:= ValueReader(Counter);

  1249.           Inc(Counter,CMDIntR[1].Spacing);



  1251.           CMDIntR[2]:= ValueReader(Counter);

  1252.           Inc(Counter,CMDIntR[2].Spacing-1);

  1253.         END;

  1254.         $21:

  1255.         BEGIN

  1256.           CMDIntR[1]:= ValueReader(Counter);

  1257.           Inc(Counter,CMDIntR[1].Spacing);



  1259.           CMDStrR[1]:= TextReader(Counter);

  1260.           Inc(Counter,CMDStrR[1].Spacing);



  1262.           For L:= 2 to 10 do

  1263.           BEGIN

  1264.             CMDIntR[L]:= ValueReader(Counter);

  1265.             Inc(Counter,CMDIntR[L].Spacing);

  1266.           END;

  1267.           Dec(Counter);

  1268.         END;

  1269.         $24:

  1270.         BEGIN

  1271.           M:= ORD(Source[Counter]);

  1272.           CMDInt[1]:= M;

  1273.           Inc(Counter);



  1275.           SetLength(CMDAIntR,M);

  1276.           SetLength(CMDAStr,M);

  1277.           For L:= 0 to M-1 do

  1278.           BEGIN

  1279.             CMDAIntR[L]:= ValueReader(Counter);

  1280.             Inc(Counter,CMDAIntR[L].Spacing);



  1282.             J:= ReadFString(Counter);

  1283.             Inc(Counter,J);

  1284.             CMDAStr[L]:= '';

  1285.             For K:= 0 to High(CMDAStrR) do

  1286.             CMDAStr[L]:= CMDAStr[L] + CMDAStrR[K].Text;

  1287.             IF Source[Counter] = #00 then Inc(Counter);

  1288.           END;

  1289.           Dec(Counter);

  1290.         END;

  1291.         ELSE Dec(Counter);

  1292.       END;

  1293.       END;

  1294.     $63:

  1295.       BEGIN

  1296.       SCMD:= ORD(Source[Counter]);

  1297.       Inc(Counter);

  1298.       Case SCMD of

  1299.         $01:

  1300.         BEGIN

  1301.           For L:= 1 to 5 do

  1302.           BEGIN

  1303.             CMDIntR[L]:= ValueReader(Counter);

  1304.             Inc(Counter,CMDIntR[L].Spacing);

  1305.           END;

  1306.           Dec(Counter);

  1307.         END;

  1308.         $02:

  1309.         BEGIN

  1310.           For L:= 1 to 3 do

  1311.           BEGIN

  1312.             CMDIntR[L]:= ValueReader(Counter);

  1313.             Inc(Counter,CMDIntR[L].Spacing);

  1314.           END;

  1315.           Dec(Counter);

  1316.         END;

  1317.         $20:

  1318.         BEGIN

  1319.           CMDInt[1]:= ORD(Source[Counter]);

  1320.           Inc(Counter);



  1322.           CMDIntR[1]:= ValueReader(Counter);

  1323.           Inc(Counter,CMDIntR[1].Spacing-1);

  1324.         END;

  1325.         ELSE Dec(Counter);

  1326.       END;

  1327.       END;

  1328.     $64:

  1329.       BEGIN

  1330.       SCMD:= ORD(Source[Counter]);

  1331.       Inc(Counter);

  1332.       Case SCMD of

  1333.         $02, $04, $10:

  1334.         BEGIN

  1335.           For L:= 1 to 8 do

  1336.           BEGIN

  1337.             CMDIntR[L]:= ValueReader(Counter);

  1338.             Inc(Counter,CMDIntR[L].Spacing);

  1339.           END;

  1340.           Dec(Counter);

  1341.         END;

  1342.         $07, $11, $12, $20:

  1343.         BEGIN

  1344.           For L:= 1 to 5 do

  1345.           BEGIN

  1346.             CMDIntR[L]:= ValueReader(Counter);

  1347.             Inc(Counter,CMDIntR[L].Spacing);

  1348.           END;

  1349.           Dec(Counter);

  1350.         END;

  1351.         $15:

  1352.         BEGIN

  1353.           For L:= 1 to 9 do

  1354.           BEGIN

  1355.             CMDIntR[L]:= ValueReader(Counter);

  1356.             Inc(Counter,CMDIntR[L].Spacing);

  1357.           END;

  1358.           Dec(Counter);

  1359.         END;

  1360.         $30:

  1361.         BEGIN

  1362.           For L:= 1 to 10 do

  1363.           BEGIN

  1364.             CMDIntR[L]:= ValueReader(Counter);

  1365.             Inc(Counter,CMDIntR[L].Spacing);

  1366.           END;

  1367.           Dec(Counter);

  1368.         END;

  1369.         $32:

  1370.         BEGIN

  1371.           For L:= 1 to 16 do

  1372.           BEGIN

  1373.             CMDIntR[L]:= ValueReader(Counter);

  1374.             Inc(Counter,CMDIntR[L].Spacing);

  1375.           END;

  1376.           Dec(Counter);

  1377.         END;

  1378.         ELSE Dec(Counter);

  1379.       END;

  1380.       END;

  1381.     $66:

  1382.       BEGIN

  1383.       SCMD:= ORD(Source[Counter]);

  1384.       Inc(Counter);



  1386.       For L:= 1 to 6 do

  1387.         BEGIN

  1388.         CMDIntR[L]:= ValueReader(Counter);

  1389.         Inc(Counter,CMDIntR[L].Spacing);

  1390.         END;



  1392.       J:= ReadFString(Counter);

  1393.       CMDStr[1]:= '';

  1394.       For L:= 1 to High(CMDAStrR) do

  1395.         BEGIN

  1396.         CMDStr[1]:= CMDStr[1] + CMDAStrR[L].Text;

  1397.         END;

  1398.       Inc(Counter,J-1);

  1399.       END;

  1400.     $67:

  1401.       BEGIN

  1402.       SCMD:= ORD(Source[Counter]);

  1403.       Inc(Counter);

  1404.       Case SCMD of

  1405.         $00:

  1406.         BEGIN

  1407.           For L:= 1 to 6 do

  1408.           BEGIN

  1409.             CMDIntR[L]:= ValueReader(Counter);

  1410.             Inc(Counter,CMDIntR[L].Spacing);

  1411.           END;

  1412.           Dec(Counter);

  1413.         END;

  1414.         $01:

  1415.         BEGIN

  1416.           For L:= 1 to 9 do  { 8 for earlier than 3217D }

  1417.           BEGIN

  1418.             CMDIntR[L]:= ValueReader(Counter);

  1419.             Inc(Counter,CMDIntR[L].Spacing);

  1420.           END;

  1421.           Dec(Counter);

  1422.         END;

  1423.         $02:

  1424.         BEGIN

  1425.           For L:= 1 to 9 do { 8 for earlier than 3216M }

  1426.           BEGIN

  1427.             CMDIntR[L]:= ValueReader(Counter);

  1428.             Inc(Counter,CMDIntR[L].Spacing);

  1429.           END;

  1430.           Dec(Counter);

  1431.         END;

  1432.         $03:

  1433.         BEGIN

  1434.           For L:= 1 to 11 do

  1435.           BEGIN

  1436.             CMDIntR[L]:= ValueReader(Counter);

  1437.             Inc(Counter,CMDIntR[L].Spacing);

  1438.           END;

  1439.           Dec(Counter);

  1440.         END;

  1441.         $05:

  1442.         BEGIN

  1443.           For L:= 1 to 8 do

  1444.           BEGIN

  1445.             CMDIntR[L]:= ValueReader(Counter);

  1446.             Inc(Counter,CMDIntR[L].Spacing);

  1447.           END;

  1448.           Dec(Counter);

  1449.         END;

  1450.         $08:

  1451.         BEGIN

  1452.           For L:= 1 to 9 do

  1453.           BEGIN

  1454.             CMDIntR[L]:= ValueReader(Counter);

  1455.             Inc(Counter,CMDIntR[L].Spacing);

  1456.           END;

  1457.           Dec(Counter);

  1458.         END;

  1459.         $11:

  1460.         BEGIN

  1461.           For L:= 1 to 3 do  { 2 for earlier than 3217D }

  1462.           BEGIN

  1463.             CMDIntR[L]:= ValueReader(Counter);

  1464.             Inc(Counter,CMDIntR[L].Spacing);

  1465.           END;

  1466.           Dec(Counter);

  1467.         END;

  1468.         $12:

  1469.         BEGIN

  1470.           For L:= 1 to 3 do  { 2 for earlier than 3216M }

  1471.           BEGIN

  1472.             CMDIntR[L]:= ValueReader(Counter);

  1473.             Inc(Counter,CMDIntR[L].Spacing);

  1474.           END;

  1475.           Dec(Counter);

  1476.         END;

  1477.         $20:

  1478.         BEGIN

  1479.           For L:= 1 to 15 do

  1480.           BEGIN

  1481.             CMDIntR[L]:= ValueReader(Counter);

  1482.             Inc(Counter,CMDIntR[L].Spacing);

  1483.           END;

  1484.           Dec(Counter);

  1485.         END;

  1486.         $21:

  1487.         BEGIN

  1488.           For L:= 1 to 16 do

  1489.           BEGIN

  1490.             CMDIntR[L]:= ValueReader(Counter);

  1491.             Inc(Counter,CMDIntR[L].Spacing);

  1492.           END;

  1493.           Dec(Counter);

  1494.         END;

  1495.         $22:

  1496.         BEGIN

  1497.           For L:= 1 to 18 do

  1498.           BEGIN

  1499.             CMDIntR[L]:= ValueReader(Counter);

  1500.             Inc(Counter,CMDIntR[L].Spacing);

  1501.           END;

  1502.           Dec(Counter);

  1503.         END;

  1504.         ELSE Dec(Counter);

  1505.       END;

  1506.       END;

  1507.     $68:

  1508.       BEGIN

  1509.       SCMD:= ORD(Source[Counter]);

  1510.       Inc(Counter);

  1511.       Case SCMD of

  1512.         $01:

  1513.         BEGIN

  1514.           For L:= 1 to 4 do

  1515.           BEGIN

  1516.             CMDIntR[L]:= ValueReader(Counter);

  1517.             Inc(Counter,CMDIntR[L].Spacing);

  1518.           END;

  1519.           Dec(Counter);

  1520.         END;

  1521.         $10:

  1522.         BEGIN

  1523.           For L:= 1 to 5 do

  1524.           BEGIN

  1525.             CMDIntR[L]:= ValueReader(Counter);

  1526.             Inc(Counter,CMDIntR[L].Spacing);

  1527.           END;

  1528.           Dec(Counter);

  1529.         END;

  1530.         ELSE Dec(Counter);

  1531.       END;

  1532.       END;

  1533.     $69:

  1534.       BEGIN

  1535.       CMDInt[1]:= ORD(Source[Counter]);

  1536.       Inc(Counter);



  1538.       CMDInt[2]:= ORD(Source[Counter]);

  1539.       Inc(Counter);



  1541.       For L:= 1 to 6 do

  1542.         BEGIN

  1543.         CMDIntR[L]:= ValueReader(Counter);

  1544.         Inc(Counter,CMDIntR[L].Spacing);

  1545.         END;

  1546.       Dec(Counter);

  1547.       END;

  1548.     $6A:

  1549.       BEGIN

  1550.       SCMD:= ORD(Source[Counter]);

  1551.       Inc(Counter);

  1552.       Case SCMD of

  1553.         $10, $20, $30:

  1554.         BEGIN

  1555.           CMDInt[1]:= ORD(Source[Counter]);

  1556.           Inc(Counter);



  1558.           M:= ORD(Source[Counter]);

  1559.           CMDInt[2]:= M;

  1560.           Inc(Counter);



  1562.           CMDIntR[1]:= ValueReader(Counter);

  1563.           Inc(Counter,CMDIntR[1].Spacing);



  1565.           CMDIntR[2]:= ValueReader(Counter);

  1566.           Inc(Counter,CMDIntR[2].Spacing);



  1568.           CMDIntR[3]:= ValueReader(Counter);

  1569.           Inc(Counter,CMDIntR[3].Spacing);



  1571.           IF SCMD = $30 then

  1572.           BEGIN

  1573.             CMDIntR[4]:= ValueReader(Counter);

  1574.             Inc(Counter,CMDIntR[4].Spacing);

  1575.           END;



  1577.           SetLength(CMDAIntR, M);

  1578.           SetLength(CMDAStrR, M);



  1580.           For L:= 0 to M-1 do

  1581.           BEGIN

  1582.             CMDAStrR[L]:= TextReader(Counter);

  1583.             Inc(Counter,CMDAStrR[L].Spacing);



  1585.             CMDAIntR[L]:= ValueReader(Counter);

  1586.             Inc(Counter,CMDAIntR[L].Spacing);

  1587.           END;

  1588.           { 1 Byte Extra Intended }

  1589.         END;

  1590.         $03, $04:

  1591.         BEGIN

  1592.           M:= ORD(Source[Counter]);

  1593.           CMDInt[1]:= M;

  1594.           Inc(Counter);



  1596.           CMDIntR[1]:= ValueReader(Counter);

  1597.           Inc(Counter,CMDIntR[1].Spacing);



  1599.           CMDIntR[2]:= ValueReader(Counter);

  1600.           Inc(Counter,CMDIntR[2].Spacing);



  1602.           SetLength(CMDAIntR, M);

  1603.           SetLength(CMDAStrR, M);



  1605.           For L:= 0 to M-1 do

  1606.           BEGIN

  1607.             CMDAStrR[L]:= TextReader(Counter);

  1608.             Inc(Counter,CMDAStrR[L].Spacing);



  1610.             CMDAIntR[L]:= ValueReader(Counter);

  1611.             Inc(Counter,CMDAIntR[L].Spacing);

  1612.           END;

  1613.           { 1 Byte Extra Intended }

  1614.         END;

  1615.         $05:

  1616.         BEGIN

  1617.           Dec(Counter);

  1618.         END;

  1619.         ELSE Dec(Counter);

  1620.       END;

  1621.       END;

  1622.     $6C:

  1623.       BEGIN

  1624.       SCMD:= ORD(Source[Counter]);

  1625.       Inc(Counter);

  1626.       Case SCMD of

  1627.         $02:

  1628.         BEGIN

  1629.           CMDStrR[1]:= TextReader(Counter);

  1630.           Inc(Counter,CMDStrR[1].Spacing);



  1632.           CMDStrR[2]:= TextReader(Counter);

  1633.           Inc(Counter,CMDStrR[2].Spacing-1);

  1634.         END;

  1635.         $03:

  1636.         BEGIN

  1637.           Dec(Counter);

  1638.         END;

  1639.         $04, $20:

  1640.         BEGIN

  1641.           CMDIntR[1]:= ValueReader(Counter);

  1642.           Inc(Counter,CMDIntR[1].Spacing);



  1644.           CMDIntR[2]:= ValueReader(Counter);

  1645.           Inc(Counter,CMDIntR[2].Spacing-1);

  1646.         END;

  1647.         $05:

  1648.         BEGIN

  1649.           CMDIntR[1]:= ValueReader(Counter);

  1650.           Inc(Counter,CMDIntR[1].Spacing);



  1652.           CMDIntR[2]:= ValueReader(Counter);

  1653.           Inc(Counter,CMDIntR[2].Spacing);



  1655.           CMDIntR[3]:= ValueReader(Counter);

  1656.           Inc(Counter,CMDIntR[3].Spacing);



  1658.           CMDIntR[4]:= ValueReader(Counter);

  1659.           Inc(Counter,CMDIntR[4].Spacing-1);

  1660.         END;

  1661.         $10, $11:

  1662.         BEGIN

  1663.           CMDIntR[1]:= ValueReader(Counter);

  1664.           Inc(Counter,CMDIntR[1].Spacing-1);

  1665.         END;

  1666.         $15:

  1667.         BEGIN

  1668.           CMDIntR[1]:= ValueReader(Counter);

  1669.           Inc(Counter,CMDIntR[1].Spacing);



  1671.           CMDIntR[2]:= ValueReader(Counter);

  1672.           Inc(Counter,CMDIntR[2].Spacing);



  1674.           CMDIntR[3]:= ValueReader(Counter);

  1675.           Inc(Counter,CMDIntR[3].Spacing-1);

  1676.         END;

  1677.         ELSE Dec(Counter);

  1678.       END;

  1679.       END;

  1680.     $6D:

  1681.       BEGIN

  1682.       SCMD:= ORD(Source[Counter]);

  1683.       Inc(Counter);

  1684.       Case SCMD of

  1685.         $01, $02:

  1686.         BEGIN

  1687.           CMDIntR[1]:= ValueReader(Counter);

  1688.           Inc(Counter,CMDIntR[1].Spacing);



  1690.           CMDIntR[2]:= ValueReader(Counter);

  1691.           Inc(Counter,CMDIntR[2].Spacing);



  1693.           CMDIntR[3]:= ValueReader(Counter);

  1694.           Inc(Counter,CMDIntR[3].Spacing-1);

  1695.         END;

  1696.         $03, $20, $21:

  1697.         BEGIN

  1698.           Dec(Counter);

  1699.         END;

  1700.         ELSE Dec(Counter);

  1701.       END;

  1702.       END;

  1703.     $6E:

  1704.       BEGIN

  1705.       SCMD:= ORD(Source[Counter]);

  1706.       Inc(Counter);

  1707.       Case SCMD of

  1708.         $01..$04:

  1709.         BEGIN

  1710.           CMDIntR[1]:= ValueReader(Counter);

  1711.           Inc(Counter,CMDIntR[1].Spacing-1);

  1712.         END;

  1713.         $05:

  1714.         BEGIN

  1715.           CMDIntR[1]:= ValueReader(Counter);

  1716.           Inc(Counter,CMDIntR[1].Spacing);



  1718.           CMDIntR[2]:= ValueReader(Counter);

  1719.           Inc(Counter,CMDIntR[2].Spacing);



  1721.           CMDIntR[3]:= ValueReader(Counter);

  1722.           Inc(Counter,CMDIntR[3].Spacing-1);

  1723.         END;

  1724.         ELSE Dec(Counter);

  1725.       END;

  1726.       END;

  1727.     $6F:

  1728.       BEGIN

  1729.       CMDIntR[1]:= ValueReader(Counter);

  1730.       Inc(Counter,CMDIntR[1].Spacing);



  1732.       CMDIntR[2]:= ValueReader(Counter);

  1733.       Inc(Counter,CMDIntR[2].Spacing);



  1735.       CMDIntR[3]:= ValueReader(Counter);

  1736.       Inc(Counter,CMDIntR[3].Spacing);



  1738.       CMDIntR[4]:= ValueReader(Counter);

  1739.       Inc(Counter,CMDIntR[4].Spacing-1);

  1740.       END;

  1741.     $70:

  1742.       BEGIN

  1743.       SCMD:= ORD(Source[Counter]);

  1744.       Inc(Counter);

  1745.       Case SCMD of

  1746.         $01, $02:

  1747.         BEGIN

  1748.           CMDIntR[1]:= ValueReader(Counter);

  1749.           Inc(Counter,CMDIntR[1].Spacing);



  1751.           CMDIntR[2]:= ValueReader(Counter);

  1752.           Inc(Counter,CMDIntR[2].Spacing);



  1754.           CMDIntR[3]:= ValueReader(Counter);

  1755.           Inc(Counter,CMDIntR[3].Spacing);



  1757.           CMDIntR[4]:= ValueReader(Counter);

  1758.           Inc(Counter,CMDIntR[4].Spacing-1);

  1759.         END;

  1760.         $03..$06, $10, $11:

  1761.         BEGIN

  1762.           CMDIntR[1]:= ValueReader(Counter);

  1763.           Inc(Counter,CMDIntR[1].Spacing-1);

  1764.         END;

  1765.         ELSE Dec(Counter);

  1766.       END;

  1767.       END;

  1768.     $72:

  1769.       BEGIN

  1770.       SCMD:= ORD(Source[Counter]);

  1771.       Inc(Counter);

  1772.       Case SCMD of

  1773.         $01..$05, $11..$15:

  1774.         BEGIN

  1775.           CMDIntR[1]:= ValueReader(Counter);

  1776.           Inc(Counter,CMDIntR[1].Spacing);



  1778.           CMDIntR[2]:= ValueReader(Counter);

  1779.           Inc(Counter,CMDIntR[2].Spacing-1);

  1780.         END;

  1781.         ELSE Dec(Counter);

  1782.       END;

  1783.       END;

  1784.     $73:

  1785.       BEGIN

  1786.       SCMD:= ORD(Source[Counter]);

  1787.       Inc(Counter);

  1788.       Case SCMD of

  1789.         $01, $02, $05, $06, $31:

  1790.         BEGIN

  1791.           CMDIntR[1]:= ValueReader(Counter);

  1792.           Inc(Counter,CMDIntR[1].Spacing);



  1794.           CMDIntR[2]:= ValueReader(Counter);

  1795.           Inc(Counter,CMDIntR[2].Spacing-1);

  1796.         END;

  1797.         $10..$13, $16..$30, $32..$34:

  1798.         BEGIN

  1799.           CMDIntR[1]:= ValueReader(Counter);

  1800.           Inc(Counter,CMDIntR[1].Spacing-1);

  1801.         END;

  1802.         ELSE Dec(Counter);

  1803.       END;

  1804.       END;

  1805.     $74:

  1806.       BEGIN

  1807.       SCMD:= ORD(Source[Counter]);

  1808.       Inc(Counter);

  1809.       Case SCMD of

  1810.         $01, $02:

  1811.         BEGIN

  1812.           CMDIntR[1]:= ValueReader(Counter);

  1813.           Inc(Counter,CMDIntR[1].Spacing-1);

  1814.         END;

  1815.         $03, $04:

  1816.         BEGIN

  1817.           CMDIntR[1]:= ValueReader(Counter);

  1818.           Inc(Counter,CMDIntR[1].Spacing);



  1820.           CMDIntR[2]:= ValueReader(Counter);

  1821.           Inc(Counter,CMDIntR[2].Spacing-1);

  1822.         END;

  1823.         ELSE Dec(Counter);

  1824.       END;

  1825.       END;

  1826.     $75:

  1827.       BEGIN

  1828.       SCMD:= ORD(Source[Counter]);

  1829.       Inc(Counter);



  1831.       CMDIntR[1]:= ValueReader(Counter);

  1832.       Inc(Counter,CMDIntR[1].Spacing-1);

  1833.       END;

  1834.     $76:

  1835.       BEGIN

  1836.       SCMD:= ORD(Source[Counter]);

  1837.       Inc(Counter);

  1838.       Case SCMD of

  1839.         $01, $02:

  1840.         BEGIN

  1841.           CMDIntR[1]:= ValueReader(Counter);

  1842.           Inc(Counter,CMDIntR[1].Spacing-1);

  1843.         END;

  1844.         $04, $05:

  1845.         BEGIN

  1846.           Dec(Counter);

  1847.         END;

  1848.         ELSE Dec(Counter);

  1849.       END;

  1850.       END;

  1851.     $FE, $FF:

  1852.       BEGIN

  1853.       CMDInt[1]:= IntReader(Counter);

  1854.       IF (CMDInt[1] >= 0) AND (CMDInt[1] < LineMax) then

  1855.         BEGIN

  1856.         Inc(Counter,4);

  1857.         CMDStrR[1]:= TextReader(Counter);

  1858.         Inc(Counter,CMDStrR[1].Spacing-1);



  1860.         IF Assigned(PutLine) then

  1861.           IF CMD = $FE then PutLine(CMDInt[1],Han2Zen(CMDStrR[1].Text))

  1862.                       else PutLine(CMDInt[1],CMDStrR[1].Text);

  1863.         END

  1864.       else

  1865.         BEGIN

  1866.         CMDStrR[1]:= TextReader(Counter);

  1867.         Inc(Counter,CMDStrR[1].Spacing-1);

  1868.         END;

  1869.       END;

  1870.     ELSE

  1871.       BEGIN

  1872.       Dec(Counter);

  1873.       END;

  1874.     END;

  1875.   Finally

  1876.     Source:= Copy(Source,1,Counter);

  1877.     Delete(CMDString,1,Counter);

  1878.   END;

  1879.   END;



  1881. Destructor RScenCMD.Destroy;

  1882.   Var

  1883.   Count: Integer;

  1884.   BEGIN

  1885.   SetLength(CMDAInt,0);

  1886.   SetLength(CMDAByte,0);



  1888.   SetLength(CMDAIntR,0);

  1889.   SetLength(CMDAIntDR,0,0);

  1890.   SetLength(CMDAStrR,0);



  1892.   For Count:= High(CMDACond) downto 0 do

  1893.     SetLength(CMDACond[Count].Condition,0);

  1894.   SetLength(CMDACond,0);



  1896.   For Count:= High(CMDASelR) downto 0 do

  1897.     SetLength(CMDASelR[Count].Condition,0);

  1898.   SetLength(CMDASelR,0);



  1900.   Inherited;

  1901.   END;



  1903. Function RScenCMD.IntReader(Pos: Integer): Integer;

  1904.   Var

  1905.   Cache: RMixInt;

  1906.   BEGIN

  1907.   Cache.Bytes[0]:= Source[Pos];

  1908.   Cache.Bytes[1]:= Source[Pos+1];

  1909.   Cache.Bytes[2]:= Source[Pos+2];

  1910.   Cache.Bytes[3]:= Source[Pos+3];

  1911.   Result:= Cache.AInt;

  1912.   END;



  1914. Function RScenCMD.ValueReader(Pos: Integer): RValue;

  1915.   Var

  1916.   VHeader: Byte;

  1917.   Count: Byte;

  1918.   BEGIN

  1919.   With Result do

  1920.     BEGIN

  1921.     VHeader:= ORD(Source[Pos]);

  1922.     Spacing:= ((VHeader SHR 4) AND $7);

  1923.     IF (Spacing = 0) OR (Spacing > 5) then Fault(SeenCMDValueHeaderError,Pos);



  1925.     IsRegister:= (VHeader AND $80) <> 0;

  1926.     Value:= 0;

  1927.     For Count:= 1 to Spacing - 1 do

  1928.       Value:= (Value SHL 8) + ORD(Source[Pos+Count]);

  1929.     Value:= (Value SHL 4) OR (VHeader AND $F);

  1930.     END;

  1931.   END;



  1933. Function RScenCMD.TextReader(Pos: Integer): RText;

  1934.   Var

  1935.   ValueCache: RValue;

  1936.   BEGIN

  1937.   With Result do

  1938.     BEGIN

  1939.     Spacing:= 1;

  1940.     IF Source[Pos] = '@' then

  1941.       BEGIN

  1942.       IsRegister:= True;

  1943.       ValueCache:= ValueReader(Pos+Spacing);

  1944.       Inc(Spacing,ValueCache.Spacing);

  1945.       IsIndirect:= ValueCache.IsRegister;

  1946.       Value:= ValueCache.Value;

  1947.       END

  1948.     else

  1949.       BEGIN

  1950.       IsRegister:= False;

  1951.       Text:= PChar(Copy(Source,Pos,Length(Source)));

  1952.       Inc(Spacing,Length(Text));

  1953.       END;

  1954.     END;

  1955.   END;



  1957. Function RScenCMD.Conditioner(Pos: Integer; ExpectAttr: Boolean): RCond;

  1958.   Const

  1959.   MAXLevels = 256;

  1960.   Var

  1961.   LevelCnt, OutCnt: Integer;

  1962.   AppendCond: Array[1..MAXLevels] of Byte;

  1963.   PastChar: Char;

  1964.   AttrVal: RValue;

  1965.   CMPVal1, CMPVal2: RValue;



  1967.   BEGIN

  1968.   With Result do

  1969.     BEGIN

  1970.     Spacing:= 0;

  1971.     LevelCnt:= 0;

  1972.     OutCnt:= 0;

  1973.     PastChar:= #$00;

  1974.     Repeat

  1975.       Case Source[Pos+Spacing] of

  1976.       #$28:

  1977.         BEGIN

  1978.         Inc(LevelCnt);

  1979.         IF LevelCnt > 256 then Fault(SeenCMDConditionLevelOverflow,Pos+Spacing);

  1980.         AppendCond[LevelCnt]:= 0;

  1981.         END;

  1982.       #$29:

  1983.         BEGIN

  1984.         IF LevelCnt >= 1 then

  1985.           IF AppendCond[LevelCnt] <> 0 then

  1986.           BEGIN

  1987.             SetLength(Condition,OutCnt+1);

  1988.             Condition[OutCnt].CType:= CPLOp;

  1989.             Condition[OutCnt].CValue:= AppendCond[LevelCnt];

  1990.             Inc(OutCnt);

  1991.           END;

  1992.         Dec(LevelCnt);

  1993.         END;

  1994.       #$26, #$27:

  1995.         BEGIN

  1996.         IF LevelCnt < 0 then Fault(SeenCMDConditionLOperPosError,Pos+Spacing);

  1997.         IF AppendCond[LevelCnt] <> 0 then                // Slack Logic!! >_<

  1998.           BEGIN

  1999.           SetLength(Condition,OutCnt+1);

  2000.           Condition[OutCnt].CType:= CPLOp;

  2001.           Condition[OutCnt].CValue:= AppendCond[LevelCnt];

  2002.           Inc(OutCnt);

  2003.           END;

  2004.         AppendCond[LevelCnt]:= ORD(Source[Pos+Spacing]);

  2005.         END;

  2006.       #$58:

  2007.         BEGIN

  2008.         IF NOT ExpectAttr then Fault(SeenCMDConditionPropertyUnExp,Pos+Spacing);

  2009.         IF PastChar <> #$29 then Fault(SeenCMDConditionPropertyPosError,Pos+Spacing);



  2011.         SetLength(Condition,OutCnt+2);

  2012.         Condition[OutCnt+1].CType:= CPAttr;

  2013.         Condition[OutCnt+1].CValue:= ORD(Source[Pos+Spacing+1]);



  2015.         Case Source[Pos+Spacing+1] of

  2016.           #$20, #$22:

  2017.           BEGIN

  2018.             AttrVal:= ValueReader(Pos+Spacing+2);

  2019.             Condition[OutCnt].CType:= CPImm;

  2020.             Condition[OutCnt].CValue:= AttrVal.Value;

  2021.           END;

  2022.           #$21:

  2023.           BEGIN

  2024.             AttrVal.Spacing:= 0;

  2025.             Condition[OutCnt].CType:= CPImm;

  2026.             Condition[OutCnt].CValue:= 0;

  2027.           END;

  2028.           ELSE Fault(SeenCMDConditionPropertyError,Pos+Spacing);

  2029.         END;



  2031.         Inc(Spacing,AttrVal.Spacing+1);

  2032.         Inc(OutCnt,2);

  2033.         END;

  2034.         #$36..#$3B, #$41..#$49, #$4F..#$55:

  2035.         BEGIN

  2036.           CMPVal1:= ValueReader(Pos+Spacing+1);

  2037.           CMPVal2:= ValueReader(Pos+Spacing+CMPVal1.Spacing+1);



  2039.           SetLength(Condition,OutCnt+3);

  2040.           Condition[OutCnt].CValue:= CMPVal1.Value;

  2041.           Condition[OutCnt+1].CValue:= CMPVal2.Value;

  2042.           Condition[OutCnt+2].CValue:= ORD(Source[Pos+Spacing]);

  2043.           Condition[OutCnt+2].CType:= CPLOp;

  2044.           Case Source[Pos+Spacing] of

  2045.           #$36, #$37:

  2046.             BEGIN

  2047.             Condition[OutCnt].CType:= CPRBit;

  2048.             Condition[OutCnt+1].CType:= CPImm;

  2049.             END;

  2050.           #$38, #$39:

  2051.             BEGIN

  2052.             Condition[OutCnt].CType:= CPRBit;

  2053.             Condition[OutCnt+1].CType:= CPRBit

  2054.             END;

  2055.           #$3A, #$3B, #$41..#$47:

  2056.             BEGIN

  2057.             Condition[OutCnt].CType:= CPRInt;

  2058.             Condition[OutCnt+1].CType:= CPImm;

  2059.             END;

  2060.           #$48, #$49, #$4F..#$55:

  2061.             BEGIN

  2062.             Condition[OutCnt].CType:= CPRInt;

  2063.             Condition[OutCnt+1].CType:= CPRInt;

  2064.             END;

  2065.           END;

  2066.           Inc(Spacing,CMPVal1.Spacing+CMPVal2.Spacing);

  2067.           Inc(OutCnt,3);

  2068.         END;

  2069.       ELSE Fault(SeenCMDConditionError,Pos+Spacing);

  2070.       END;

  2071.       PastChar:= Source[Pos+Spacing];

  2072.       Inc(Spacing);

  2073.     Until (LevelCnt <= 0);

  2074.     END;

  2075.   END;



  2077. Function RScenCMD.ReadFString(Pos: Integer; ExpectAttr: Boolean = False): Integer;

  2078.   Var

  2079.   CondCounter: Integer;

  2080.   TextCounter: Integer;

  2081.   ValueCache: RValue;

  2082.   BEGIN

  2083.   SetLength(CMDAStrR,0);

  2084.   For CondCounter:= High(CMDACond) downto 0 do

  2085.     SetLength(CMDACond[CondCounter].Condition,0);

  2086.   SetLength(CMDACond,0);



  2088.   CondCounter:= 0;

  2089.   TextCounter:= 0;

  2090.   Result:= 0;



  2092.   Repeat

  2093.     Case Source[Pos+Result] of

  2094.     #$FF, #$FE:

  2095.       BEGIN

  2096.       SetLength(CMDAStrR,TextCounter+1);

  2097.       CMDAStrR[TextCounter].IsRegister:= False;

  2098.       CMDAStrR[TextCounter].Text:= PChar(Copy(Source,Pos+Result+1,Length(Source)));

  2099.       CMDAStrR[TextCounter].Spacing:= Length(CMDAStrR[TextCounter].Text);

  2100.       IF Source[Pos+Result] = #$FE then

  2101.         CMDAStrR[TextCounter].Text:= Han2Zen(CMDAStrR[TextCounter].Text);

  2102.       Inc(Result,CMDAStrR[TextCounter].Spacing+1);

  2103.       Inc(TextCounter);

  2104.       END;

  2105.     #$FD:

  2106.       BEGIN

  2107.       SetLength(CMDAStrR,TextCounter+1);

  2108.       CMDAStrR[TextCounter].IsRegister:= True;

  2109.       ValueCache:= ValueReader(Pos+Result+1);

  2110.       CMDAStrR[TextCounter].Spacing:= ValueCache.Spacing;

  2111.       CMDAStrR[TextCounter].IsIndirect:= ValueCache.IsRegister;

  2112.       CMDAStrR[TextCounter].Value:= ValueCache.Value;

  2113.       Inc(Result,CMDAStrR[TextCounter].Spacing+1);

  2114.       Inc(TextCounter);

  2115.       END;

  2116.     #$28:

  2117.       BEGIN

  2118.       IF CondCounter <> 0 then Fault(SeenCMDFStringConditionError,Pos+Result);

  2119.       SetLength(CMDACond,CondCounter+1);

  2120.       CMDACond[CondCounter]:= Conditioner(Pos+Result,ExpectAttr);

  2121.       Inc(Result,CMDACond[CondCounter].Spacing);

  2122.       Inc(CondCounter);

  2123.       END;

  2124.     #$10:

  2125.       BEGIN

  2126.       Inc(Result);

  2127.       Case Source[Result] of

  2128.         #$03:

  2129.         BEGIN

  2130.           SetLength(CMDAStrR,TextCounter+1);

  2131.           CMDAStrR[TextCounter].IsRegister:= True;

  2132.           ValueCache:= ValueReader(Pos+Result+1);

  2133.           CMDAStrR[TextCounter].Spacing:= ValueCache.Spacing;

  2134.           CMDAStrR[TextCounter].IsIndirect:= ValueCache.IsRegister;

  2135.           CMDAStrR[TextCounter].Value:= ValueCache.Value;

  2136.           Inc(Result,CMDAStrR[TextCounter].Spacing+1);

  2137.           Inc(TextCounter);

  2138.         END;

  2139.         ELSE Fault(SeenCMDFString10hSubCMDError,Pos+Result);

  2140.       END;

  2141.       END;

  2142.     ELSE Break; // Fault(SeenCMDFStringError,Pos+Result); { Allow for NO String }

  2143.     END;

  2144.     Inc(Result);

  2145.   Until Source[Pos+Result] = #0;

  2146.   END;



  2148. Function RScenCMD.Han2Zen(StrIn: ANSIString): ANSIString;

  2149.   Const

  2150.   H2ZTable: Array[#$20..#$7F] of Char = (

  2151.     #$40, #$49, #$68, #$94, #$90, #$93, #$95, #$66, #$69, #$6A, #$96, #$7B, #$43, #$7C, #$44, #$5E,

  2152.     #$4F, #$50, #$51, #$52, #$53, #$54, #$55, #$56, #$57, #$58, #$46, #$47, #$83, #$81, #$84, #$48,

  2153.     #$97, #$60, #$61, #$62, #$63, #$64, #$65, #$66, #$67, #$68, #$69, #$6A, #$6B, #$6C, #$6D, #$6E,

  2154.     #$6F, #$70, #$71, #$72, #$73, #$74, #$75, #$76, #$77, #$78, #$79, #$6D, #$8F, #$6E, #$4F, #$51,

  2155.     #$65, #$81, #$82, #$83, #$84, #$85, #$86, #$87, #$88, #$89, #$8A, #$8B, #$8C, #$8D, #$8E, #$8F,

  2156.     #$90, #$91, #$92, #$93, #$94, #$95, #$96, #$97, #$98, #$99, #$9A, #$6F, #$62, #$70, #$60, #$45

  2157.     );

  2158.   Var

  2159.   Count, Len: Integer;

  2160.   Ch: Char;

  2161.   BEGIN

  2162.   Len:= Length(StrIn);

  2163.   Result:= '';

  2164.   For Count:= 1 to Len do

  2165.     BEGIN

  2166.     Ch:= StrIn[Count];

  2167.     IF Ch in [#$20..#$80] then

  2168.       IF (Ch in ['0'..'9']) OR (Ch in ['0'..'9']) OR (Ch in ['0'..'9']) then

  2169.       Result:= Result + #$82 + H2ZTable[Ch]

  2170.       else Result:= Result + #$81 + H2ZTable[Ch]

  2171.     else Result:= Result + Ch;

  2172.     END;

  2173.   END;



  2175. Function RScenCMD.Explain(Detail: Boolean): String;

  2176.   BEGIN

  2177.   IF Source = '' then Result:= SeenCMDExpEmpty;



  2179.   Detail:= False;

  2180.   IF NOT Detail then

  2181.     Case CMD of

  2182.     $00: Result:= SeenCMDExpCat01;

  2183.     $01: Result:= SeenCMDExpCat02;

  2184.     $02: Result:= SeenCMDExpCat03;

  2185.     $03: Result:= SeenCMDExpCat04;

  2186.     $04: Result:= SeenCMDExpCat05;

  2187.     $05: Result:= SeenCMDExpCat06;

  2188.     $0B: Result:= SeenCMDExpCat07;

  2189.     $0C: Result:= SeenCMDExpCat08;

  2190.     $0E: Result:= SeenCMDExpCat09;

  2191.     $10: Result:= SeenCMDExpCat10;

  2192.     $13: Result:= SeenCMDExpCat11;

  2193.     $15: Result:= SeenCMDExpCat12;

  2194.     $16: Result:= SeenCMDExpCat13;

  2195.     $17: Result:= SeenCMDExpCat14;

  2196.     $18: Result:= SeenCMDExpCat15;

  2197.     $19: Result:= SeenCMDExpCat16;

  2198.     $1B: Result:= SeenCMDExpCat17;

  2199.     $1C: Result:= SeenCMDExpCat18;

  2200.     $1D: Result:= SeenCMDExpCat19;

  2201.     $1E: Result:= SeenCMDExpCat20;

  2202.     $20: Result:= SeenCMDExpCat21;

  2203.     $37: Result:= SeenCMDExpCat22;

  2204.     $39: Result:= SeenCMDExpCat23;

  2205.     $3B: Result:= SeenCMDExpCat24;

  2206.     $3C: Result:= SeenCMDExpCat25;

  2207.     $3D: Result:= SeenCMDExpCat26;

  2208.     $3E: Result:= SeenCMDExpCat27;

  2209.     $3F: Result:= SeenCMDExpCat28;

  2210.     $40: Result:= SeenCMDExpCat29;

  2211.     $41: Result:= SeenCMDExpCat30;

  2212.     $42: Result:= SeenCMDExpCat31;

  2213.     $43: Result:= SeenCMDExpCat32;

  2214.     $49: Result:= SeenCMDExpCat33;

  2215.     $4A: Result:= SeenCMDExpCat34;

  2216.     $4B: Result:= SeenCMDExpCat35;

  2217.     $4C: Result:= SeenCMDExpCat36;

  2218.     $4D: Result:= SeenCMDExpCat37;

  2219.     $4E: Result:= SeenCMDExpCat38;

  2220.     $4F: Result:= SeenCMDExpCat39;

  2221.     $50: Result:= SeenCMDExpCat40;

  2222.     $51: Result:= SeenCMDExpCat41;

  2223.     $56: Result:= SeenCMDExpCat42;

  2224.     $57: Result:= SeenCMDExpCat43;

  2225.     $58: Result:= SeenCMDExpCat44;

  2226.     $59: Result:= SeenCMDExpCat45;

  2227.     $5B: Result:= SeenCMDExpCat46;

  2228.     $5C: Result:= SeenCMDExpCat47;

  2229.     $5D: Result:= SeenCMDExpCat48;

  2230.     $5E: Result:= SeenCMDExpCat49;

  2231.     $5F: Result:= SeenCMDExpCat50;

  2232.     $60: Result:= SeenCMDExpCat51;

  2233.     $61: Result:= SeenCMDExpCat52;

  2234.     $63: Result:= SeenCMDExpCat53;

  2235.     $64: Result:= SeenCMDExpCat54;

  2236.     $66: Result:= SeenCMDExpCat55;

  2237.     $67: Result:= SeenCMDExpCat56;

  2238.     $68: Result:= SeenCMDExpCat57;

  2239.     $69: Result:= SeenCMDExpCat58;

  2240.     $6A: Result:= SeenCMDExpCat59;

  2241.     $6C: Result:= SeenCMDExpCat60;

  2242.     $6D: Result:= SeenCMDExpCat61;

  2243.     $6E: Result:= SeenCMDExpCat62;

  2244.     $70: Result:= SeenCMDExpCat63;

  2245.     $72: Result:= SeenCMDExpCat64;

  2246.     $73: Result:= SeenCMDExpCat65;

  2247.     $74: Result:= SeenCMDExpCat66;

  2248.     $75: Result:= SeenCMDExpCat67;

  2249.     $76: Result:= SeenCMDExpCat68;

  2250.     $FE: Result:= SeenCMDExpCat69;

  2251.     $FF: Result:= SeenCMDExpCat70;

  2252.     ELSE Result:= Format(SeenCMDExpCatXX, [ CMD, SCMD ]);

  2253.     END

  2254.   ELSE

  2255.     Result:= Format(SeenCMDExplainDetailUnImp, [ CMD, SCMD ]);



  2257.   Result:= '[' + IntToStr(Offset) + ':' + IntToStr(Length(Source))+ '] ' + Result;

  2258.   END;



  2260. Procedure RScenCMD.Fault(Error: String; Pos: Integer);

  2261.   Var

  2262.   RAWDump: String;

  2263.   Count, Len: Integer;

  2264.   BEGIN

  2265.   RAWDump:= '';

  2266.   IF Source <> '' then

  2267.     BEGIN

  2268.     RAWDump:= SeenCMDFaultHeader;

  2269.     Len:= Length(Source);

  2270.     For Count:= 1 to Pos do

  2271.       IF Count <= Len then

  2272.       RAWDump:= RAWDump + ' ' + IntToHex(ORD(Source[Count]),2);

  2273.     END;



  2275.   Raise Exception.Create('[' + IntToStr(Offset) + '] $' + IntToHex(CMD,2) + ':$' + IntToHex(SCMD,2) + ' ' + Error + ' | ' + RAWDump);

  2276.   END;



  2278. Procedure RScenCMD.ExpressTree(Tree: TTreeView; Root: TTreeNode);

  2279.   Var

  2280.   TempRoot: TTreeNode;

  2281.   TempChild: TTreeNode;

  2282.   BEGIN

  2283.   IF Source = '' then

  2284.     BEGIN

  2285.     TempRoot:= Tree.Items.AddChild(Root,SeenCMDExpEmpty);

  2286.     TempRoot.ImageIndex:= 3;

  2287.     TempRoot.SelectedIndex:= 3;

  2288.     Exit;

  2289.     END;



  2291.   TempRoot:= Tree.Items.AddChild(Root,Explain(True));

  2292.   Case CMD of

  2293.     $00:

  2294.     BEGIN

  2295.       TempRoot.ImageIndex:= 20;

  2296.       TempRoot.SelectedIndex:= 20;

  2297.     END;

  2298.     $01:

  2299.     BEGIN

  2300.       TempRoot.ImageIndex:= 6;

  2301.       TempRoot.SelectedIndex:= 6;

  2302.     END;

  2303.     $02:

  2304.     BEGIN

  2305.       TempRoot.ImageIndex:= 8;

  2306.       TempRoot.SelectedIndex:= 8;

  2307.     END;

  2308.     $03:

  2309.     BEGIN

  2310.       TempRoot.ImageIndex:= 6;

  2311.       TempRoot.SelectedIndex:= 6;

  2312.     END;

  2313.     $04:

  2314.     BEGIN

  2315.       TempRoot.ImageIndex:= 8;

  2316.       TempRoot.SelectedIndex:= 8;

  2317.     END;

  2318.     $05:

  2319.     BEGIN

  2320.       TempRoot.ImageIndex:= 8;

  2321.       TempRoot.SelectedIndex:= 8;

  2322.     END;

  2323.     $0B:

  2324.     BEGIN

  2325.       TempRoot.ImageIndex:= 2;

  2326.       TempRoot.SelectedIndex:= 10;

  2327.     END;

  2328.     $0C:

  2329.     BEGIN

  2330.       TempRoot.ImageIndex:= 9;

  2331.       TempRoot.SelectedIndex:= 10;

  2332.     END;

  2333.     $0E:

  2334.     BEGIN

  2335.       TempRoot.ImageIndex:= 0;

  2336.       TempRoot.SelectedIndex:= 10;

  2337.     END;

  2338.     $10:

  2339.     BEGIN

  2340.       TempRoot.ImageIndex:= 8;

  2341.       TempRoot.SelectedIndex:= 8;

  2342.     END;

  2343.     $13:

  2344.     BEGIN

  2345.       TempRoot.ImageIndex:= 2;

  2346.       TempRoot.SelectedIndex:= 10;

  2347.     END;

  2348.     $15:

  2349.     BEGIN

  2350.       TempRoot.ImageIndex:= 14;

  2351.       TempRoot.SelectedIndex:= 14;

  2352.     END;

  2353.     $16:

  2354.     BEGIN

  2355.       TempRoot.ImageIndex:= 14;

  2356.       TempRoot.SelectedIndex:= 14;

  2357.     END;

  2358.     $17:

  2359.     BEGIN

  2360.       TempRoot.ImageIndex:= 2;

  2361.       TempRoot.SelectedIndex:= 2;

  2362.     END;

  2363.     $18:

  2364.     BEGIN

  2365.       TempRoot.ImageIndex:= 8;

  2366.       TempRoot.SelectedIndex:= 8;

  2367.     END;

  2368.     $19:

  2369.     BEGIN

  2370.       TempRoot.ImageIndex:= 18;

  2371.       TempRoot.SelectedIndex:= 18;

  2372.     END;

  2373.     $1B:

  2374.     BEGIN

  2375.       TempRoot.ImageIndex:= 14;

  2376.       TempRoot.SelectedIndex:= 14;

  2377.     END;

  2378.     $1C:

  2379.     BEGIN

  2380.       TempRoot.ImageIndex:= 14;

  2381.       TempRoot.SelectedIndex:= 14;

  2382.     END;

  2383.     $1D:

  2384.     BEGIN

  2385.       TempRoot.ImageIndex:= 14;

  2386.       TempRoot.SelectedIndex:= 14;

  2387.     END;

  2388.     $1E:

  2389.     BEGIN

  2390.       TempRoot.ImageIndex:= 14;

  2391.       TempRoot.SelectedIndex:= 14;

  2392.     END;

  2393.     $20:

  2394.     BEGIN

  2395.       TempRoot.ImageIndex:= 14;

  2396.       TempRoot.SelectedIndex:= 14;

  2397.     END;

  2398.     $37:

  2399.     BEGIN

  2400.       TempRoot.ImageIndex:= 4;

  2401.       TempRoot.SelectedIndex:= 4;

  2402.     END;

  2403.     $39:

  2404.     BEGIN

  2405.       TempRoot.ImageIndex:= 4;

  2406.       TempRoot.SelectedIndex:= 4;

  2407.     END;

  2408.     $3B:

  2409.     BEGIN

  2410.       TempRoot.ImageIndex:= 4;

  2411.       TempRoot.SelectedIndex:= 4;

  2412.     END;

  2413.     $3C:

  2414.     BEGIN

  2415.       TempRoot.ImageIndex:= 4;

  2416.       TempRoot.SelectedIndex:= 4;

  2417.     END;

  2418.     $3D:

  2419.     BEGIN

  2420.       TempRoot.ImageIndex:= 4;

  2421.       TempRoot.SelectedIndex:= 4;

  2422.     END;

  2423.     $3E:

  2424.     BEGIN

  2425.       TempRoot.ImageIndex:= 4;

  2426.       TempRoot.SelectedIndex:= 4;

  2427.     END;

  2428.     $3F:

  2429.     BEGIN

  2430.       TempRoot.ImageIndex:= 4;

  2431.       TempRoot.SelectedIndex:= 4;

  2432.     END;

  2433.     $40:

  2434.     BEGIN

  2435.       TempRoot.ImageIndex:= 4;

  2436.       TempRoot.SelectedIndex:= 4;

  2437.     END;

  2438.     $41:

  2439.     BEGIN

  2440.       TempRoot.ImageIndex:= 4;

  2441.       TempRoot.SelectedIndex:= 4;

  2442.     END;

  2443.     $42:

  2444.     BEGIN

  2445.       TempRoot.ImageIndex:= 4;

  2446.       TempRoot.SelectedIndex:= 4;

  2447.     END;

  2448.     $43:

  2449.     BEGIN

  2450.       TempRoot.ImageIndex:= 4;

  2451.       TempRoot.SelectedIndex:= 4;

  2452.     END;

  2453.     $49:

  2454.     BEGIN

  2455.       TempRoot.ImageIndex:= 4;

  2456.       TempRoot.SelectedIndex:= 4;

  2457.     END;

  2458.     $4A:

  2459.     BEGIN

  2460.       TempRoot.ImageIndex:= 4;

  2461.       TempRoot.SelectedIndex:= 4;

  2462.     END;

  2463.     $4B:

  2464.     BEGIN

  2465.       TempRoot.ImageIndex:= 4;

  2466.       TempRoot.SelectedIndex:= 4;

  2467.     END;

  2468.     $4C:

  2469.     BEGIN

  2470.       TempRoot.ImageIndex:= 4;

  2471.       TempRoot.SelectedIndex:= 4;

  2472.     END;

  2473.     $4D:

  2474.     BEGIN

  2475.       TempRoot.ImageIndex:= 4;

  2476.       TempRoot.SelectedIndex:= 4;

  2477.     END;

  2478.     $4E:

  2479.     BEGIN

  2480.       TempRoot.ImageIndex:= 4;

  2481.       TempRoot.SelectedIndex:= 4;

  2482.     END;

  2483.     $4F:

  2484.     BEGIN

  2485.       TempRoot.ImageIndex:= 4;

  2486.       TempRoot.SelectedIndex:= 4;

  2487.     END;

  2488.     $50:

  2489.     BEGIN

  2490.       TempRoot.ImageIndex:= 4;

  2491.       TempRoot.SelectedIndex:= 4;

  2492.     END;

  2493.     $51:

  2494.     BEGIN

  2495.       TempRoot.ImageIndex:= 4;

  2496.       TempRoot.SelectedIndex:= 4;

  2497.     END;

  2498.     $56:

  2499.     BEGIN

  2500.       TempRoot.ImageIndex:= 4;

  2501.       TempRoot.SelectedIndex:= 4;

  2502.     END;

  2503.     $57:

  2504.     BEGIN

  2505.       TempRoot.ImageIndex:= 4;

  2506.       TempRoot.SelectedIndex:= 4;

  2507.     END;

  2508.     $58:

  2509.     BEGIN

  2510.       TempRoot.ImageIndex:= 22;

  2511.       TempRoot.SelectedIndex:= 10;

  2512.     END;

  2513.     $59:

  2514.     BEGIN

  2515.       TempRoot.ImageIndex:= 4;

  2516.       TempRoot.SelectedIndex:= 4;

  2517.     END;

  2518.     $5B:

  2519.     BEGIN

  2520.       TempRoot.ImageIndex:= 4;

  2521.       TempRoot.SelectedIndex:= 4;

  2522.     END;

  2523.     $5C:

  2524.     BEGIN

  2525.       TempRoot.ImageIndex:= 4;

  2526.       TempRoot.SelectedIndex:= 4;

  2527.     END;

  2528.     $5D:

  2529.     BEGIN

  2530.       TempRoot.ImageIndex:= 4;

  2531.       TempRoot.SelectedIndex:= 4;

  2532.     END;

  2533.     $5E:

  2534.     BEGIN

  2535.       TempRoot.ImageIndex:= 12;

  2536.       TempRoot.SelectedIndex:= 12;

  2537.     END;

  2538.     $5F:

  2539.     BEGIN

  2540.       TempRoot.ImageIndex:= 4;

  2541.       TempRoot.SelectedIndex:= 4;

  2542.     END;

  2543.     $60:

  2544.     BEGIN

  2545.       TempRoot.ImageIndex:= 13;

  2546.       TempRoot.SelectedIndex:= 13;

  2547.     END;

  2548.     $61:

  2549.     BEGIN

  2550.       TempRoot.ImageIndex:= 6;

  2551.       TempRoot.SelectedIndex:= 10;

  2552.     END;

  2553.     $63:

  2554.     BEGIN

  2555.       TempRoot.ImageIndex:= 2;

  2556.       TempRoot.SelectedIndex:= 2;

  2557.     END;

  2558.     $64:

  2559.     BEGIN

  2560.       TempRoot.ImageIndex:= 2;

  2561.       TempRoot.SelectedIndex:= 10;

  2562.     END;

  2563.     $66:

  2564.     BEGIN

  2565.       TempRoot.ImageIndex:= 2;

  2566.       TempRoot.SelectedIndex:= 2;

  2567.     END;

  2568.     $67:

  2569.     BEGIN

  2570.       TempRoot.ImageIndex:= 2;

  2571.       TempRoot.SelectedIndex:= 2;

  2572.     END;

  2573.     $68:

  2574.     BEGIN

  2575.       TempRoot.ImageIndex:= 2;

  2576.       TempRoot.SelectedIndex:= 2;

  2577.     END;

  2578.     $69:

  2579.     BEGIN

  2580.       TempRoot.ImageIndex:= 2;

  2581.       TempRoot.SelectedIndex:= 10;

  2582.     END;

  2583.     $6A:

  2584.     BEGIN

  2585.       TempRoot.ImageIndex:= 2;

  2586.       TempRoot.SelectedIndex:= 10;

  2587.     END;

  2588.     $6C:

  2589.     BEGIN

  2590.       TempRoot.ImageIndex:= 19;

  2591.       TempRoot.SelectedIndex:= 10;

  2592.     END;

  2593.     $6D:

  2594.     BEGIN

  2595.       TempRoot.ImageIndex:= 5;

  2596.       TempRoot.SelectedIndex:= 5;

  2597.     END;

  2598.     $6E:

  2599.     BEGIN

  2600.       TempRoot.ImageIndex:= 2;

  2601.       TempRoot.SelectedIndex:= 10;

  2602.     END;

  2603.     $70:

  2604.     BEGIN

  2605.       TempRoot.ImageIndex:= 7;

  2606.       TempRoot.SelectedIndex:= 10;

  2607.     END;

  2608.     $72:

  2609.     BEGIN

  2610.       TempRoot.ImageIndex:= 7;

  2611.       TempRoot.SelectedIndex:= 10;

  2612.     END;

  2613.     $73:

  2614.     BEGIN

  2615.       TempRoot.ImageIndex:= 7;

  2616.       TempRoot.SelectedIndex:= 10;

  2617.     END;

  2618.     $74:

  2619.     BEGIN

  2620.       TempRoot.ImageIndex:= 15;

  2621.       TempRoot.SelectedIndex:= 10;

  2622.     END;

  2623.     $75:

  2624.     BEGIN

  2625.       TempRoot.ImageIndex:= 11;

  2626.       TempRoot.SelectedIndex:= 11;

  2627.     END;

  2628.     $76:

  2629.     BEGIN

  2630.       TempRoot.ImageIndex:= 7;

  2631.       TempRoot.SelectedIndex:= 7;

  2632.     END;

  2633.     $FE:

  2634.     BEGIN

  2635.       TempRoot.ImageIndex:= 8;

  2636.       TempRoot.SelectedIndex:= 8;

  2637.     END;

  2638.     $FF:

  2639.     BEGIN

  2640.       TempRoot.ImageIndex:= 8;

  2641.       TempRoot.SelectedIndex:= 8;

  2642.     END;

  2643.     ELSE

  2644.     BEGIN

  2645.       TempRoot.ImageIndex:= 17;

  2646.       TempRoot.SelectedIndex:= 17;

  2647.     END;

  2648.   END;

  2649.   END;



  2651. END.

复制代码
注:
1. MD5什么的可以忽略不计，脚本中没有这个指令，引擎也不会做这个操作，是我后来(心血来潮)加进去的 =v=
2. Tree / Node什么的也可以忽略掉，这个是为了将指令映射到图形界面上，和引擎/指令没有关系。
3. 关键就在TScenario(分析脚本头部格式)和RScenCMD(对每个指令进行解码)。
  其中RScenCMD实现了对命令流的自动解析，在构建指令对象的时候，新的指令的类型和参数就被自动分析出来放到对应的成员中去了。
最后编辑Prz 最后编辑于 2007-07-17 13:56:30
飛べない翼に、意味はあるんでしょうか？
TOP
kizunaXD
头像

  • - 永远光辉的季节 -
  • 来自：
  • 性别：土豆
  • 生日：
  • 注册： 2007-07-23
  • 精华：0
  • 学分：0 个
  • 好人卡：30 张
  • 好感度：0
  • [浙江省金华市]
2007-07-23 15:27 |只看该用户 12#
t T

回复：請教如何解開SEEN.TXT

其他的还顺利，可是在最后一步出错了：
fatal error: exception Sys_error(&amp;quot;permission denied&amp;quot;)

怎么回事啊啊啊啊啊~又是哪里出错了？？？
最后编辑kizunaXD 最后编辑于 2007-07-23 16:22:08
TOP
返回列表 12
上一主题 | 下一主题