ShSyntax.hpp

Go to the documentation of this file.

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 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 SHSYNTAX_HPP
#define SHSYNTAX_HPP

#include "ShDllExport.hpp"
#include "ShProgram.hpp"
#include "ShUtility.hpp"



#define SH_PUSH_ARG_QUEUE ::SH::shPushArgQueue()
#define SH_PUSH_ARG ::SH::shPushArg()
#define SH_PROCESS_ARG(arg, internal_cond) ::SH::shProcessArg(arg, internal_cond)




#define SH_BEGIN_PROGRAM(target) ::SH::shBeginShader(target);

#define SH_END_PROGRAM         ::SH::shEndShader();


#define SH_END                 SH_END_PROGRAM

#define SH_BEGIN_VERTEX_PROGRAM ::SH::shBeginShader("gpu:vertex");
#define SH_BEGIN_FRAGMENT_PROGRAM ::SH::shBeginShader("gpu:fragment");



#define SH_IF(cond) { \
  bool sh__internal_cond; \
  ::SH::shIf(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, &sh__internal_cond)); \
  if (ShContext::current()->parsing() || sh__internal_cond) {{

#define SH_ELSE  \
  }} \
  ::SH::shElse(); \
  if (ShContext::current()->parsing() || !sh__internal_cond) {{

#define SH_ENDIF \
  }} \
  ::SH::shEndIf(); \
}




#define SH_WHILE(cond) { \
  bool sh__internal_cond; \
  ::SH::shWhile(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, &sh__internal_cond)); \
  bool sh__internal_firsttime = true; \
  while ((sh__internal_firsttime && (ShContext::current()->parsing() || sh__internal_cond)) \
         || (!ShContext::current()->parsing() && ::SH::shEvaluateCondition(cond))) {{{

#define SH_ENDWHILE \
    sh__internal_firsttime = false; \
  }}} \
  ::SH::shEndWhile(); \
}




#define SH_DO       { \
  ::SH::shDo(); \
  do {{{{

#define SH_UNTIL(cond) \
  }}}} while (!ShContext::current()->parsing() && ::SH::shEvaluateCondition(cond)); \
  if (ShContext::current()->parsing()) ::SH::shUntil(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, 0)); }




// TODO: It is possible to make declaring variables in init work. do so.
#define SH_FOR(init,cond,update) { \
  if (ShContext::current()->parsing()) \
    ::SH::shFor(SH_PUSH_ARG_QUEUE \
             && SH_PUSH_ARG && SH_PROCESS_ARG(init, 0) \
             && SH_PUSH_ARG && SH_PROCESS_ARG(cond, 0) \
             && SH_PUSH_ARG && SH_PROCESS_ARG(update, 0)); \
  if (!ShContext::current()->parsing()) init; \
  bool sh__internal_first_time = true; \
  while (1) {{{{{ \
    if (!ShContext::current()->parsing()) { \
      if (!sh__internal_first_time) { update; } \
      else { sh__internal_first_time = false; } \
      if (!shEvaluateCondition(cond)) break; \
    }                                                                                  

#define SH_ENDFOR \
    if (ShContext::current()->parsing()) break; \
  }}}}} \
  ::SH::shEndFor(); \
}




#define SH_BREAK    if (!ShContext::current()->parsing()) { break; } else { ::SH::shBreak(); }

#define SH_CONTINUE if (!ShContext::current()->parsing()) { continue; } else { ::SH::shBreak(); }


#define SH_BEGIN_SECTION(name) \
  {{{{{{ \
    if(ShContext::current()->parsing()) { \
      ::SH::shBeginSection(); \
      ::SH::shComment(name); \
    }

#define SH_END_SECTION \
    if(ShContext::current()->parsing()) { ::SH::shEndSection(); } \
  }}}}}} 




#define SH_NAME(var) do { var.name( # var); } while (0)

#define SH_DECL(var) var; var.name( # var ); ::SH::ShIgnore() & var

#define SH_NAMEDECL(var, varName) var; var.name( varName ); ::SH::ShIgnore() & var


namespace SH {

SH_DLLEXPORT
bool shProcessArg(const ShVariable& arg, bool* internal_cond);

SH_DLLEXPORT
bool shPushArg();

SH_DLLEXPORT
bool shPushArgQueue();

SH_DLLEXPORT
bool shEvaluateCondition(const ShVariable& arg);

SH_DLLEXPORT
ShProgram shBeginShader(const std::string& kind = "");
SH_DLLEXPORT
void shEndShader();

SH_DLLEXPORT
void shCompile(ShProgram& prg);
SH_DLLEXPORT
void shCompile(ShProgram& prg, const std::string& target);

SH_DLLEXPORT
void shCompileShader(ShProgram& prg);
SH_DLLEXPORT
void shCompileShader(ShProgram& prg, const std::string& target);

SH_DLLEXPORT
void shBind(ShProgram& prg);
SH_DLLEXPORT
void shBind(const std::string& target, ShProgram& shader);

SH_DLLEXPORT
void shBindShader(ShProgram& shader);
SH_DLLEXPORT
void shBindShader(const std::string& target, ShProgram& shader);

SH_DLLEXPORT
void shBind(const ShProgramSet& s);

SH_DLLEXPORT
void shUnbind();

SH_DLLEXPORT
void shUnbind(ShProgram& prg);
SH_DLLEXPORT
void shUnbind(const std::string& target, ShProgram& shader);

SH_DLLEXPORT
void shUnbind(const ShProgramSet& s);

SH_DLLEXPORT
void shLink(const ShProgramSet& s);

SH_DLLEXPORT
void shUpdate();

SH_DLLEXPORT
bool shSetBackend(const std::string& name);

SH_DLLEXPORT
bool shUseBackend(const std::string& name);

SH_DLLEXPORT
bool shHaveBackend(const std::string& name);

SH_DLLEXPORT
void shClearBackends();

SH_DLLEXPORT
std::string shFindBackend(const std::string& target);

SH_DLLEXPORT
void shInit();

SH_DLLEXPORT
void shIf(bool);
SH_DLLEXPORT
void shElse();
SH_DLLEXPORT
void shEndIf();

SH_DLLEXPORT
void shWhile(bool);
SH_DLLEXPORT
void shEndWhile();

SH_DLLEXPORT
void shDo();
SH_DLLEXPORT
void shUntil(bool);

SH_DLLEXPORT
void shFor(bool);
SH_DLLEXPORT
void shEndFor();

SH_DLLEXPORT
void shBreak();
SH_DLLEXPORT
void shContinue();

SH_DLLEXPORT
void shBeginSection();
SH_DLLEXPORT
void shEndSection();

SH_DLLEXPORT
void shComment(const std::string& comment);

}

#endif

---