attribute_mapper_ast.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2021 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef ATTRIBUTE_MAPPER_AST_HPP
#define ATTRIBUTE_MAPPER_AST_HPP
 
#include <vector>
#include <list>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/spirit/include/qi_optional.hpp>
 
using result_type_t = float;
 
namespace ast
{
namespace x3 = boost::spirit::x3;
 
struct nil {};
struct signed_;
struct expression;
struct condition;
struct attribute;
struct attribute_path_subscript;
struct assignment;
struct function_invokation;
struct scope;
 
using ast_node = boost::variant<ast::scope>;
struct ast_tree : public std::vector<ast_node> {};
 
enum operator_ids {
  operator_plus,
  operator_minus,
  operator_equals,
  operator_mult,
  operator_div,
  operator_bitand,
  operator_bitor,
  operator_bitxor,
  operator_less_than,
  operator_greater_than,
  operator_or,
  operator_modulo,
  operator_exponent,
  operator_neq,
  operator_less_than_or_eq,
  operator_greater_than_or_eq,
};
 
using operand = x3::variant<ast::nil,
                            uint32_t,
                            float,
                            x3::forward_ast<attribute>,
                            x3::forward_ast<signed_>,
                            x3::forward_ast<expression>,
                            x3::forward_ast<condition>,
                            x3::forward_ast<function_invokation>>;
using attribute_path_element
  = boost::variant<ast::nil, ast::operand, uint32_t, attribute_path_subscript>;
 
struct signed_ {
  char sign;
  operand operand_;
};
 
struct operation {
  operator_ids operator_;  
  operand operand_;        
};
 
struct expression {
  operand first;
  std::list<operation> rest;  
};
 
struct condition {
  operand cond_value;  
  operand cond_true;   
  operand cond_false;  
};
 
struct attribute_path_subscript {
  operand identifier;
  operand index;
};
 
struct attribute {
  char value_type;
  std::vector<attribute_path_element> attribute_path;
};
 
struct assignment {
  // Type of assignment.
  // 0 - regular assignment
  // 1 - instance assignment
  // 2 - clearance assignment
  int type;
  ast::attribute lhs;  
  expression rhs;      
};
 
enum AssignmentType { REGULAR, INSTANCE, CLEARANCE };
 
struct function_invokation {
  std::string function_name;          // Function name to invoke.
  std::vector<expression> arguments;  // Arguments for the function
};
 
struct scope_setting {
  std::string setting_name;
  boost::optional<unsigned int> setting_value;
};
 
using scope_settings_t = std::vector<scope_setting>;
 
struct scope {
  int priority;
  scope_settings_t settings;
  std::vector<assignment> assignments;
};
 
bool operator==(const nil &a, const nil &b);
bool operator==(const operand &a, const operand &b);
bool operator==(const signed_ &a, const signed_ &b);
bool operator==(const operation &a, const operation &b);
bool operator==(const expression &a, const expression &b);
bool operator==(const condition &a, const condition &b);
bool operator==(const attribute &a, const attribute &b);
bool operator==(const attribute_path_subscript &a,
                const attribute_path_subscript &b);
bool operator==(const assignment &a, const assignment &b);
bool operator==(const scope_setting &a, const scope_setting &b);
bool operator==(const function_invokation &a, const function_invokation &b);
 
}  // namespace ast
 
BOOST_FUSION_ADAPT_STRUCT(ast::signed_, sign, operand_)
BOOST_FUSION_ADAPT_STRUCT(ast::operation, operator_, operand_)
BOOST_FUSION_ADAPT_STRUCT(ast::expression, first, rest)
BOOST_FUSION_ADAPT_STRUCT(ast::assignment, type, lhs, rhs)
BOOST_FUSION_ADAPT_STRUCT(ast::condition, cond_value, cond_true, cond_false)
BOOST_FUSION_ADAPT_STRUCT(ast::attribute, value_type, attribute_path)
BOOST_FUSION_ADAPT_STRUCT(ast::attribute_path_subscript, identifier, index)
BOOST_FUSION_ADAPT_STRUCT(ast::function_invokation, function_name, arguments)
BOOST_FUSION_ADAPT_STRUCT(ast::scope_setting,
                          (std::string, setting_name),
                          (boost::optional<unsigned int>, setting_value))
BOOST_FUSION_ADAPT_STRUCT(ast::scope, priority, settings, assignments)
 
#endif  //ATTRIBUTE_MAPPER_AST_HPP