home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Programowanie / AmigaE / powerd.lha / PowerD / source / dmod.d < prev    next >
Encoding:
Text File  |  2000-07-14  |  10.6 KB  |  505 lines
  1. // view powerd binary module (#?.b) generated by powerd v0.12
  2.  
  3. PROC DisplayMODULE(mem:PTR TO CHAR)
  4.     DEF    ver,rev,count,nl,ml,namelist:PTR TO CHAR,type,flags,acount,rcount,l,offset,
  5.             base:PTR TO CHAR
  6.  
  7.     IF Long(mem)<>"DMOD"
  8.         PrintF('\s: unknown filetype','dmod')
  9.         RETURN
  10.     ENDIF
  11.     mem+=4                        // skip "DMOD"
  12.     ver:=Word(mem)
  13.     rev:=Word(mem+2)
  14.     mem+=4                        // skip ver,rev
  15.     PrintF('// requied version of powerd: v\d.\z\d[2]\n\n',ver,rev)
  16.  
  17.     IF Long(mem)="MODS"
  18.         PrintF('MODULE\t')
  19.         count:=Word(mem+4)
  20.         mem+=6
  21.         WHILE count
  22.             count--
  23.             nl:=Word(mem)
  24.             mem+=2
  25.             PrintF('''\s''',mem)
  26.             mem+=nl+1
  27.             IF Odd(mem) THEN mem++
  28.             IF CtrlC() THEN RETURN
  29.         EXITIF count=0 DO PrintF('\n\n')
  30.             PrintF(',\n\t\t\t')
  31.         ENDWHILE
  32.     ENDIF
  33.  
  34.     IF Long(mem)="CNST"                // constant list
  35.         PrintF('CONST\t')
  36.         count:=Word(mem+4)            // count of constants
  37.         ml:=Long(mem+6)
  38.         nl:=Long(mem+10)
  39.         mem+=14
  40.         namelist:=mem+ml
  41.         WHILE count
  42.             count--
  43.             PrintF('\s=',namelist)
  44.             type:=UByte(mem++)
  45.             flags:=UByte(mem++)
  46.             IF type=$ff
  47.                 PrintF('0')
  48.             ELSEIF type=8                // DT_DOUBLE
  49.                 PrintF('$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  50.                 mem+=8
  51.             ELSEIF flags&%10            // S_TAG
  52.                 PrintF('$\h',Word(mem)|$80000000)
  53.                 mem+++
  54.             ELSEIF type=3                // DT_WORD
  55.                 PrintF('\d',Word(mem))
  56.                 mem+++
  57.             ELSE
  58.                 acount:=Long(mem)
  59.                 PrintF(IF acount>=-32768 AND acount<=32767 THEN '\d' ELSE '$\h',acount)
  60. //                PrintF(IF Long(mem)>=-32768 AND Long(mem)<=32767 THEN '\d' ELSE '$\h',Long(mem))
  61.                 mem+=4
  62.             ENDIF
  63.             namelist+=StrLen(namelist)+1
  64.             IF namelist[0]="\0" THEN namelist++
  65.             IF CtrlC() THEN RETURN
  66.         EXITIF count=0 DO PrintF('\n\n')
  67.             PrintF(',\n\t\t')
  68.         ENDWHILE
  69.         IF Odd(namelist) THEN namelist++
  70.         mem:=namelist
  71.     ENDIF
  72.  
  73.     IF Long(mem)="OBJC"            -> object list
  74.         ml:=Long(mem+4)
  75.         nl:=Long(mem+8)
  76.         acount:=Word(mem+12)
  77.         count:=Word(mem+14)
  78.         mem+=16
  79.         namelist:=mem+ml
  80.  
  81.         WHILE acount
  82.             mem,namelist:=LoadOBJECT(mem,namelist)
  83.             acount--
  84.             IF CtrlC() THEN RETURN
  85.         ENDWHILE
  86.  
  87.         IF Odd(namelist) THEN namelist++
  88.         mem:=namelist
  89.     ENDIF
  90.  
  91.     IF Long(mem)="#def"            -> #define list
  92.         count:=Word(mem+4)
  93.         acount:=Word(mem+6)
  94.         ml:=Long(mem+8)
  95.         nl:=Long(mem+12)
  96.         mem+=16
  97.         namelist:=mem+ml
  98.  
  99.         WHILE count
  100.             count--
  101.             PrintF('#define \s',namelist)
  102.             namelist+=mem[1]+1
  103.             l:=Word(mem+2)
  104.             acount:=mem[0]
  105.             mem+=4
  106.             IF acount
  107.                 PrintF('(')
  108.                 WHILE acount
  109.                     PrintF('\s',namelist)
  110.                     namelist+=mem[1]+1
  111.                     mem+++
  112.                     acount--
  113.                     IF CtrlC() THEN RETURN
  114.                 EXITIF acount=0 DO PrintF(') ')
  115.                     PrintF(',')
  116.                 ENDWHILE
  117.             ELSE PrintF(' ')
  118.             PrintF('\s\n',namelist)
  119.             namelist+=l+1
  120.             IF CtrlC() THEN RETURN
  121.         ENDWHILE
  122.  
  123.         IF Odd(namelist) THEN namelist++
  124.         mem:=mem+nl
  125.     ENDIF
  126.  
  127.     IF Long(mem)="LIBR"            // function list
  128.         count:=Word(mem+4)        // count of functions
  129.         nl:=Word(mem+6)            // base name length
  130.         ml:=Long(mem+12)            // block length
  131.         mem+=16
  132.         base:=mem
  133.         mem+=nl
  134.         IF mem[0]="\0" THEN mem++
  135.         namelist:=mem+ml
  136.         PrintF('LIBRARY \s\n\t',base)
  137.  
  138.         WHILE count
  139.             count--
  140.             offset:=Word(mem)
  141.             acount:=mem[2]
  142.             rcount:=mem[3]&$1f
  143.             ver:=mem[3]>>5            // get ppc function type
  144.             SELECT ver
  145.             CASE 0;    PrintF('M68K,')
  146.             CASE 1;    PrintF('PPC,')
  147.             CASE 2;    PrintF('PPC2,')
  148.             CASE 3;    PrintF('PPC0,')
  149.             ENDSELECT
  150.             mem+=4
  151.             PrintF('\s(',namelist)
  152.             namelist+=StrLen(namelist)+1
  153.             WHILE acount
  154.                 acount--
  155.                 IF ver
  156.                     SELECT mem[2]
  157.                     CASE 0 TO 31;    PrintF('r\d',mem[2]&%11111)
  158.                     CASE 32 TO 63;    PrintF('f\d',mem[2]&%11111)
  159.                     ENDSELECT
  160.                 ELSE
  161.                     SELECT mem[2]
  162.                     CASE 0 TO 7;    PrintF('d\d',mem[2]&%111)
  163.                     CASE 8 TO 15;    PrintF('a\d',mem[2]&%111)
  164.                     CASE 16 TO 23;    PrintF('fp\d',mem[2]&%111)
  165.                     ENDSELECT
  166.                 ENDIF
  167.                 type:=mem[0]
  168.                 flags:=mem[1]        // means default value set
  169.                 nl:=mem[3]
  170.                 mem+=4
  171.                 IF flags
  172.                     IF type=8
  173.                         PrintF('=$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  174.                         mem+=8
  175.                     ELSE
  176.                         PrintF('=$\d',Long(mem))
  177.                         mem+=4
  178.                     ENDIF
  179.                 ENDIF
  180.                 IF type
  181.                     PrintF(':\s',TypeStr(type))
  182.                 ENDIF
  183.                 IF nl
  184.                     PrintF('\s',namelist)
  185.                     namelist+=nl+1
  186.                 ENDIF
  187.             EXITIF acount=0
  188.                 PrintF(',')
  189.                 IF CtrlC() THEN RETURN
  190.             ENDWHILE
  191.             PrintF(')')
  192.  
  193.             IF rcount
  194.                 PrintF('(')
  195.                 WHILE rcount
  196.                     rcount--
  197.                     IF ver
  198.                         SELECT mem[2]
  199.                         CASE 0 TO 31;    PrintF('r\d',mem[2]&%11111)
  200.                         CASE 32 TO 63;    PrintF('f\d',mem[2]&%11111)
  201.                         ENDSELECT
  202.                     ELSE
  203.                         SELECT mem[2]
  204.                         CASE 0 TO 7;    PrintF('d\d',mem[2]&%111)
  205.                         CASE 8 TO 15;    PrintF('a\d',mem[2]&%111)
  206.                         CASE 16 TO 23;    PrintF('fp\d',mem[2]&%111)
  207.                         ENDSELECT
  208.                     ENDIF
  209.                     type:=mem[0]
  210.                     nl:=mem[3]
  211.                     mem+=4
  212.                     IF type
  213.                         PrintF(':\s',TypeStr(type))
  214.                     ENDIF
  215.                     IF nl
  216.                         PrintF('\s',namelist)
  217.                         namelist+=nl+1
  218.                     ENDIF
  219.                 EXITIF rcount=0 DO PrintF(')')
  220.                     PrintF(',')
  221.                     IF CtrlC() THEN RETURN
  222.                 ENDWHILE
  223.             ENDIF
  224.             PrintF('=\d',offset)
  225.             IF CtrlC() THEN RETURN
  226.         EXITIF count=0 DO PrintF('\n\n')
  227.             PrintF(',\n\t')
  228.         ENDWHILE
  229.         IF Odd(namelist) THEN namelist++
  230.         mem:=namelist
  231.     ENDIF
  232.  
  233.     IF Long(mem)="EXPR"            // external function list
  234.         count:=Word(mem+4)
  235.         ml:=Long(mem+10)
  236.         nl:=Long(mem+14)
  237.         mem+=18
  238.         namelist:=mem+ml
  239.  
  240.         WHILE count
  241.             count--
  242.             SELECT type:=mem[0]
  243.             CASE 11;    PrintF('EPROC')
  244.             CASE 13;    PrintF('LPROC')
  245.             CASE 14;    PrintF('RPROC')
  246.             ENDSELECT
  247. /*
  248.             IF StrCmp(namelist,'Ror')
  249.                 xxxxxx:
  250.                 l:=l
  251.             ENDIF
  252. */
  253.             PrintF(' \s(',namelist)
  254.             namelist+=StrLen(namelist)+1
  255.             flags:=mem[1]
  256.             acount:=mem[2]
  257.             rcount:=mem[3]
  258.             mem+=4
  259.             offset:=0
  260.             IF flags&%01
  261.                 offset:=namelist
  262.                 namelist+=StrLen(namelist)+1
  263.             ENDIF
  264.  
  265.             IF type=14
  266.                 IF flags&%10
  267.                     l:=namelist
  268.                     namelist+=StrLen(namelist)+1
  269.                 ELSE
  270.                     l:=NIL
  271.                 ENDIF
  272.             ENDIF
  273.  
  274.             WHILE acount
  275.                 acount--
  276.                 type:=mem[0]
  277.                 flags:=mem[1]
  278.                 SELECT mem[3]
  279.                 CASE 0 TO 7;    PrintF('d\d',mem[3]&%111)
  280.                 CASE 8 TO 15;    PrintF('a\d',mem[3]&%111)
  281.                 CASE 16 TO 23;    PrintF('fp\d',mem[3]&%111)
  282.                 DEFAULT;            PrintF('\c',"z"-acount)        // stack
  283.                 ENDSELECT
  284.                 mem+=4
  285.                 IF flags&%01
  286.                     IF type=8    // DT_DOUBLE
  287.                         PrintF('=$\z\h[8].\z\h[8]',Long(mem),Long(mem+4))
  288.                         mem+=8
  289.                     ELSE
  290.                         PrintF('=\d',Long(mem))
  291.                         mem+=4
  292.                     ENDIF
  293.                 ENDIF
  294.                 IF type
  295.                     PrintF(':\s',TypeStr(type))
  296.                     IF flags&%10
  297.                         PrintF('\s',namelist)
  298.                         namelist+=StrLen(namelist)+1
  299.                     ENDIF
  300.                 ENDIF
  301.             EXITIF acount=0
  302.                 PrintF(',')
  303.                 IF CtrlC() THEN RETURN
  304.             ENDWHILE
  305.             PrintF(')')
  306.  
  307.             IF rcount
  308.                 PrintF('(')
  309.                 WHILE rcount
  310.                     rcount--
  311.                     type:=mem[0]
  312.                     SELECT mem[1]
  313.                     CASE 0 TO 7;    PrintF('d\d',mem[1]&%111)
  314.                     CASE 8 TO 15;    PrintF('a\d',mem[1]&%111)
  315.                     CASE 16 TO 23;    PrintF('fp\d',mem[1]&%111)
  316.                     ENDSELECT
  317.                     mem+++
  318.                     IF type THEN PrintF(':\s',TypeStr(type))
  319.                     IF type=10 OR type=42 OR type=74 OR type=138
  320.                         PrintF('\s',namelist)
  321.                         namelist+=StrLen(namelist)+1
  322.                     ENDIF
  323.                 EXITIF rcount=0 DO PrintF(')')
  324.                     PrintF(',')
  325.                     IF CtrlC() THEN RETURN
  326.                 ENDWHILE
  327.             ENDIF
  328.  
  329.             IF offset THEN PrintF(' OF \s',offset)
  330.             IF l THEN PrintF('=''\s''',l)
  331.             IF CtrlC() THEN RETURN
  332.             PrintF('\n')
  333.         ENDWHILE
  334.         PrintF('\n')
  335.         IF Odd(namelist) THEN namelist++
  336.         mem+=nl
  337.     ENDIF
  338.  
  339.     IF Long(mem)="EDEF"
  340.         PrintF('EDEF\t')
  341.         count:=Word(mem+4)
  342.         ml:=Long(mem+6)
  343.         nl:=Long(mem+10)
  344.         mem+=14
  345.         namelist:=mem+ml
  346.  
  347.         WHILE count
  348.             count--
  349.             PrintF('\s',namelist)
  350.             namelist+=StrLen(namelist)+1
  351.             IF mem[0] THEN PrintF(':\s',TypeStr(mem[0]))
  352.             IF mem[1]
  353.                 PrintF('\s',namelist)
  354.                 namelist+=StrLen(namelist)+1
  355.             ENDIF
  356.             mem+++
  357.         EXITIF count=0 DO PrintF('\n\n')
  358.             PrintF(',\n\t\t')
  359.             IF CtrlC() THEN RETURN
  360.         ENDWHILE
  361.         mem+=nl
  362.     ENDIF
  363.  
  364.     IF Long(mem)="LINK"
  365.         PrintF('OPT\t')
  366.         count:=Word(mem+4)
  367.         mem:=mem+6
  368.         WHILE count
  369.             count--
  370.             nl:=Word(mem)
  371.             mem+++
  372.             PrintF('''\s''',mem)
  373.             mem:=mem+nl
  374.             IF Odd(nl) THEN mem++
  375.         EXITIF count=0 DO PrintF('\n')
  376.             PrintF(',\n\t\t')
  377.             IF CtrlC() THEN RETURN
  378.         ENDWHILE
  379.     ENDIF
  380.  
  381.     IF Long(mem)="HEAD"
  382.         nl:=Word(mem+4)
  383.         mem+=6
  384.         PrintF('OPT\tHEAD=''\s''\n',mem)
  385.         mem+=nl
  386.         IF Odd(nl) THEN mem++
  387.     ENDIF
  388.  
  389. ENDPROC
  390.  
  391. PROC LoadOBJECT(mem:PTR TO CHAR,nmem:PTR TO CHAR)(PTR TO CHAR,PTR TO CHAR)
  392.     IF mem[0]=0
  393.         PrintF('OBJECT \s',nmem)
  394.         nmem+=mem[1]+1
  395.         IF mem[2]
  396.             PrintF(' OF \s\n',nmem)
  397.             nmem+=mem[2]+1
  398.         ELSE PrintF('\n')
  399.         mem+=8
  400.         WHILE mem[0]=1
  401.             mem,nmem:=LoadOBJECT(mem,nmem)
  402.         EXITIF mem[0]<>1 DO PrintF('\n\n')
  403.             PrintF(',\n')
  404.             IF CtrlC() THEN RETURN
  405.         ENDWHILE
  406.     ELSEIF mem[0]=1
  407.         PrintF('\t\s',nmem)
  408.         nmem+=mem[1]+1
  409.         IF Word(mem+6) THEN PrintF('[\d]',Word(mem+6))
  410.         PrintF(':\s',TypeStr(mem[2]))
  411.         IF mem[5]
  412.             PrintF('\s',nmem)
  413.             nmem+=mem[5]+1
  414.         ENDIF
  415.         mem+=10
  416.     ENDIF
  417. ENDPROC mem,nmem
  418.  
  419. PROC TypeStr(type)(PTR TO CHAR)
  420.     DEF    str:PTR TO CHAR
  421.     SELECT type
  422.     CASE 1;    str:='LONG'
  423.     CASE 2;    str:='ULONG'
  424.     CASE 3;    str:='WORD'
  425.     CASE 4;    str:='UWORD'
  426.     CASE 5;    str:='BYTE'
  427.     CASE 6;    str:='UBYTE'
  428.     CASE 7;    str:='FLOAT'
  429.     CASE 8;    str:='DOUBLE'
  430.     CASE 9;    str:='BOOL'
  431.     CASE 10;    str:=NIL
  432.     CASE 11;    str:='PTR'
  433.     CASE 12;    str:='DLONG'
  434.     CASE 13;    str:='UDLONG'
  435.     CASE 14;    str:='STRING'
  436.  
  437.     CASE 33;    str:='PTR TO LONG'
  438.     CASE 34;    str:='PTR TO ULONG'
  439.     CASE 35;    str:='PTR TO WORD'
  440.     CASE 36;    str:='PTR TO UWORD'
  441.     CASE 37;    str:='PTR TO BYTE'
  442.     CASE 38;    str:='PTR TO UBYTE'
  443.     CASE 39;    str:='PTR TO FLOAT'
  444.     CASE 40;    str:='PTR TO DOUBLE'
  445.     CASE 41;    str:='PTR TO BOOL'
  446.     CASE 42;    str:='PTR TO '
  447.     CASE 43;    str:='PTR TO PTR'
  448.     CASE 44;    str:='PTR TO DLONG'
  449.     CASE 45;    str:='PTR TO UDLONG'
  450.     CASE 46;    str:='PTR TO CHAR'
  451.  
  452.     CASE 65;    str:='PTR TO PTR TO LONG'
  453.     CASE 66;    str:='PTR TO PTR TO ULONG'
  454.     CASE 67;    str:='PTR TO PTR TO WORD'
  455.     CASE 68;    str:='PTR TO PTR TO UWORD'
  456.     CASE 69;    str:='PTR TO PTR TO BYTE'
  457.     CASE 70;    str:='PTR TO PTR TO UBYTE'
  458.     CASE 71;    str:='PTR TO PTR TO FLOAT'
  459.     CASE 72;    str:='PTR TO PTR TO DOUBLE'
  460.     CASE 73;    str:='PTR TO PTR TO BOOL'
  461.     CASE 74;    str:='PTR TO PTR TO '
  462.     CASE 75;    str:='PTR TO PTR TO PTR'
  463.     CASE 76;    str:='PTR TO PTR TO DLONG'
  464.     CASE 77;    str:='PTR TO PTR TO UDLONG'
  465.     CASE 78;    str:='PTR TO PTR TO CHAR'
  466.  
  467.     CASE 129;str:='LIST OF LONG'
  468.     CASE 130;str:='LIST OF ULONG'
  469.     CASE 131;str:='LIST OF WORD'
  470.     CASE 132;str:='LIST OF UWORD'
  471.     CASE 133;str:='LIST OF BYTE'
  472.     CASE 134;str:='LIST OF UBYTE'
  473.     CASE 135;str:='LIST OF FLOAT'
  474.     CASE 136;str:='LIST OF DOUBLE'
  475.     CASE 137;str:='LIST OF BOOL'
  476.     CASE 138;str:='LIST OF '
  477.     CASE 139;str:='LIST OF PTR'
  478.     CASE 140;str:='LIST OF DLONG'
  479.     CASE 141;str:='LIST OF UDLONG'
  480.     CASE 142;str:='LIST OF CHAR'
  481.     DEFAULT;    str:='VOID'
  482.     ENDSELECT
  483. ENDPROC str
  484.  
  485. MODULE    'exec/memory'
  486.  
  487. ENUM    SOURCE
  488.  
  489. PROC main()
  490.     DEF    rda,args=[0,0]:LONG,l,m:PTR TO CHAR,f
  491.     IF rda:=ReadArgs('SOURCE/A',args,NIL)
  492.         l:=FileLength(args[SOURCE])
  493.         IF f:=Open(args[SOURCE],OLDFILE)
  494.             IF m:=AllocMem(l+8,MEMF_PUBLIC|MEMF_CLEAR)
  495.                 IF Read(f,m,l)=l
  496.                     DisplayMODULE(m)
  497.                 ELSE PrintFault(IOErr(),'dmod')
  498.                 FreeMem(m,l+8)
  499.             ELSE PrintF('\s: not enough memory\n','dmod')
  500.             Close(f)
  501.         ELSE PrintFault(IOErr(),'dmod')
  502.         FreeArgs(rda)
  503.     ELSE PrintFault(IOErr(),'dmod')
  504. ENDPROC
  505.