nimbus-eth1/nimbus/vm2/interpreter/op_handlers/oph_defs.nim

# Nimbus
# Copyright (c) 2018 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
#    http://www.apache.org/licenses/LICENSE-2.0)
#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or
#    http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except
# according to those terms.

## EVM Opcodes, Definitions
## ========================
##

# Including types.nim needed unless included (not imported) into
# oph_kludge.nim
#
# Note that the nim compiler will distinguish <Vm2Ctx> tuples defined
# here when imported and from oph_kludge.nim. This is so due to the
# duplicate/different Computation definitions.
#
when not declared(Computation):
  import
    ../../types

import
  ../forks_list,
  ../op_codes,
  eth/common/eth_types

type
  Vm2Ctx* = tuple
    cpt: Computation          ## computation text
    rc: int                   ## return code from op handler

  Vm2OpFn* =                  ## general op handler, return codes are passed
                              ## back via argument descriptor ``k``
    proc(k: var Vm2Ctx) {.gcsafe.}


  Vm2OpHanders* = tuple       ## three step op code execution, typically
                              ## only the ``run`` entry is activated
    prep: Vm2OpFn
    run:  Vm2OpFn
    post: Vm2OpFn


  Vm2OpExec* = tuple          ## op code handler entry
    opCode: Op                ## index back-reference
    forks: set[Fork]          ## forks applicable for this operation
    name: string              ## handler name
    info: string              ## handter info, explainer
    exec: Vm2OpHanders

# ------------------------------------------------------------------------------
# Public
# ------------------------------------------------------------------------------

const
  vm2OpIgnore*: Vm2OpFn =      ## No operation, placeholder function
    proc(k: var Vm2Ctx) = discard

  # similar to: toSeq(Fork).mapIt({it}).foldl(a+b)
  Vm2OpAllForks* =
    {Fork.low .. Fork.high}

  Vm2OpHomesteadAndLater* =    ## Set of all fork symbols
    Vm2OpAllForks - {FkFrontier}

  Vm2OpTangerineAndLater* =    ## Set of fork symbols starting from Homestead
    Vm2OpHomesteadAndLater - {FkHomestead}

  Vm2OpSpuriousAndLater* =     ## ditto ...
    Vm2OpTangerineAndLater - {FkTangerine}

  Vm2OpByzantiumAndLater* =
    Vm2OpSpuriousAndLater - {FkSpurious}

  Vm2OpConstantinopleAndLater* =
    Vm2OpByzantiumAndLater - {FkByzantium}

  Vm2OpPetersburgAndLater* =
    Vm2OpConstantinopleAndLater - {FkConstantinople}

  Vm2OpIstanbulAndLater* =
    Vm2OpPetersburgAndLater - {FkPetersburg}

  Vm2OpBerlinAndLater* =
    Vm2OpIstanbulAndLater - {FkIstanbul}

# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------