#
#
#           The Nim Compiler
#        (c) Copyright 2012 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# This is the documentation generator. It is currently pretty simple: No
# semantic checking is done for the code. Cross-references are generated
# by knowing how the anchors are going to be named.

import
  ast, strutils, strtabs, options, msgs, os, ropes, idents,
  wordrecg, syntaxes, renderer, lexer, packages/docutils/rstast,
  packages/docutils/rst, packages/docutils/rstgen, times,
  packages/docutils/highlite, sempass2, json, xmltree, cgi,
  typesrenderer, astalgo, modulepaths

type
  TSections = array[TSymKind, Rope]
  TDocumentor = object of rstgen.RstGenerator
    modDesc: Rope           # module description
    toc, section: TSections
    indexValFilename: string
    analytics: string  # Google Analytics javascript, "" if doesn't exist
    seenSymbols: StringTableRef # avoids duplicate symbol generation for HTML.
    jArray: JsonNode
    types: TStrTable
    isPureRst: bool

  PDoc* = ref TDocumentor ## Alias to type less.

proc whichType(d: PDoc; n: PNode): PSym =
  if n.kind == nkSym:
    if d.types.strTableContains(n.sym):
      result = n.sym
  else:
    for i in 0..<safeLen(n):
      let x = whichType(d, n[i])
      if x != nil: return x

proc attachToType(d: PDoc; p: PSym): PSym =
  let params = p.ast.sons[paramsPos]
  # first check the first parameter, then the return type,
  # then the other parameter:
  template check(i) =
    result = whichType(d, params[i])
    if result != nil: return result

  if params.len > 1: check(1)
  if params.len > 0: check(0)
  for i in 2..<params.len: check(i)

proc compilerMsgHandler(filename: string, line, col: int,
                        msgKind: rst.MsgKind, arg: string) {.procvar.} =
  # translate msg kind:
  var k: msgs.TMsgKind
  case msgKind
  of meCannotOpenFile: k = errCannotOpenFile
  of meExpected: k = errXExpected
  of meGridTableNotImplemented: k = errGridTableNotImplemented
  of meNewSectionExpected: k = errNewSectionExpected
  of meGeneralParseError: k = errGeneralParseError
  of meInvalidDirective: k = errInvalidDirectiveX
  of mwRedefinitionOfLabel: k = warnRedefinitionOfLabel
  of mwUnknownSubstitution: k = warnUnknownSubstitutionX
  of mwUnsupportedLanguage: k = warnLanguageXNotSupported
  of mwUnsupportedField: k = warnFieldXNotSupported
  globalError(newLineInfo(filename, line, col), k, arg)

proc docgenFindFile(s: string): string {.procvar.} =
  result = options.findFile(s)
  if result.len == 0:
    result = getCurrentDir() / s
    if not existsFile(result): result = ""

proc parseRst(text, filename: string,
              line, column: int, hasToc: var bool,
              rstOptions: RstParseOptions): PRstNode =
  result = rstParse(text, filename, line, column, hasToc, rstOptions,
                    docgenFindFile, compilerMsgHandler)

proc newDocumentor*(filename: string, config: StringTableRef): PDoc =
  new(result)
  initRstGenerator(result[], (if gCmd != cmdRst2tex: outHtml else: outLatex),
                   options.gConfigVars, filename, {roSupportRawDirective},
                   docgenFindFile, compilerMsgHandler)

  if config.hasKey("doc.googleAnalytics"):
    result.analytics = """
<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

  ga('create', '$1', 'auto');
  ga('send', 'pageview');

</script>
    """ % [config.getOrDefault"doc.googleAnalytics"]
  else:
    result.analytics = ""

  result.seenSymbols = newStringTable(modeCaseInsensitive)
  result.id = 100
  result.jArray = newJArray()
  initStrTable result.types
  result.onTestSnippet = proc (d: var RstGenerator; filename, cmd: string; status: int; content: string) =
    localError(newLineInfo(d.filename, -1, -1), warnUser, "only 'rst2html' supports the ':test:' attribute")

proc dispA(dest: var Rope, xml, tex: string, args: openArray[Rope]) =
  if gCmd != cmdRst2tex: addf(dest, xml, args)
  else: addf(dest, tex, args)

proc getVarIdx(varnames: openArray[string], id: string): int =
  for i in countup(0, high(varnames)):
    if cmpIgnoreStyle(varnames[i], id) == 0:
      return i
  result = -1

proc ropeFormatNamedVars(frmt: FormatStr, varnames: openArray[string],
                         varvalues: openArray[Rope]): Rope =
  var i = 0
  var L = len(frmt)
  result = nil
  var num = 0
  while i < L:
    if frmt[i] == '$':
      inc(i)                  # skip '$'
      case frmt[i]
      of '#':
        add(result, varvalues[num])
        inc(num)
        inc(i)
      of '$':
        add(result, "$")
        inc(i)
      of '0'..'9':
        var j = 0
        while true:
          j = (j * 10) + ord(frmt[i]) - ord('0')
          inc(i)
          if (i > L + 0 - 1) or not (frmt[i] in {'0'..'9'}): break
        if j > high(varvalues) + 1: internalError("ropeFormatNamedVars")
        num = j
        add(result, varvalues[j - 1])
      of 'A'..'Z', 'a'..'z', '\x80'..'\xFF':
        var id = ""
        while true:
          add(id, frmt[i])
          inc(i)
          if not (frmt[i] in {'A'..'Z', '_', 'a'..'z', '\x80'..'\xFF'}): break
        var idx = getVarIdx(varnames, id)
        if idx >= 0: add(result, varvalues[idx])
        else: rawMessage(errUnknownSubstitionVar, id)
      of '{':
        var id = ""
        inc(i)
        while frmt[i] != '}':
          if frmt[i] == '\0': rawMessage(errTokenExpected, "}")
          add(id, frmt[i])
          inc(i)
        inc(i)                # skip }
                              # search for the variable:
        var idx = getVarIdx(varnames, id)
        if idx >= 0: add(result, varvalues[idx])
        else: rawMessage(errUnknownSubstitionVar, id)
      else: internalError("ropeFormatNamedVars")
    var start = i
    while i < L:
      if frmt[i] != '$': inc(i)
      else: break
    if i - 1 >= start: add(result, substr(frmt, start, i - 1))

proc genComment(d: PDoc, n: PNode): string =
  result = ""
  var dummyHasToc: bool
  if n.comment != nil:
    renderRstToOut(d[], parseRst(n.comment, toFilename(n.info),
                               toLinenumber(n.info), toColumn(n.info),
                               dummyHasToc, d.options), result)

proc genRecComment(d: PDoc, n: PNode): Rope =
  if n == nil: return nil
  result = genComment(d, n).rope
  if result == nil:
    if n.kind notin {nkEmpty..nkNilLit, nkEnumTy, nkTupleTy}:
      for i in countup(0, len(n)-1):
        result = genRecComment(d, n.sons[i])
        if result != nil: return
  else:
    n.comment = nil

proc getPlainDocstring(n: PNode): string =
  ## Gets the plain text docstring of a node non destructively.
  ##
  ## You need to call this before genRecComment, whose side effects are removal
  ## of comments from the tree. The proc will recursively scan and return all
  ## the concatenated ``##`` comments of the node.
  result = ""
  if n == nil: return
  if n.comment != nil and startsWith(n.comment, "##"):
    result = n.comment
  if result.len < 1:
    for i in countup(0, safeLen(n)-1):
      result = getPlainDocstring(n.sons[i])
      if result.len > 0: return

proc nodeToHighlightedHtml(d: PDoc; n: PNode; result: var Rope; renderFlags: TRenderFlags = {}) =
  var r: TSrcGen
  var literal = ""
  initTokRender(r, n, renderFlags)
  var kind = tkEof
  while true:
    getNextTok(r, kind, literal)
    case kind
    of tkEof:
      break
    of tkComment:
      dispA(result, "<span class=\"Comment\">$1</span>", "\\spanComment{$1}",
            [rope(esc(d.target, literal))])
    of tokKeywordLow..tokKeywordHigh:
      dispA(result, "<span class=\"Keyword\">$1</span>", "\\spanKeyword{$1}",
            [rope(literal)])
    of tkOpr:
      dispA(result, "<span class=\"Operator\">$1</span>", "\\spanOperator{$1}",
            [rope(esc(d.target, literal))])
    of tkStrLit..tkTripleStrLit:
      dispA(result, "<span class=\"StringLit\">$1</span>",
            "\\spanStringLit{$1}", [rope(esc(d.target, literal))])
    of tkCharLit:
      dispA(result, "<span class=\"CharLit\">$1</span>", "\\spanCharLit{$1}",
            [rope(esc(d.target, literal))])
    of tkIntLit..tkUInt64Lit:
      dispA(result, "<span class=\"DecNumber\">$1</span>",
            "\\spanDecNumber{$1}", [rope(esc(d.target, literal))])
    of tkFloatLit..tkFloat128Lit:
      dispA(result, "<span class=\"FloatNumber\">$1</span>",
            "\\spanFloatNumber{$1}", [rope(esc(d.target, literal))])
    of tkSymbol:
      dispA(result, "<span class=\"Identifier\">$1</span>",
            "\\spanIdentifier{$1}", [rope(esc(d.target, literal))])
    of tkSpaces, tkInvalid:
      add(result, literal)
    of tkCurlyDotLe:
      dispA(result, """<span class="Other pragmabegin">$1</span><div class="pragma">""",
                    "\\spanOther{$1}",
                  [rope(esc(d.target, literal))])
    of tkCurlyDotRi:
      dispA(result, "</div><span class=\"Other pragmaend\">$1</span>",
                    "\\spanOther{$1}",
                  [rope(esc(d.target, literal))])
    of tkParLe, tkParRi, tkBracketLe, tkBracketRi, tkCurlyLe, tkCurlyRi,
       tkBracketDotLe, tkBracketDotRi, tkParDotLe,
       tkParDotRi, tkComma, tkSemiColon, tkColon, tkEquals, tkDot, tkDotDot,
       tkAccent, tkColonColon,
       tkGStrLit, tkGTripleStrLit, tkInfixOpr, tkPrefixOpr, tkPostfixOpr:
      dispA(result, "<span class=\"Other\">$1</span>", "\\spanOther{$1}",
            [rope(esc(d.target, literal))])

proc getAllRunnableExamples(d: PDoc; n: PNode; dest: var Rope) =
  case n.kind
  of nkCallKinds:
    if n[0].kind == nkSym and n[0].sym.magic == mRunnableExamples and
        n.len >= 2 and n.lastSon.kind == nkStmtList:
      dispA(dest, "\n<strong class=\"examples_text\">$1</strong>\n",
          "\n\\textbf{$1}\n", [rope"Examples:"])
      inc d.listingCounter
      let id = $d.listingCounter
      dest.add(d.config.getOrDefault"doc.listing_start" % [id, "langNim"])
      # this is a rather hacky way to get rid of the initial indentation
      # that the renderer currently produces:
      var i = 0
      var body = n.lastSon
      if body.len == 1 and body.kind == nkStmtList and
          body.lastSon.kind == nkStmtList:
        body = body.lastSon
      for b in body:
        if i > 0: dest.add "\n"
        inc i
        nodeToHighlightedHtml(d, b, dest, {})
      dest.add(d.config.getOrDefault"doc.listing_end" % id)
  else: discard
  for i in 0 ..< n.safeLen:
    getAllRunnableExamples(d, n[i], dest)

when false:
  proc findDocComment(n: PNode): PNode =
    if n == nil: return nil
    if not isNil(n.comment) and startsWith(n.comment, "##"): return n
    for i in countup(0, safeLen(n)-1):
      result = findDocComment(n.sons[i])
      if result != nil: return

  proc extractDocComment*(s: PSym, d: PDoc = nil): string =
    let n = findDocComment(s.ast)
    result = ""
    if not n.isNil:
      if not d.isNil:
        var dummyHasToc: bool
        renderRstToOut(d[], parseRst(n.comment, toFilename(n.info),
                                     toLinenumber(n.info), toColumn(n.info),
                                     dummyHasToc, d.options + {roSkipPounds}),
                       result)
      else:
        result = n.comment.substr(2).replace("\n##", "\n").strip

proc isVisible(n: PNode): bool =
  result = false
  if n.kind == nkPostfix:
    if n.len == 2 and n.sons[0].kind == nkIdent:
      var v = n.sons[0].ident
      result = v.id == ord(wStar) or v.id == ord(wMinus)
  elif n.kind == nkSym:
    # we cannot generate code for forwarded symbols here as we have no
    # exception tracking information here. Instead we copy over the comment
    # from the proc header.
    result = {sfExported, sfFromGene { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/*</span>
<span class="cm"> *  CIL opcode definition</span>
<span class="cm"> * </span>
<span class="cm"> *  Copyright (c) 2002 Fabrice Bellard</span>
<span class="cm"> *</span>
<span class="cm"> *  This program is free software; you can redistribute it and/or modify</span>
<span class="cm"> *  it under the terms of the GNU General Public License as published by</span>
<span class="cm"> *  the Free Software Foundation; either version 2 of the License, or</span>
<span class="cm"> *  (at your option) any later version.</span>
<span class="cm"> *</span>
<span class="cm"> *  This program is distributed in the hope that it will be useful,</span>
<span class="cm"> *  but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="cm"> *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="cm"> *  GNU General Public License for more details.</span>
<span class="cm"> *</span>
<span class="cm"> *  You should have received a copy of the GNU General Public License</span>
<span class="cm"> *  along with this program; if not, write to the Free Software</span>
<span class="cm"> *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.</span>
<span class="cm"> */</span>
<span class="n">OP</span><span class="p">(</span><span class="n">NOP</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;nop&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x00</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BREAK</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;break&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x01</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARG_0</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarg.0&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x02</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARG_1</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarg.1&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x03</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARG_2</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarg.2&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x04</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARG_3</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarg.3&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x05</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOC_0</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloc.0&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x06</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOC_1</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloc.1&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x07</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOC_2</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloc.2&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x08</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOC_3</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloc.3&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x09</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STLOC_0</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;stloc.0&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0a</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STLOC_1</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;stloc.1&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0b</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STLOC_2</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;stloc.2&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0c</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STLOC_3</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;stloc.3&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0d</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARG_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarg.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0e</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDARGA_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldarga.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x0f</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STARG_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;starg.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x10</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOC_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloc.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x11</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDLOCA_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldloca.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x12</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">STLOC_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;stloc.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x13</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDNULL</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldnull&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x14</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_M1</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.m1&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x15</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_0</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.0&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x16</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_1</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.1&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x17</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_2</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.2&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x18</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_3</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.3&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x19</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_4</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.4&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1a</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_5</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.5&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1b</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_6</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.6&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1c</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_7</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.7&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1d</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_8</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.8&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1e</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x1f</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I4</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i4&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x20</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_I8</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.i8&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x21</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_R4</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.r4&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x22</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDC_R8</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldc.r8&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x23</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">LDPTR</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ldptr&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x24</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">DUP</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;dup&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x25</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">POP</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;pop&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x26</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">JMP</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;jmp&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x27</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">CALL</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;call&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x28</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">CALLI</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;calli&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x29</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">RET</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ret&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2a</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BR_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;br.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2b</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BRFALSE_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;brfalse.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2c</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BRTRUE_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;brtrue.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2d</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BEQ_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;beq.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2e</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BGE_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;bge.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x2f</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BGT_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;bgt.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x30</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BLE_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ble.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x31</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BLT_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;blt.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x32</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BNE_UN_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;bne.un.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x33</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BGE_UN_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;bge.un.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x34</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BGT_UN_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;bgt.un.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x35</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BLE_UN_S</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;ble.un.s&quot;</span><span class="p">,</span><span class="w"> </span><span class="mh">0x36</span><span class="p">)</span>
<span class="n">OP</span><span class="p">(</span><span class="n">BLT_UN_S</span><span class="p">,</sp