item.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <llvm/ADT/ilist_node.h>
#include <llvm/ADT/ilist.h>
#include <llvm/ADT/StringRef.h>
 
#include "core/use.h"
 
class Item;
class Expr;
class Atom;
 
 
 
template <> struct llvm::ilist_traits<Item> {
private:
  using instr_iterator = simple_ilist<Item>::iterator;
 
public:
  void deleteNode(Item *inst);
  void addNodeToList(Item *inst);
  void removeNodeFromList(Item *inst);
  void transferNodesFromList(
      ilist_traits &from,
      instr_iterator first,
      instr_iterator last
  );
 
  Atom *getParent();
};
 
class Item final : public llvm::ilist_node_with_parent<Item, Atom> {
public:
  enum class Kind : uint8_t {
    INT8,
    INT16,
    INT32,
    INT64,
    FLOAT64,
    EXPR32,
    EXPR64,
    SPACE,
    STRING
  };
 
public:
  Item(Item &that);
  ~Item();
 
  // Helpers to create items.
  static Item *CreateInt8(int8_t val);
  static Item *CreateInt16(int16_t val);
  static Item *CreateInt32(int32_t val);
  static Item *CreateInt64(int64_t val);
  static Item *CreateFloat64(double val);
  static Item *CreateSpace(unsigned val);
  static Item *CreateExpr32(Expr *val);
  static Item *CreateExpr64(Expr *val);
  static Item *CreateString(const std::string_view str);
 
  void removeFromParent();
  void eraseFromParent();
 
  Atom *getParent() const { return parent_; }
 
  Kind GetKind() const { return kind_; }
 
  bool IsExpr() const
  {
    return kind_ == Kind::EXPR32 || kind_ == Kind::EXPR64;
  }
 
  bool IsSpace() const { return GetKind() == Item::Kind::SPACE; }
 
  size_t GetSize() const;
 
  // Returns integer values.
  int8_t GetInt8() const  { assert(kind_ == Kind::INT8);  return int8val_;  }
  int16_t GetInt16() const { assert(kind_ == Kind::INT16); return int16val_; }
  int32_t GetInt32() const { assert(kind_ == Kind::INT32); return int32val_; }
  int64_t GetInt64() const { assert(kind_ == Kind::INT64); return int64val_; }
  unsigned GetSpace() const { assert(IsSpace()); return int32val_; }
 
  // Returns the real values.
  double GetFloat64() const
  {
    assert(kind_ == Kind::FLOAT64);
    return float64val_;
  }
 
  llvm::StringRef getString() const
  {
    assert(kind_ == Kind::STRING);
    return stringVal_;
  }
 
  std::string_view GetString() const
  {
    assert(kind_ == Kind::STRING);
    return stringVal_;
  }
 
  Expr *GetExpr();
  const Expr *GetExpr() const;
  Expr *AsExpr();
  const Expr *AsExpr() const;
 
private:
  Item(Kind kind) : kind_(kind), parent_(nullptr) {}
 
private:
  friend struct llvm::ilist_traits<Item>;
 
  void setParent(Atom *parent) { parent_ = parent; }
 
private:
  Kind kind_;
  Atom *parent_;
  union {
    int8_t        int8val_;
    int16_t       int16val_;
    int32_t       int32val_;
    int64_t       int64val_;
    double        float64val_;
    Use           useVal_;
    std::string   stringVal_;
  };
};