ShProgramNode.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2006 Serious Hack Inc.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#ifndef SHPROGRAMNODE_HPP
#define SHPROGRAMNODE_HPP

#include <list>
#include <map>
#include <utility>
#include <string>
#include "ShDllExport.hpp"
#include "ShRefCount.hpp"
#include "ShTokenizer.hpp"
#include "ShVariableNode.hpp"
#include "ShCtrlGraph.hpp"
#include "ShTextureNode.hpp"
#include "ShChannelNode.hpp"
#include "ShPaletteNode.hpp"
#include "ShMeta.hpp"

namespace SH {

class ShBackendCode;
class ShBackend;

class
SH_DLLEXPORT ShProgramNode : public virtual ShRefCountable, public virtual ShMeta, public virtual ShInfoHolder {
public:
  ShProgramNode(const std::string& target);

  ~ShProgramNode();
  
  void compile(const ShPointer<ShBackend>& backend);
  void compile(const std::string& target, const ShPointer<ShBackend>& backend);

  bool is_compiled() const;
  bool is_compiled(const std::string& target) const;
  bool is_compiled(const std::string& target, const ShPointer<ShBackend>& backend) const;

  std::string describe_interface() const;
  std::string describe_vars() const;
  std::string describe_decls() const;
  std::string describe_bindings();
  std::string describe_bindings(const std::string& target);

  void dump(std::string filename) const;
  
  ShPointer<ShBackendCode> code(); 
  ShPointer<ShBackendCode> code(const ShPointer<ShBackend>& backend);
  ShPointer<ShBackendCode> code(const std::string& target, const ShPointer<ShBackend>& backend);

  void updateUniform(const ShVariableNodePtr& uniform);

  ShTokenizer tokenizer;

  ShPointer<ShCtrlGraph> ctrlGraph;

  void collectDecls();

  void collectVariables();

  bool hasDecl(const ShVariableNodePtr& node) const;

  void addDecl(const ShVariableNodePtr& node, const ShCtrlGraphNodePtr&);
  void addDecl(const ShVariableNodePtr& node);

  typedef std::set<ShVariableNodePtr> VarSet;
  typedef std::list<ShVariableNodePtr> VarList;
  typedef std::list<ShTextureNodePtr> TexList;
  typedef std::list<ShChannelNodePtr> ChannelList;
  typedef std::list<ShPaletteNodePtr> PaletteList;

  VarList::const_iterator begin_inputs() const         { return inputs.begin(); }
  VarList::const_iterator end_inputs() const           { return inputs.end(); }
  VarList::const_iterator begin_outputs() const        { return outputs.begin(); }
  VarList::const_iterator end_outputs() const          { return outputs.end(); }
  VarList::const_iterator begin_temps() const          { return temps.begin(); }
  VarList::const_iterator end_temps() const            { return temps.end(); }
  VarList::const_iterator begin_constants() const      { return constants.begin(); }
  VarList::const_iterator end_constants() const        { return constants.end(); }
  VarList::const_iterator begin_parameters() const     { return uniforms.begin(); }
  VarList::const_iterator end_parameters() const       { return uniforms.end(); }
  VarList::const_iterator begin_all_parameters() const { return all_uniforms.begin(); }
  VarList::const_iterator end_all_parameters() const   { return all_uniforms.end(); }
  TexList::const_iterator begin_textures() const       { return textures.begin(); }
  TexList::const_iterator end_textures() const         { return textures.end(); }
  ChannelList::const_iterator begin_channels() const   { return channels.begin(); }
  ChannelList::const_iterator end_channels() const     { return channels.end(); }
  PaletteList::const_iterator begin_palettes() const   { return palettes.begin(); }
  PaletteList::const_iterator end_palettes() const     { return palettes.end(); }
  
  VarList inputs; 
  VarList outputs; 
  VarList temps; 
  VarSet tempDecls; 
  VarList constants; 
  VarList uniforms; 
  VarList all_uniforms; 
  TexList textures; 
  ChannelList channels; 
  PaletteList palettes; 

  std::string backend_name() const { return m_backend_name; }

  std::string target() const { return m_target; }

  std::string& target() { return m_target; }

  ShPointer<ShProgramNode> clone() const;

  static std::ostream& print(std::ostream& out, const VarList& list);

  bool finished() const { return m_finished; }

  void finish();

  void assign(const ShVariableNodePtr& var) const { m_assigned_var = var; }
  
private:
  std::string m_backend_name; 
  std::string m_target; 

  void collect_node_decls(const ShPointer<ShCtrlGraphNode>& node);
  void collect_node_vars(const ShPointer<ShCtrlGraphNode>& node);
  void collect_var(const ShVariableNodePtr& node);
  void collect_dependent_uniform(const ShVariableNodePtr& var);

  typedef std::map< std::pair< std::string, ShPointer<ShBackend> >,
                    ShPointer<ShBackendCode> > CodeMap;
  CodeMap m_code; 

  bool m_finished; 


  mutable ShVariableNodePtr m_assigned_var;
};

typedef ShPointer<ShProgramNode> ShProgramNodePtr;
typedef ShPointer<const ShProgramNode> ShProgramNodeCPtr;

}

#endif

---