Class: Idl::BinaryExpressionAst

Inherits:

AstNode

• Object
• AstNode
• Idl::BinaryExpressionAst

Defined in:

lib/udb/idl/condition_to_udb.rb

Constant Summary

OP_TO_KEY =

{
  "==" => "equal",
  "!=" => "notEqual",
  ">" => "greaterThan",
  "<" => "lessThan",
  ">=" => "greaterThanOrEqual",
  "<=" => "lessThanOrEqual"
}

Instance Method Summary

• #to_udb_h(symtab) ⇒ UdbHashType

Instance Method Details

#to_udb_h(symtab) ⇒ UdbHashType

Parameters:

• symtab (Idl::SymbolTable)

Returns:

• (UdbHashType)

# File 'lib/udb/idl/condition_to_udb.rb', line 201

def to_udb_h(symtab)
  case @op
  when "&&"
    {
      "allOf" => [
        lhs.to_udb_h(symtab),
        rhs.to_udb_h(symtab)
      ]
    }
  when "||"
    {
      "anyOf" => [
        lhs.to_udb_h(symtab),
        rhs.to_udb_h(symtab)
      ]
    }
  when "==", "!=", "<", ">", "<=", ">="
    if lhs.is_a?(IdAst)
      value_result = value_try do
        return {
          "param" => {
            "name" => lhs.name,
            OP_TO_KEY.fetch(@op) => rhs.value(symtab)
          }
        }
      end
      value_else(value_result) do
        raise <<~MSG
          Comparison value (#{rhs.text_value}) must be compile-time evaluatable in #{text_value}
            While evaluating value of #{AstNode.value_error_ast.text_value}:
              '#{AstNode.value_error_reason}'
        MSG
      end
    elsif lhs.is_a?(AryElementAccessAst)
      raise "#{lhs.var.text_value} is not a parameter" unless lhs.var.is_a?(IdAst)

      index_value = T.let(nil, T.nilable(Integer))
      value_result = value_try do
        index_value = lhs.index.value(symtab)
      end
      value_else(value_result) do
        raise "Array index value (#{lhs.index.text_value}) must be known at compile time in #{text_value}"
      end

      value_result = value_try do
        return {
          "param" => {
            "name" => lhs.var.name,
            OP_TO_KEY.fetch(@op) => rhs.value(symtab),
            "index" => T.must(index_value)
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value (#{rhs.text_value}) must be compile-time evaluatable in #{text_value}"
      end
    elsif lhs.is_a?(AryRangeAccessAst)
      raise "#{lhs.var.text_value} is not a parameter" unless lhs.var.is_a?(IdAst)

      value_result = value_try do
        return {
          "param" => {
            "name" => lhs.var.name,
            "range" => "#{lhs.msb.value(symtab)}-#{lhs.lsb.value(symtab)}",
            OP_TO_KEY.fetch(@op) => rhs.value(symtab)
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value, msb, and lsb must all be compile-time evaluatable in #{text_value}"
      end

    elsif lhs.is_a?(ArraySizeAst)
      raise "#{lhs.expression.text_value} is not a parameter" unless lhs.expression.is_a?(IdAst)

      value_result = value_try do
        return {
          "param" => {
            "name" => lhs.expression.name,
            OP_TO_KEY.fetch(@op) => rhs.value(symtab),
            "size" => true
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value (#{rhs.text_value}) must be compile-time evaluatable in #{text_value}"
      end
    elsif rhs.is_a?(IdAst)
      value_result = value_try do
        return {
          "param" => {
            "name" => rhs.name,
            OP_TO_KEY.fetch(@op) => lhs.value(symtab)
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value (#{lhs.text_value}) must be compile-time evaluatable in #{text_value}"
      end
    elsif rhs.is_a?(AryElementAccessAst)
      raise "#{rhs.var.text_value} is not a parameter" unless rhs.var.is_a?(IdAst)

      index_value = T.let(nil, T.nilable(Integer))
      value_result = value_try do
        index_value = rhs.index.value(symtab)
      end
      value_else(value_result) do
        raise "Array index value (#{rhs.index.text_value}) must be known at compile time in #{text_value}"
      end

      value_result = value_try do
        return {
          "param" => {
            "name" => rhs.name,
            OP_TO_KEY.fetch(@op) => lhs.value(symtab),
            "index" => T.must(index_value)
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value (#{lhs.text_value}) must be compile-time evaluatable in #{text_value}"
      end
    elsif rhs.is_a?(AryRangeAccessAst)
      raise "#{rhs.var.text_value} is not a parameter" unless rhs.var.is_a?(IdAst)

      value_result = value_try do
        return {
          "param" => {
            "name" => rhs.var.name,
            "range" => "#{rhs.msb.value(symtab)}-#{rhs.lsb.value(symtab)}",
            OP_TO_KEY.fetch(@op) => lhs.value(symtab)
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value, msb, and lsb must all be compile-time evaluatable in #{text_value}"
      end

    elsif rhs.is_a?(ArraySizeAst)
      raise "#{rhs.expression.text_value} is not a parameter" unless rhs.expression.is_a?(IdAst)

      value_result = value_try do
        return {
          "param" => {
            "name" => rhs.expression.name,
            OP_TO_KEY.fetch(@op) => lhs.value(symtab),
            "size" => true
          }
        }
      end
      value_else(value_result) do
        raise "Comparison value (#{lhs.text_value}) must be compile-time evaluatable in #{text_value}"
      end
    elsif lhs.is_a?(FunctionCallExpressionAst)
      if lhs.name == "xlen"
        if @op == "=="
          return { "xlen" => rhs.value(symtab) }
        elsif @op == "!="
          return { "not": { "xlen" => rhs.value(symtab) } }
        else
          raise "'#{text_value}' can not be converted to UDB YAML"
        end
      else
        raise "'#{text_value}' can not be converted to UDB YAML"
      end
    elsif rhs.is_a?(FunctionCallExpressionAst)
      if rhs.name == "xlen"
        if @op == "=="
          return { "xlen" => lhs.value(symtab) }
        elsif @op == "!="
          return { "not": { "xlen" => lhs.value(symtab) } }
        else
          raise "'#{text_value}' can not be converted to UDB YAML"
        end
      else
        raise "'#{text_value}' can not be converted to UDB YAML"
      end
    else
      raise "'#{text_value}' can not be converted to UDB YAML"
    end
  else
    raise "'#{text_value}` uses an operator (#{@op}) that cannot be converted to UDB YAML"
  end
end