ShProgramNode.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#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);

  std::string describe_interface() const;

  std::string describe_vars() const;

  std::string describe_decls() const;

  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(ShVariableNodePtr node) const;

  // temporaries are added. 
  //
  // The first version adds to a specified cfg node in addition to this.
  // The second adds to this and the entry node.
  //
  // @todo range check that adding to the cfg node doesn't screw anything up...
  // (i.e. if somewhere we don't copy cfg when manipulating program...)
  //
  // @{
  void addDecl(ShVariableNodePtr node, ShCtrlGraphNodePtr);
  void addDecl(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 inputs_begin() const;
  VarList::const_iterator inputs_end() const;
  VarList::const_iterator outputs_begin() const;
  VarList::const_iterator outputs_end() const;
  VarList::const_iterator temps_begin() const;
  VarList::const_iterator temps_end() const;
  VarList::const_iterator constants_begin() const;
  VarList::const_iterator constants_end() const;
  VarList::const_iterator uniforms_begin() const;
  VarList::const_iterator uniforms_end() const;

  TexList::const_iterator textures_begin() const;
  TexList::const_iterator textures_end() const;

  ChannelList::const_iterator channels_begin() const;
  ChannelList::const_iterator channels_end() const;

  PaletteList::const_iterator palettes_begin() const;
  PaletteList::const_iterator palettes_end() const;
  
  
  VarList inputs; 
  VarList outputs; 
  VarList temps; 
  VarSet tempDecls; 
  VarList constants; 
  VarList uniforms; 
  TexList textures; 
  ChannelList channels; 
  PaletteList palettes; 

  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;

  void finish();

  void assign(const ShVariableNodePtr& var) const;
  
private:
  static std::string describe(const VarList &varlist); 
  static std::string describe(const ChannelList &chanlist); 

  std::string m_target; 

  void collectNodeDecls(const ShPointer<ShCtrlGraphNode>& node);

  void collectNodeVars(const ShPointer<ShCtrlGraphNode>& node);
  void collectVar(const ShVariableNodePtr& node);

  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

---