context.h

/*
 *  Copyright (C) 2004-2024 Edward F. Valeev
 *
 *  This file is part of Libint compiler.
 *
 *  Libint compiler is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint compiler is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Libint compiler.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#include <default_params.h>
#include <entity.h>
 
#ifndef _libint2_src_bin_libint_codecontext_h_
#define _libint2_src_bin_libint_codecontext_h_
 
namespace libint2 {
 
class ForLoop;
 
class CodeContext {
 public:
  virtual ~CodeContext() {}
 
  const std::shared_ptr<CompilationParameters>& cparams() const;
 
  void turn_comments(bool on);
  bool comments_on() const;
 
  virtual void reset();
 
  virtual std::string code_prefix() const = 0;
  virtual std::string code_postfix() const = 0;
  virtual std::string copyright() const = 0;
  virtual std::string std_header() const = 0;
  virtual std::string std_function_header() const = 0;
  virtual std::string label_to_name(const std::string& label) const = 0;
  virtual std::string declare(const std::string& type,
                              const std::string& name) const = 0;
  virtual std::string declare_v(const std::string& type,
                                const std::string& name,
                                const std::string& nelem) const = 0;
  virtual std::string decldef(const std::string& type, const std::string& name,
                              const std::string& value) = 0;
  virtual std::string assign(const std::string& name,
                             const std::string& value) = 0;
  virtual std::string accumulate(const std::string& name,
                                 const std::string& value) = 0;
  virtual std::string assign_binary_expr(const std::string& name,
                                         const std::string& left,
                                         const std::string& oper,
                                         const std::string& right) = 0;
  virtual std::string assign_ternary_expr(const std::string& name,
                                          const std::string& arg1,
                                          const std::string& oper1,
                                          const std::string& arg2,
                                          const std::string& oper2,
                                          const std::string& arg3) = 0;
  virtual std::string accumulate_binary_expr(const std::string& name,
                                             const std::string& left,
                                             const std::string& oper,
                                             const std::string& right) = 0;
  virtual std::string accumulate_ternary_expr(const std::string& name,
                                              const std::string& arg1,
                                              const std::string& oper1,
                                              const std::string& arg2,
                                              const std::string& oper2,
                                              const std::string& arg3) = 0;
  virtual std::string stack_address(const DGVertex::Address& a) const = 0;
 
  virtual std::string macro_define(const std::string& name) const = 0;
  virtual std::string macro_define(const std::string& name,
                                   const std::string& value) const = 0;
  virtual std::string macro_if(const std::string& name) const = 0;
  virtual std::string macro_ifdef(const std::string& name) const = 0;
  virtual std::string macro_endif() const = 0;
 
  virtual std::string comment(const std::string& statement) const = 0;
  virtual std::string open_block() const = 0;
  virtual std::string close_block() const = 0;
  virtual std::string end_of_stat() const = 0;
  virtual std::string value_to_pointer(const std::string& val) const = 0;
 
  virtual std::shared_ptr<ForLoop> for_loop(
      std::string& varname, const std::shared_ptr<Entity>& less_than,
      const std::shared_ptr<Entity>& start_at =
          std::shared_ptr<Entity>(new CTimeEntity<int>(0))) const = 0;
 
  template <typename T>
  std::string unique_name() const;
  template <typename T>
  std::string type_name() const;
  virtual std::string inteval_type_name(const std::string& task) const = 0;
  virtual std::string inteval_spec_type_name(const std::string& task) const = 0;
  virtual std::string inteval_gen_type_name() const = 0;
  virtual std::string const_modifier() const = 0;
  virtual std::string mutable_modifier() const = 0;
 
 protected:
  CodeContext(const std::shared_ptr<CompilationParameters>& cparams);
  virtual std::string unique_fp_name() const = 0;
  virtual std::string unique_int_name() const = 0;
 
  unsigned int next_fp_index() const;
  unsigned int next_int_index() const;
  static std::string replace_chars(const std::string& S,
                                   const std::string& From,
                                   const std::string& To);
 
  virtual std::string void_type() const = 0;
  virtual std::string int_type() const = 0;
  virtual std::string size_type() const = 0;
  virtual std::string fp_type() const = 0;
  virtual std::string ptr_fp_type() const = 0;
 
 private:
  std::shared_ptr<CompilationParameters> cparams_;
  mutable unsigned int next_index_[EntityTypes::ntypes];
  void zero_out_counters() const;
  bool comments_on_;
};
 
class CppCodeContext : public CodeContext,
                       public std::enable_shared_from_this<CppCodeContext> {
 public:
  CppCodeContext(const std::shared_ptr<CompilationParameters>& cparams,
                 bool vectorize = false);
  virtual ~CppCodeContext();
 
  std::string code_prefix() const override;
  std::string code_postfix() const override;
  std::string copyright() const override;
  std::string std_header() const override;
  std::string std_function_header() const override;
  std::string label_to_name(const std::string& label) const override;
  std::string declare(const std::string& type,
                      const std::string& name) const override;
  std::string declare_v(const std::string& type, const std::string& name,
                        const std::string& nelem) const override;
  // Implementation of CodeContext::decldef()
  std::string decldef(const std::string& type, const std::string& name,
                      const std::string& value) override;
  std::string assign(const std::string& name,
                     const std::string& value) override;
  std::string accumulate(const std::string& name,
                         const std::string& value) override;
  std::string assign_binary_expr(const std::string& name,
                                 const std::string& left,
                                 const std::string& oper,
                                 const std::string& right) override;
  // Implementation of CodeContext::assign_ternary_expr()
  std::string assign_ternary_expr(const std::string& name,
                                  const std::string& arg1,
                                  const std::string& oper1,
                                  const std::string& arg2,
                                  const std::string& oper2,
                                  const std::string& arg3) override;
  std::string accumulate_binary_expr(const std::string& name,
                                     const std::string& left,
                                     const std::string& oper,
                                     const std::string& right) override;
  // Implementation of CodeContext::accumulate_ternary_expr()
  std::string accumulate_ternary_expr(const std::string& name,
                                      const std::string& arg1,
                                      const std::string& oper1,
                                      const std::string& arg2,
                                      const std::string& oper2,
                                      const std::string& arg3) override;
  std::string stack_address(const DGVertex::Address& a) const override;
 
  std::string macro_define(const std::string& name) const override;
  std::string macro_define(const std::string& name,
                           const std::string& value) const override;
  std::string macro_if(const std::string& name) const override;
  std::string macro_ifdef(const std::string& name) const override;
  std::string macro_endif() const override;
 
  std::string comment(const std::string& statement) const override;
  std::string open_block() const override;
  std::string close_block() const override;
  std::string end_of_stat() const override;
  std::string value_to_pointer(const std::string& val) const override;
  std::shared_ptr<ForLoop> for_loop(
      std::string& varname, const std::shared_ptr<Entity>& less_than,
      const std::shared_ptr<Entity>& start_at) const override;
 
  std::string inteval_type_name(const std::string& task) const override;
  std::string inteval_spec_type_name(const std::string& task) const override;
  std::string inteval_gen_type_name() const override;
 
 private:
  bool vectorize_;
 
  std::string unique_fp_name() const override;
  std::string unique_int_name() const override;
  std::string symbol_to_pointer(const std::string& symbol);
 
  std::string void_type() const override;
  std::string int_type() const override;
  std::string size_type() const override;
  std::string fp_type() const override;
  std::string ptr_fp_type() const override;
  std::string const_modifier() const override;
  std::string mutable_modifier() const override;
 
  std::string start_expr() const;
  std::string end_expr() const;
 
  std::string assign_(const std::string& name, const std::string& value,
                      bool accum);
  std::string assign_binary_expr_(const std::string& name,
                                  const std::string& left,
                                  const std::string& oper,
                                  const std::string& right, bool accum);
  std::string assign_ternary_expr_(const std::string& name,
                                   const std::string& arg1,
                                   const std::string& oper1,
                                   const std::string& arg2,
                                   const std::string& oper2,
                                   const std::string& arg3, bool accum);
};
 
};  // namespace libint2
 
#endif