CInstr = object
  case op*: COpcode
  of opJump, opErrJump, opLabel, opDispJump:
      label*: CLabel

  of opSetTarget, opDispatcher:
      discr*: uint32         ## ID of the discriminator variable
      value*: int            ## either the value, or number of dispatcher branches
    
  of opStmts:
      stmts*: Slice[int]

  of opStmt:
      stmt*: int
      specifier*: CLabelSpecifier

  of opBackup, opRestore, opAbort:
      local*: uint32         ## ID of the backup variable
    
  of opPopHandler:
      nil

  

CLabel = tuple[id: CLabelId, specifier: Option[CLabelSpecifier]]

CLabelId = distinct uint32

CLabelSpecifier = uint32

COpcode = enum
  opJump,                   ## unconditional jump
  opErrJump,                ## jump if in error mode
  opDispJump,               ## jump part of a dispatcher
  opLabel,                  ## jump target
  opSetTarget,              ## set the value of a dispatcher's discriminator
  opDispatcher,             ## start of a dispatcher
  opBackup,                 ## backup the error state in a local variable and clear it
  opRestore,                ## restore the error from a local variable
  opStmts,                  ## slice of statements
  opStmt,                   ## control-flow relevant single statement. A label
                             ## specifier is passed along
  opAbort, opPopHandler

FinallyInfo = object
  routes: seq[PathIndex]
  numExits: int              ## number of exits the finally has. Pre-computed for efficiency
  numErr: int                ## number of exceptional jump paths going through this finalizer
  numNormal: int             ## number of non-exception jump paths going through this finalizer
  discriminator: uint32      ## ID of the discriminator variable to use for the dispatcher
  errBackupId: uint32        ## only valid if the finally is entered by exceptional control-flow
  

ExitLabel = 0'u32

ResumeLabel = 0'u32

func `==`(a, b: CLabelId): bool {.borrow, ...raises: [], tags: [].}

func toBlockId(id: CLabelId): BlockId {....raises: [], tags: [].}

func toCLabel(n: CgNode): CLabelId {....raises: [], tags: [].}

func toCLabel(n: CgNode; specifier: Option[CLabelSpecifier]): CLabel {.inline,
    ...raises: [], tags: [].}

proc toInstrList(stmts: CgNode; isFull: bool): seq[CInstr] {....raises: [KeyError],
    tags: [].}