libs/iovm/io/Block.io

   1 getSlot("Block") do(
   2
   3         //doc Block asSimpleString Returns a short description of the receiver.
   4         asSimpleString := method(
   5                 if(scope, "block", "method") .. "(" .. argumentNames append("...") join(", ") .. ")"
   6         )
   7
   8         //doc Block asString Returns a full description of the receiver with decompiled code.
   9         asString := method(
  10                 Formatter clone formatBlock(getSlot("self")) buffer
  11         )
  12
  13         print := method(
  14                 writeln
  15                 writeln(asString)
  16         )
  17
  18         println := getSlot("print")
  19
  20         Formatter := Object clone do(
  21                 newSlot("lineNumber", 0)
  22                 newSlot("isLineEmpty", true)
  23                 newSlot("depth", 0)
  24                 newSlot("buffer")
  25
  26                 newSlot("operators")
  27                 newSlot("reverseAssignOperators")
  28
  29                 init := method(
  30                         buffer = Sequence clone
  31                         operators = OperatorTable operators
  32                         reverseAssignOperators = OperatorTable reverseAssignOperators
  33                         reverseAssignOperators atPut("setSlotWithType", ":=")
  34                 )
  35
  36                 appendSeq := method(
  37                         call delegateTo(buffer)
  38                         isLineEmpty = false
  39                 )
  40
  41                 newLine := method(
  42                         buffer appendSeq("\n")
  43                         lineNumber = lineNumber + 1
  44                         isLineEmpty = true
  45                 )
  46
  47                 newLinesTo := method(msg,
  48                         (msg lineNumber - lineNumber) minMax(0, 2) repeat(newLine)
  49                         lineNumber = msg lineNumber
  50                 )
  51
  52                 indent := method(
  53                         depth repeat(appendSeq("    "))
  54                 )
  55
  56                 formatBlock := method(theBlock,
  57                         msg := getSlot("theBlock") message
  58
  59                         if(msg label != CLI commandLineLabel,
  60                                 appendSeq("# " .. msg label .. ":" .. msg lineNumber, "\n")
  61                         )
  62                         appendSeq("method(")
  63                         if(getSlot("theBlock") argumentNames size > 0,
  64                                 getSlot("theBlock") argumentNames foreach(i, name,
  65                                         if(i > 0,
  66                                                 appendSeq(", ")
  67                                         )
  68
  69                                         appendSeq(name)
  70                                 )
  71
  72                                 appendSeq(", ")
  73                         )
  74
  75                         newLine
  76                         lineNumber = msg lineNumber
  77                         formatIndentedMessage(msg)
  78                         newLine
  79                         appendSeq(")")
  80                         self
  81                 )
  82
  83                 formatIndentedMessage := method(msg,
  84                         depth = depth + 1
  85                         formatMessage(msg)
  86                         depth = depth - 1
  87                 )
  88
  89                 formatMessage := method(msg,
  90                         m := msg
  91                         while(m,
  92                                 if(m isEndOfLine,
  93                                         if(lineNumber == m next ?lineNumber,
  94                                                 appendSeq(m name)
  95                                         )
  96                                         m = m next
  97                                         continue
  98                                 )
  99
 100                                 newLinesTo(m)
 101
 102                                 if(isLineEmpty,
 103                                         indent
 104                                 ,
 105                                         if(m != msg,
 106                                                 appendSeq(" ")
 107                                         )
 108                                 )
 109
 110                                 if(reverseAssignOperators hasKey(m name)) then(
 111                                         args := m arguments
 112
 113                                         if(args first cachedResult,
 114                                                 appendSeq(args first cachedResult, " ")
 115
 116                                                 appendSeq(reverseAssignOperators at(m name))
 117
 118                                                 appendSeq(" ")
 119                                                 if(args at(1),
 120                                                         formatMessage(args at(1))
 121                                                 )
 122                                         ,
 123                                                 appendSeq(m name)
 124                                                 if(m argCount > 0,
 125                                                         formatArguments(m)
 126                                                 )
 127                                         )
 128                                 ) elseif(operators hasKey(m name)) then(
 129                                         appendSeq(m name)
 130
 131                                         appendSeq(" ")
 132                                         if(m arguments first,
 133                                                 formatMessage(m arguments first)
 134                                         )
 135                                 ) else(
 136                                         appendSeq(m name)
 137                                         if(m argCount > 0,
 138                                                 formatArguments(m)
 139                                         )
 140                                 )
 141
 142                                 m = m next
 143                         )
 144                 )
 145
 146                 formatArguments := method(msg,
 147                         appendSeq("(")
 148
 149                         startingLineNumber := lineNumber
 150                         msg arguments foreach(i, arg,
 151                                 # Insert separator between arguments
 152                                 if(i > 0,
 153                                         # Still on the same line as the "("
 154                                         if(startingLineNumber == lineNumber,
 155                                                 appendSeq(", ")
 156                                         ,
 157                                                 newLine; indent; appendSeq(","); newLine
 158                                         )
 159                                 )
 160
 161                                 # Format the argument
 162                                 formatIndentedMessage(arg)
 163                         )
 164
 165                         if(startingLineNumber != lineNumber,
 166                                 newLine
 167                                 indent
 168                         )
 169                         appendSeq(")")
 170                 )
 171         )
 172 )