home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v941.tgz / icon.v941src.tar / icon.v941src / ipl / mprocs / emutils.icn < prev    next >
Text File  |  2000-07-29  |  17KB  |  509 lines
  1. ############################################################################
  2. #
  3. #    File:     emutils.icn
  4. #
  5. #    Subject:  Procedures to support MT-Icon monitors
  6. #
  7. #    Author:   Ralph E. Griswold
  8. #
  9. #    Date:     April 16, 1997
  10. #
  11. ############################################################################
  12. #
  13. #   This file is in the public domain.
  14. #
  15. ############################################################################
  16. #
  17. #  evname(s) maps the event code to a standard descriptive phrases and vice
  18. #  versa.
  19. #
  20. ############################################################################
  21. #
  22. #  Links:  convert, tables
  23. #
  24. ############################################################################
  25. #
  26. #  Includes:  evdefs.icn
  27. #
  28. ############################################################################
  29.  
  30. link convert
  31. link tables
  32.  
  33. $include "evdefs.icn"
  34.  
  35. procedure evname(s)
  36.    local result
  37.    static namemap
  38.  
  39.    initial {
  40.       namemap   := table()
  41.    
  42.       namemap[E_Aconv] := "conversion attempt"
  43.       namemap[E_Argp] := "argument pointer"
  44.       namemap[E_Alien] := "alien allocation"
  45.       namemap[E_Assign] := "assignment"
  46. #     namemap[E_Base] := "base address of storage region"
  47.       namemap[E_BlkDeAlc] := "block deallocation"
  48.       namemap[E_Bsusp] := "suspension from operation"
  49.       namemap[E_Coact] := "co-expression activation"
  50.       namemap[E_Cocreate] := "co-expression creation"
  51.       namemap[E_Coexpr] := "co-expression allocation"
  52.       namemap[E_Cofail] := "co-expression failure"
  53.       namemap[E_Collect] := "garbage collection"
  54. #     namemap[E_Comment] := "comment"
  55.       namemap[E_Coret] := "co-expression return"
  56.       namemap[E_Cset] := "cset allocation"
  57.       namemap[E_Deref] := "variable dereference"
  58.       namemap[E_Ecall] := "call of operation"
  59.       namemap[E_Efail] := "failure from expression"
  60.       namemap[E_Efp] := "expression frame pointer"
  61.       namemap[E_EndCollect] := "end of garbage collection"
  62.       namemap[E_Erem] := "removal of a suspended generator"
  63.       namemap[E_Eresum] := "resumption of expression"
  64. #     namemap[E_Eret] := "return from expression"
  65.       namemap[E_Error] := "run-time error"
  66.       namemap[E_Esusp] := "suspension from alternation"
  67.       namemap[E_Exit] := "program exit"
  68.       namemap[E_External] := "external allocation"
  69.       namemap[E_Fcall] := "function call"
  70.       namemap[E_Fclose] := "file close"
  71.       namemap[E_Fconv] := "conversion failure"
  72.       namemap[E_Ffail] := "function failure"
  73.       namemap[E_File] := "file allocation"
  74.       namemap[E_Floc] := "file location"
  75.       namemap[E_Fmode] := "file open mode"
  76.       namemap[E_Fopen] := "file open"
  77.       namemap[E_Fread] := "file read"
  78.       namemap[E_Freads] := "file reads"
  79.       namemap[E_Free] := "free region"
  80.       namemap[E_Frem] := "function suspension removal"
  81.       namemap[E_Fresum] := "function resumption"
  82.       namemap[E_Fret] := "function return"
  83.       namemap[E_Fseek] := "file seek"
  84.       namemap[E_Fstring] := "string read or written"
  85.       namemap[E_Fsusp] := "function suspension"
  86.       namemap[E_Fwhere] := "file location"
  87.       namemap[E_Fwrite] := "function write"
  88.       namemap["\223"] := "function writes"
  89.       namemap[E_Gfp] := "generator frame pointer"
  90. #     namemap[E_Highlight] := "allocation highlight"
  91.       namemap[E_Ilevel] := "interpreter call level"
  92.       namemap[E_Intcall] := "interpreter call"
  93.       namemap[E_Integer] := "integer value pseudo-event"
  94.       namemap[E_Intret] := "interpreter return"
  95.       namemap[E_Ipc] := "interpreter program counter"
  96.       namemap[E_Kywdint] := "integer keyword value pseudo-event"
  97.       namemap[E_Kywdpos] := "position value pseudo-event"
  98.       namemap[E_Kywdsubj] := "subject value pseudo-event"
  99.       namemap[E_Lbang] := "list generation"
  100.       namemap[E_Lcreate] := "list creation"
  101.       namemap[E_Lelem] := "list element allocation"
  102.       namemap[E_Lget] := "list get"
  103.       namemap[E_Line] := "line change"
  104.       namemap[E_List] := "list allocation"
  105.       namemap[E_Loc] := "location change"
  106.       namemap[E_Lpop] := "list pop"
  107.       namemap[E_Lpull] := "list pull"
  108.       namemap[E_Lpush] := "list push"
  109.       namemap[E_Lput] := "list put"
  110.       namemap[E_Lrand] := "list random reference"
  111. #     namemap[E_Lref] := "list reference"
  112.       namemap[E_Lrgint] := "large integer allocation"
  113.       namemap[E_Lsub] := "list subscript"
  114.       namemap[E_Lsusp] := "suspension from limitation"
  115.       namemap[E_MXevent] := "monitor input event"
  116.       namemap[E_Nconv] := "conversion not needed"
  117.       namemap[E_NewRegion] := "new storage region"
  118.       namemap[E_Null] := "null value value pseudo-event"
  119.       namemap[E_Ocall] := "operator call"
  120.       namemap[E_Ofail] := "operator failure"
  121. #     namemap[E_Offset] := "address offset"
  122. #     namemap[E_Op] := "interpreter operation"
  123.       namemap[E_Opcode] := "virtual-machine instruction"
  124.       namemap[E_Orem] := "operator suspension removal"
  125.       namemap[E_Oresum] := "operator resumption"
  126.       namemap[E_Oret] := "operator return"
  127.       namemap[E_Osusp] := "operator suspension"
  128. #     namemap[E_Pause] := "memory monitoring comment"
  129.       namemap[E_Pcall] := "procedure call"
  130.       namemap[E_Pfail] := "procedure failure"
  131.       namemap[E_Pfp] := "procedure frame pointer"
  132. #     namemap[E_Pid] := "symbol name"
  133.       namemap[E_Prem] := "suspended procedure removal"
  134.       namemap[E_Presum] := "procedure resumption"
  135.       namemap[E_Pret] := "procedure return"
  136.       namemap[E_Proc] := "procedure value pseudo-event"
  137.       namemap[E_Psusp] := "procedure suspension"
  138.       namemap[E_Rbang] := "record generation"
  139.       namemap[E_Rcreate] := "record creation"
  140.       namemap[E_Real] := "real allocation"
  141.       namemap[E_Record] := "record allocation"
  142.       namemap[E_Refresh] := "refresh allocation"
  143. #     namemap[E_Region] := "region"
  144.       namemap[E_Rrand] := "record random reference"
  145. #     namemap[E_Rref] := "record reference"
  146.       namemap[E_Rsub] := "record subscript"
  147.       namemap[E_Sbang] := "set generation"
  148.       namemap[E_Sconv] := "conversion success"
  149.       namemap[E_Screate] := "set creation"
  150.       namemap[E_Sdelete] := "set deletion"
  151.       namemap[E_Selem] := "set element allocation"
  152.       namemap[E_Set] := "set allocation"
  153.       namemap[E_Sfail] := "scanning failure"
  154.       namemap[E_Sinsert] := "set insertion"
  155. #     namemap[E_Size] := "region size"
  156.       namemap[E_Slots] := "hash header allocation"
  157.       namemap[E_Smember] := "set membership"
  158.       namemap[E_Snew] := "scanning environment creation"
  159.       namemap[E_Spos] := "scanning position"
  160.       namemap[E_Srand] := "set random reference"
  161.       namemap[E_Srem] := "scanning environment removal"
  162.       namemap[E_Sresum] := "scanning resumption"
  163.       namemap[E_Ssasgn] := "substring assignment"
  164.       namemap[E_Ssusp] := "scanning suspension"
  165.       namemap[E_Stack] := "stack depth"
  166.       namemap[E_StrDeAlc] := "string deallocation"
  167.       namemap[E_String] := "string allocation"
  168.       namemap[E_Sval] := "set value"
  169. #     namemap[E_Sym] := "symbol table entry"
  170.       namemap[E_Table] := "table allocation"
  171.       namemap[E_Tbang] := "table generation"
  172.       namemap[E_Tconv] := "conversion target"
  173.       namemap[E_Tcreate] := "table creation"
  174.       namemap[E_Tdelete] := "table deletion"
  175.       namemap[E_Telem] := "table element allocation"
  176.       namemap[E_TenureBlock] := "tenure a block region"
  177.       namemap[E_TenureString] := "tenure a string region"
  178.       namemap[E_Tick] := "clock tick"
  179.       namemap[E_Tinsert] := "table insertion"
  180.       namemap[E_Tkey] := "table key generation"
  181.       namemap[E_Tmember] := "table membership"
  182.       namemap[E_Trand] := "table random reference"
  183. #     namemap[E_Tref] := "table reference"
  184.       namemap[E_Tsub] := "table subscript"
  185. #     namemap[E_Tval] := "table value"
  186.       namemap[E_Tvsubs] := "substring trapped variable allocation"
  187.       namemap[E_Tvtbl] := "table-element trapped variable allocation"
  188. #     namemap[E_Used] := "space used"
  189.       namemap[E_Value] := "value assigned"
  190.       namemap[E_Fterm] := "write terminator"
  191.  
  192. #     namemap := twt(namemap)
  193.       }
  194.    
  195.    result := namemap[s]
  196.    /result := "E_\\" || exbase10(find(s, &cset) - 1, 8)
  197.  
  198.    return result
  199.  
  200. end
  201.  
  202. ############################################################################
  203. #
  204. #  evsym() maps event codes to the symbolic names for the codes and vice
  205. #  versa.
  206. #
  207. ############################################################################
  208.  
  209. procedure evsym(s)
  210.    local result
  211.    static symmap
  212.  
  213.    initial {
  214.       symmap   := table()
  215.    
  216.       symmap[E_Aconv]    := "E_Aconv"
  217.       symmap[E_Argp]     := "E_Argp"
  218.       symmap[E_Alien]    := "E_Alien"
  219.       symmap[E_Assign]   := "E_Assign"
  220.       symmap[E_BlkDeAlc] := "E_BlkDeAlc"
  221.       symmap[E_Bsusp]    := "E_Bsusp"
  222.       symmap[E_Coact]    := "E_Coact"
  223.       symmap[E_Cocreate] := "E_Cocreate"
  224.       symmap[E_Coexpr]   := "E_Coexpr"
  225.       symmap[E_Cofail]   := "E_Cofail"
  226.       symmap[E_Cofree]   := "E_Cofree"
  227.       symmap[E_Collect]  := "E_Collect"
  228.       symmap[E_Coret]    := "E_Coret"
  229.       symmap[E_Cset]     := "E_Cset"
  230.       symmap[E_Deref]    := "E_Deref"
  231.       symmap[E_Ecall]    := "E_Ecall"
  232.       symmap[E_Efail]    := "E_Efail"
  233.       symmap[E_Efp]      := "E_Efp"
  234.       symmap[E_Eresum]   := "E_Eresum"
  235.       symmap[E_Error]    := "E_Error"
  236.       symmap[E_Esusp]    := "E_Esusp"
  237.       symmap[E_Erem]     := "E_Erem"
  238.       symmap[E_Exit]     := "E_Exit"
  239.       symmap[E_External] := "E_External"
  240.       symmap[E_Fcall]    := "E_Fcall"
  241.       symmap[E_Fclose]   := "E_Fclose"
  242.       symmap[E_Fconv]    := "E_Fconv"
  243.       symmap[E_Ffail]    := "E_Ffail"
  244.       symmap[E_File]     := "E_File"
  245.       symmap[E_Floc]     := "E_Loc"
  246.       symmap[E_Fmode]    := "E_Fmode"
  247.       symmap[E_Fopen]    := "E_Fopen"
  248.       symmap[E_Fread]    := "E_Fread"
  249.       symmap[E_Freads]   := "E_Freads"
  250.       symmap[E_Free]     := "E_Free"
  251.       symmap[E_Frem]     := "E_Frem"
  252.       symmap[E_Fresum]   := "E_Fresum"
  253.       symmap[E_Fret]     := "E_Fret"
  254.       symmap[E_Fseek]    := "E_Fseek"
  255.       symmap[E_Fstring]  := "E_Fstring"
  256.       symmap[E_Fsusp]    := "E_Fsusp"
  257.       symmap[E_Fwhere]   := "E_Fwhere"
  258.       symmap[E_Fwrite]   := "E_Fwrite"
  259.       symmap[E_Fterm]    := "E_Fterm"
  260.       symmap[E_Gfp]      := "E_Gfp"
  261.       symmap[E_Ilevel]   := "E_Ilevel"
  262.       symmap[E_Intcall]  := "E_Intcall"
  263.       symmap[E_Integer]  := "E_Integer"
  264.       symmap[E_Intret]   := "E_Intret"
  265.       symmap[E_Ipc]      := "E_Ipc"
  266.       symmap[E_Kywdint]  := "E_Kywdint"
  267.       symmap[E_Kywdpos]  := "E_Kywdpos"
  268.       symmap[E_Kywdsubj] := "E_Kywdsubj"
  269.       symmap[E_Lbang]    := "E_Lbang"
  270.       symmap[E_Lcreate]  := "E_Lcreate"
  271.       symmap[E_Lelem]    := "E_Lelem"
  272.       symmap[E_Line]     := "E_Line"
  273.       symmap[E_List]     := "E_List"
  274.       symmap[E_Loc]      := "E_Loc"
  275.       symmap[E_Lpop]     := "E_Lpop"
  276.       symmap[E_Lpull]    := "E_Lpull"
  277.       symmap[E_Lpush]    := "E_Lpush"
  278.       symmap[E_Lput]     := "E_Lput"
  279.       symmap[E_Lrand]    := "E_Lrand"
  280.       symmap[E_Lref]     := "E_Lref"
  281.       symmap[E_Lrgint]   := "E_Lrgint"
  282.       symmap[E_Lsub]     := "E_Lsub"
  283.       symmap[E_Lsusp]    := "E_Lsusp"
  284.       symmap[E_Nconv]    := "E_Nconv"
  285.       symmap[E_NewRegion]:= "E_NewRegion"
  286.       symmap[E_Null]     := "E_Null"
  287.       symmap[E_Ocall]    := "E_Ocall"
  288.       symmap[E_Ofail]    := "E_Ofail"
  289.       symmap[E_Op]       := "E_Op"
  290.       symmap[E_Opcode]   := "E_Opcode"
  291.       symmap[E_Oresum]   := "E_Oresum"
  292.       symmap[E_Oret]     := "E_Oret"
  293.       symmap[E_Osusp]    := "E_Osusp"
  294.       symmap[E_Orem]     := "E_Orem"
  295.       symmap[E_Pcall]    := "E_Pcall"
  296.       symmap[E_Pfail]    := "E_Pfail"
  297.       symmap[E_Pfp]      := "E_Pfp"
  298.       symmap[E_Presum]   := "E_Presum"
  299.       symmap[E_Pret]     := "E_Pret"
  300.       symmap[E_Proc]     := "E_Proc"
  301.       symmap[E_Psusp]    := "E_Psusp"
  302.       symmap[E_Prem]     := "E_Prem"
  303.       symmap[E_Rbang]    := "E_Rbang"
  304.       symmap[E_Rcreate]  := "E_Rcreate"
  305.       symmap[E_Real]     := "E_Real"
  306.       symmap[E_Record]   := "E_Record"
  307.       symmap[E_Refresh]  := "E_Refresh"
  308.       symmap[E_Rrand]    := "E_Rrand"
  309.       symmap[E_Rref]     := "E_Rref"
  310.       symmap[E_Rsub]     := "E_Rsub"
  311.       symmap[E_Sbang]    := "E_Sbang"
  312.       symmap[E_Sconv]    := "E_Sconv"
  313.       symmap[E_Screate]  := "E_Screate"
  314.       symmap[E_Sdelete]  := "E_Sdelete"
  315.       symmap[E_Selem]    := "E_Selem"
  316.       symmap[E_Set]      := "E_Set"
  317.       symmap[E_Sfail]    := "E_Sfail"
  318.       symmap[E_Sinsert]  := "E_Sinsert"
  319.       symmap[E_Slots]    := "E_Slots"
  320.       symmap[E_Smember]  := "E_Smember"
  321.       symmap[E_Snew]     := "E_Snew"
  322.       symmap[E_Spos]     := "E_Spos"
  323.       symmap[E_Srand]    := "E_Srand"
  324.       symmap[E_Sresum]   := "E_Sresum"
  325.       symmap[E_Ssasgn]   := "E_Ssasgn"
  326.       symmap[E_Ssusp]    := "E_Ssusp"
  327.       symmap[E_Stack]    := "E_Stack"
  328.       symmap[E_StrDeAlc] := "E_StrDeAlc"
  329.       symmap[E_String]   := "E_String"
  330.       symmap[E_Sval]     := "E_Sval"
  331.       symmap[E_Srem]     := "E_Srem"
  332.       symmap[E_Table]    := "E_Table"
  333.       symmap[E_Tbang]    := "E_Tbang"
  334.       symmap[E_Tconv]    := "E_Tconv"
  335.       symmap[E_Tcreate]  := "E_Tcreate"
  336.       symmap[E_Tdelete]  := "E_Tdelete"
  337.       symmap[E_Telem]    := "E_Telem"
  338.       symmap[E_Tick]     := "E_Tick"
  339.       symmap[E_Tinsert]  := "E_Tinsert"
  340.       symmap[E_Tkey]     := "E_Tkey"
  341.       symmap[E_Tmember]  := "E_Tmember"
  342.       symmap[E_Trand]    := "E_Trand"
  343.       symmap[E_Tref]     := "E_Tref"
  344.       symmap[E_Tsub]     := "E_Tsub"
  345.       symmap[E_Tval]     := "E_Tval"
  346.       symmap[E_Tvsubs]   := "E_Tvsubs"
  347.       symmap[E_Tvtbl]    := "E_Tvtbl"
  348.       symmap[E_Value]    := "E_Value"
  349.    
  350.       twt(symmap)
  351.       }
  352.  
  353.    result := symmap[s]
  354.    /result := "E_\\" || exbase10(find(s, &cset), 8)
  355.  
  356.    return result
  357.  
  358. end
  359.  
  360. procedure allocode(s)
  361.    static allocmap
  362.  
  363.    initial {
  364.       allocmap   := table("unknown code")
  365.  
  366.       allocmap[E_Coexpr] :=    "co-expression"
  367.       allocmap[E_Cset] :=    "cset"
  368.       allocmap[E_File] :=    "file"
  369.       allocmap[E_List] :=    "list"
  370.       allocmap[E_Real] :=    "real"
  371.       allocmap[E_Record] :=    "record"
  372.       allocmap[E_Set] :=    "set"
  373.       allocmap[E_String] :=    "string"
  374.       allocmap[E_Table] :=    "table"
  375.  
  376.       twt(allocmap)
  377.       }
  378.  
  379.    return allocmap[s]
  380.  
  381. end
  382.  
  383. #  Turn off output in SP.
  384.  
  385. procedure kill_output()
  386.  
  387.    variable("write", EventSource) := -1
  388.    variable("writes", EventSource) := -1
  389.  
  390.    return
  391.  
  392. end
  393.  
  394. ############################################################################
  395. #
  396. #  opname() maps a virtual-machine instruction number to a symbolic name.
  397. #
  398. ############################################################################
  399.  
  400. procedure opname(i)        #: map virtual-machine code to name
  401.    static opmap
  402.  
  403.    initial {
  404.       opmap := table("")
  405.  
  406.       opmap[1] := "Asgn"
  407.       opmap[2] := "Bang"
  408.       opmap[3] := "Cat"
  409.       opmap[4] := "Compl"
  410.       opmap[5] := "Diff"
  411.       opmap[6] := "Div"
  412.       opmap[7] := "Eqv"
  413.       opmap[8] := "Inter"
  414.       opmap[9] := "Lconcat"
  415.       opmap[10] := "Lexeq"
  416.       opmap[11] := "Lexge"
  417.       opmap[12] := "Lexgt"
  418.       opmap[13] := "Lexle"
  419.       opmap[14] := "Lexlt"
  420.       opmap[15] := "Lexne"
  421.       opmap[16] := "Minus"
  422.       opmap[17] := "Mod"
  423.       opmap[18] := "Mult"
  424.       opmap[19] := "Neg"
  425.       opmap[20] := "Neqv"
  426.       opmap[21] := "Nonnull"
  427.       opmap[22] := "Null"
  428.       opmap[23] := "Number"
  429.       opmap[24] := "Numeq"
  430.       opmap[25] := "Numge"
  431.       opmap[26] := "Numgt"
  432.       opmap[27] := "Numle"
  433.       opmap[28] := "Numlt"
  434.       opmap[29] := "Numne"
  435.       opmap[30] := "Plus"
  436.       opmap[31] := "Power"
  437.       opmap[32] := "Random"
  438.       opmap[33] := "Rasgn"
  439.       opmap[34] := "Refresh"
  440.       opmap[35] := "Rswap"
  441.       opmap[36] := "Sect"
  442.       opmap[37] := "Size"
  443.       opmap[38] := "Subsc"
  444.       opmap[39] := "Swap"
  445.       opmap[40] := "Tabmat"
  446.       opmap[41] := "Toby"
  447.       opmap[42] := "Unions"
  448.       opmap[43] := "Value"
  449.       opmap[44] := "Bscan"
  450.       opmap[45] := "Ccase"
  451.       opmap[46] := "Chfail"
  452.       opmap[47] := "Coact"
  453.       opmap[48] := "Cofail"
  454.       opmap[49] := "Coret"
  455.       opmap[50] := "Create"
  456.       opmap[51] := "Cset"
  457.       opmap[52] := "Dup"
  458.       opmap[53] := "Efail"
  459.       opmap[54] := "Eret"
  460.       opmap[55] := "Escan"
  461.       opmap[56] := "Esusp"
  462.       opmap[57] := "Field"
  463.       opmap[58] := "Goto"
  464.       opmap[59] := "Init"
  465.       opmap[60] := "Int"
  466.       opmap[61] := "Invoke"
  467.       opmap[62] := "Keywd"
  468.       opmap[63] := "Limit"
  469.       opmap[64] := "Line"
  470.       opmap[65] := "Llist"
  471.       opmap[66] := "Lsusp"
  472.       opmap[67] := "Mark"
  473.       opmap[68] := "Pfail"
  474.       opmap[69] := "Pnull"
  475.       opmap[70] := "Pop"
  476.       opmap[71] := "Pret"
  477.       opmap[72] := "Psusp"
  478.       opmap[73] := "Push1"
  479.       opmap[74] := "Pushn1"
  480.       opmap[75] := "Real"
  481.       opmap[76] := "Sdup"
  482.       opmap[77] := "Str"
  483.       opmap[78] := "Unmark"
  484.       opmap[80] := "Var"
  485.       opmap[81] := "Arg"
  486.       opmap[82] := "Static"
  487.       opmap[83] := "Local"
  488.       opmap[84] := "Global"
  489.       opmap[85] := "Mark0"
  490.       opmap[86] := "Quit"
  491.       opmap[87] := "FQuit"
  492.       opmap[88] := "Tally"
  493.       opmap[89] := "Apply"
  494.       opmap[90] := "Acset"
  495.       opmap[91] := "Areal"
  496.       opmap[92] := "Astr"
  497.       opmap[93] := "Aglobal"
  498.       opmap[94] := "Astatic"
  499.       opmap[95] := "Agoto"
  500.       opmap[96] := "Amark"
  501.       opmap[98] := "Noop"
  502.       opmap[100] := "SymEvents"
  503.       opmap[108] := "Colm"
  504.       }
  505.  
  506.    return opmap[i]
  507.  
  508. end
  509.