home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Programming / AllPlaton / Unsorted / AMOSProTrackdisk.AMOS / AMOSProTrackdisk.amosSourceCode
Encoding:
AMOS Source Code  |  2001-04-15  |  9.5 KB  |  344 lines
  1. Set Buffer 100
  2. MXDIR=400 : MXSCAN=250
  3. Dim DB$(MXDIR),DBA(MXDIR)
  4. Screen Open 0,640,256,2,$8000
  5. Curs Off : Flash Off : Paper 0 : Pen 1 : Cls 
  6. Dev Open 0,"3rd.scsi.device",128,2,0
  7. Reserve As Work 8,8*1024*1024
  8. I=256
  9. ' 6335280
  10. For A=2048*2048 To 6335279 Step 8*1024*2
  11.   Home : Print A/2048
  12.   For AA=0 To 8*1024*2-1 Step 64*2
  13.     DISKREAD[Start(8)+AA*512,-64*1024,A+AA]
  14.   Next 
  15.    Extension_8_0472 "mp3:Image"+ Extension_8_0EB8(I,3),8
  16.   Inc I
  17. Next 
  18. End 
  19. CACBLK=10
  20. Reserve As Work 11,2000*12
  21. ACH=Start(11)
  22. Reserve As Work 8,512*CACBLK
  23. DISKREAD[Start(8),-Length(8),0]
  24. Reserve As Chip Work 9,1024
  25. ST=Start(9)
  26. Reserve As Chip Work 10,1024
  27. ST2=Start(10)
  28. DISKREAD[ST,512,0]
  29. If Leek(ST)<> Extension_8_0998("RDSK") Then Print "No RDB-Block!" : Stop 
  30. PARTBLK=Leek(ST+28)
  31. DBA(0)=-1
  32. DB$(0)="Dh1.1:Recover"
  33. Do 
  34.   Exit If PARTBLK<1
  35.   DISKREAD[ST,512,PARTBLK]
  36.   If Leek(ST)<> Extension_8_0998("PART") Then Print "Invalid partition" : Stop 
  37.   HEADS=Leek(ST+12+128) : BLKPERTRK=Leek(ST+20+128)
  38.   BLKPERCYL=HEADS*BLKPERTRK
  39.   BASE=Leek(ST+36+128)*BLKPERCYL
  40.   NUMBLK=Leek(ST+40+128)*BLKPERCYL-STBLK
  41.   Print "PART BLOCK: ";PARTBLK
  42.   Print "  Device        : ";Peek$(ST+37,Peek(ST+36));":"
  43.   Print "  Heads per Cyl.:";HEADS
  44.   Print "  Blks per Track:";BLKPERTRK
  45.   Print "  First block   :";BASE
  46.   Print "  Num blocks    :";NUMBLK
  47.   PARTBLK=Leek(ST+16)
  48.   DISKREAD[ST,512,BASE]
  49.   If Leek(ST)= Extension_8_0998("PFS1")-48
  50.     Print "Scanning for valid IB-Blocks..."
  51.     For BLK=0 To MXSCAN
  52.       DISKREAD[ST,1024,BASE+BLK*2]
  53.       If Deek(ST)= Extension_8_098C("IB")
  54.         Print "  Index Block";BLK;": ";
  55.         For A=0 To 252
  56.           ARGL=Leek(ST+12+A*4)
  57.           If ARGL>0 and ARGL<NUMBLK
  58.             DISKREAD[ST2,1024,BASE+ARGL]
  59.             If Deek(ST2)= Extension_8_098C("AB")
  60.               If Leek(ST2+8)<>A
  61.                 Exit 
  62.               End If 
  63.             Else 
  64.               Exit 
  65.             End If 
  66.           End If 
  67.         Next 
  68.         If A=253
  69.           Print "Block valid!"
  70.         Else 
  71.           Print "Block invalid!"
  72.         End If 
  73.       End If 
  74.     Next 
  75.     Input "Choose index block for anode chain: ";AI
  76.     Print "Creating anode list...";
  77.     DISKREAD[ST,1024,BASE+AI*2]
  78.     ANOD=0
  79.     For A=0 To 252
  80.       ARGL=Leek(ST+12+A*4)
  81.       If ARGL>0
  82.         DISKREAD[ST2,1024,BASE+ARGL]
  83.         Copy ST2+16,ST2+16+12*84 To ACH+ANOD*12 : Add ANOD,84
  84.       End If 
  85.     Next 
  86.     Print "Number of anodes:";ANOD
  87.     ROOT=Leek(ACH+5*12+4)/2
  88.     Print "Rootblock dir:";ROOT
  89.     NUMD=1
  90.     DBA(0)=ROOT
  91.     DBA(NUMD)=-1
  92.     Print "Scanning directories..."
  93.     DIB=0
  94.     Do 
  95.       Exit If DBA(DIB)=-1
  96.       BLK=DBA(DIB)
  97.       DISKREAD[ST,1024,BASE+BLK*2]
  98.       If Deek(ST)= Extension_8_098C("DB")
  99.         ALL=0
  100.         Print "  Dir block";BLK;" of ";DB$(DIB)
  101.         PAR=Leek(ST+16) : ANO=Leek(ST+12)
  102.         FP=20
  103.         Do 
  104.           SIZ=Peek(ST+FP) : Exit If SIZ=0
  105.           TYP=Peek(ST+FP+1)
  106.           ANODE=Leek(ST+FP+2)
  107.           FSIZE=Leek(ST+FP+6)
  108.           DATE=Deek(ST+FP+10)
  109.           TIME= Extension_8_0946(Deek(ST+FP+12))+Deek(ST+FP+14)
  110.           PROT=Peek(ST+FP+16)
  111.           NAME$=Peek$(ST+FP+18,Peek(ST+FP+17))
  112.           COMM$=Peek$(ST+FP+19+Len(NAME$),Peek(ST+FP+18+Len(NAME$)))
  113. '          Print NAME$;Space$(34-Len(NAME$));
  114.           If TYP=253
  115. '            Print Lsstr$(FSIZE,8);" ";
  116.           Else 
  117.             NDN$= Extension_8_03EC(DB$(DIB))+NAME$
  118. '            Print NDN$;Space$(34-Len(NAME$));ANODE
  119.             NANO=ANODE
  120.             Trap Mkdir NDN$
  121.             While NANO<>0
  122.               DB$(NUMD)=NDN$
  123.               DBA(NUMD)=Leek(ACH+NANO*12+4)/2
  124.               NANO=Leek(ACH+NANO*12+8)
  125.               Inc NUMD
  126.               DBA(NUMD)=-1
  127.             Wend 
  128. '            Print "   <DIR> ";
  129.           End If 
  130. '          Print Object Protection$(PROT);" ";Cd Date$(DATE);Ct Time$(TIME)
  131. '          Print COMM$;" ";
  132.           If TYP=253 and(Instr(NAME$,"Crack")<>0 or Instr(NAME$,"Daten")<>0)
  133.             FILN$= Extension_8_03EC(DB$(DIB))+NAME$
  134.             If Exist(FILN$)=0
  135.               If ALL=0
  136.                 If FSIZE>2*1024*1024
  137.                   Print "Save (S/N/A)? ";
  138.                   Repeat 
  139.                     I$=Inkey$ : Multi Wait 
  140.                   Until I$="n" or I$="s" or I$="a"
  141.                   If I$="a"
  142.                     I$="s" : ALL=1
  143.                   End If 
  144.                 Else 
  145.                   I$="s"
  146.                 End If 
  147.               Else 
  148.                 I$="s"
  149.               End If 
  150.               If I$="s"
  151.                 If Exist(DB$(DIB))=0
  152.                   Mkdir DB$(DIB)
  153.                 End If 
  154.                 FSIZ=FSIZE : STANODE=ANODE
  155.                 Open Out 1,FILN$
  156.                   While FSIZ
  157.                     If STANODE<1
  158.                       Stop 
  159.                     End If 
  160.                     CSIZ=Leek(ACH+STANODE*12)*512
  161.                     RSIZ=Min(CSIZ,100*1024) : OSET=BASE+Leek(ACH+STANODE*12+4)
  162.                     While RSIZ
  163.                       Print ".";
  164.                       Reserve As Chip Work 19,RSIZ
  165.                       DISKREAD[Start(19),RSIZ,OSET]
  166.                        Extension_8_17B6 1,Start(19) To Min(RSIZ,FSIZ)
  167.                       Add OSET,RSIZ/512
  168.                       Add CSIZ,-RSIZ
  169.                       Add FSIZ,-Min(RSIZ,FSIZ)
  170.                       RSIZ=Min(CSIZ,100*1024)
  171.                     Wend 
  172.                     STANODE=Leek(ACH+STANODE*12+8)
  173.                   Wend 
  174.                 Close 1
  175.                  Extension_8_16F8 FILN$,DATE,TIME
  176.                  Extension_8_0780 FILN$,PROT
  177.               End If 
  178.             End If 
  179.           End If 
  180. '          Print 
  181.           Add FP,SIZ
  182.         Loop 
  183.       Else 
  184.         Print "Fuckin error!"; Extension_8_08C4(Deek(ST))
  185.         Wait Key 
  186.       End If 
  187.       Inc DIB
  188.     Loop 
  189.   End If 
  190.   Print 
  191. Loop 
  192. Dev Close 
  193. End 
  194. DUMMY:
  195.     Print "Scanning for valid Disk Blocks..."
  196.     For BLK=0 To MXSCAN
  197.       DISKREAD[ST,1024,BASE+BLK*2]
  198.       If Deek(ST)= Extension_8_098C("DB")
  199.         FAIL=0
  200.         PAR=Leek(ST+16) : ANO=Leek(ST+12)
  201. '        FP=20 
  202. '        Do  
  203. '          SIZ=Peek(ST+FP) : Exit If SIZ=0 
  204. '          TYP=Peek(ST+FP+1) 
  205. '          ANODE=Leek(ST+FP+2) 
  206. '          Add FP,SIZ
  207. '          DISKREAD[ST2,512,BASE+(ANODE/84)*2]   
  208. '          If Deek(ST2)<>Asc.w("IB") 
  209. '            FAIL=1 : Exit 
  210. '          End If  
  211. '        Loop  
  212.         If FAIL=0
  213.           Print "  Dir block";BLK,
  214.           DBA(NUMD)=BLK : Inc NUMD
  215.         End If 
  216.       End If 
  217.     Next 
  218.     Print "Searching for Root Block..."
  219.     NUMB=NUMD
  220.     NUMD=0
  221.     For DIB=0 To NUMB-1
  222.       BLK=DBA(DIB)
  223.       DISKREAD[ST,1024,BASE+BLK*2]
  224.       If Leek(ST+16)=0
  225.         DB$(NUMD)="ROOT:"
  226.         DBA(NUMD)=BLK : Inc NUMD
  227.       End If 
  228.     Next 
  229.     Print "Rootblock dirs:";NUMD
  230.     DBA(NUMD)=-1
  231.     Print "Scanning directories..."
  232.     DIB=0
  233.     Do 
  234.       Exit If DBA(DIB)=-1
  235.       BLK=DBA(DIB)
  236.       DISKREAD[ST,1024,BASE+BLK*2]
  237.       Print "  Dir block";BLK;" of ";DB$(DIB)
  238.       PAR=Leek(ST+16) : ANO=Leek(ST+12)
  239.       FP=20
  240.       Do 
  241.         SIZ=Peek(ST+FP) : Exit If SIZ=0
  242.         TYP=Peek(ST+FP+1)
  243.         ANODE=Leek(ST+FP+2)
  244.         FSIZE=Leek(ST+FP+6)
  245.         DATE=Deek(ST+FP+10)
  246.         TIME= Extension_8_0946(Deek(ST+FP+12))+Deek(ST+FP+14)
  247.         PROT=Peek(ST+FP+16)
  248.         NAME$=Peek$(ST+FP+18,Peek(ST+FP+17))
  249. '        Print NAME$;Space$(34-Len(NAME$));ANODE 
  250.         If TYP=253
  251. '          Print Lsstr$(FSIZE,7);" ";
  252.         Else 
  253.           NDN$= Extension_8_03EC(DB$(DIB))+NAME$
  254.           Print NDN$;Space$(34-Len(NAME$));ANODE
  255.           For ARGL=0 To MXSCAN
  256.             DISKREAD[ST2,1024,BASE+ARGL*2]
  257.             If Deek(ST2)= Extension_8_098C("DB")
  258.               If ANODE=Leek(ST2+16)
  259.                 Print ANODE,ARGL : Wait Key 
  260.                 For AXL=0 To NUMD-1
  261.                   Exit If DBA(AXL)=ARGL
  262.                 Next 
  263.                 If AXL=NUMD
  264.                   DB$(NUMD)=NDN$
  265.                   DBA(NUMD)=ARGL
  266.                   Inc NUMD
  267.                   DBA(NUMD)=-1
  268.                 End If 
  269.               End If 
  270.             End If 
  271.           Next 
  272. '          Print "  <DIR> "; 
  273.         End If 
  274. '        Print Object Protection$(PROT);" ";Cd Date$(DATE);Ct Time$(TIME)
  275.         Add FP,SIZ
  276.         If TYP=253
  277.           Print "Start of cluster:";Leek(ACH+ANODE*12+4)
  278.           Print "Size of cluster :";Leek(ACH+ANODE*12)
  279.           Print "Next anode      :";Leek(ACH+ANODE*12+8)
  280.           Wait Key 
  281. '          DISKREAD[ST2,1024,BASE+]
  282.         End If 
  283. '        Print "  "
  284.       Loop 
  285.       Inc DIB
  286.     Loop 
  287.  
  288.     Print "Scanning for valid MI-Blocks..."
  289.     For BLK=0 To MXSCAN
  290.       DISKREAD[ST,1024,BASE+BLK*2]
  291.       If Deek(ST)= Extension_8_098C("MI")
  292.         Print "  Index Block";BLK;": ";
  293.         For A=0 To 252
  294.           ARGL=Leek(ST+12+A*4)
  295.           If ARGL>0
  296.             DISKREAD[ST2,1024,BASE+ARGL]
  297.             If Deek(ST2)= Extension_8_098C("BM")
  298.               If Leek(ST2+8)<>A
  299.                 Exit 
  300.               End If 
  301.             Else 
  302.               Exit 
  303.             End If 
  304.           End If 
  305.         Next 
  306.         If A=253
  307.           Print "Block valid!"
  308.         Else 
  309.           Print "Block invalid!"
  310.         End If 
  311.       End If 
  312.     Next 
  313.     Wait Key 
  314.  
  315.  
  316. Procedure DISKREAD[AD,LE,OS]
  317.   If LE<0
  318.     IO=Dev Base(0)
  319.     Loke IO+36,-LE : Loke IO+40,AD
  320.     If OS<2048*2048
  321.       Loke IO+44,OS*512
  322.     Else 
  323.       Doke IO+44,OS/128
  324.       Doke IO+46,(OS mod 128)*512
  325.     End If 
  326.     Dev Do 0,2
  327.   Else 
  328.     If OS*512+LE<=Length(8)
  329.       Copy Start(8)+OS*512,Start(8)+OS*512+LE To AD
  330.     Else 
  331.       IO=Dev Base(0)
  332.       Loke IO+36,LE : Loke IO+40,AD : Loke IO+44,OS*512
  333.       Dev Do 0,2
  334.     End If 
  335.   End If 
  336. End Proc
  337. Procedure DISKWRITE[AD,LE,OS]
  338.   IO=Dev Base(0)
  339.   Loke IO+36,LE : Loke IO+40,AD : Loke IO+44,OS*512
  340.   Dev Do 0,3
  341. End Proc
  342. Procedure DISKFLUSH
  343.   Dev Do 0,4
  344. End Proc