source-engine/utils/shadercompile/cfgprocessor.cpp

1400 lines
36 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include <stdio.h>
#include <io.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <stdarg.h>
#include "tier0/platform.h"
#include "tier0/dbg.h"
#include "tier1/utlbuffer.h"
#include "cfgprocessor.h"
// Type conversions should be controlled by programmer explicitly - shadercompile makes use of 64-bit integer arithmetics
#pragma warning( error : 4244 )
namespace
{
int Usage()
{
printf( "Usage: expparser [OPTIONS] <input.txt 2>>output.txt\n" );
printf( "Options: [none]\n" );
printf( "Input: Sections in a file:\n" );
printf( " #BEGIN\n" );
printf( " #DEFINES:\n" );
printf( " FASTPATH=0..2\n" );
printf( " FOGTYPE=0..5\n" );
printf( " #SKIP:\n" );
printf( " ($FOGTYPE > 1) && (!$FASTPATH)\n" );
printf( " #COMMAND:\n" );
printf( " fxc.exe /DFLAGS=0x00\n" );
printf( " /Foshader.o myshader.fxc > output.txt\n" );
printf( " #END\n" );
printf( "Version: expparser compiled on " __DATE__ " @ " __TIME__ ".\n" );
return -1;
}
};
namespace
{
static bool s_bNoOutput = true;
void OutputF( FILE *f, char const *szFmt, ... )
{
if( s_bNoOutput )
return;
va_list args;
va_start( args, szFmt );
vfprintf( f, szFmt, args );
va_end( args );
}
};
//////////////////////////////////////////////////////////////////////////
//
// Utility classes:
// QuickArray<T>
// QuickStrIdx
// QuickString
// QuickStrUnique
// QuickMap
//
//////////////////////////////////////////////////////////////////////////
#include <unordered_map>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <algorithm>
template < typename T >
class QuickArray : private std::vector < T >
{
public:
void Append( T const &e ) { push_back( e ); };
int Size( void ) const { return ( int ) size(); };
T const & Get( int idx ) const { return at( idx ); };
T & GetForEdit( int idx ) { return at( idx ); }
void Clear( void ) { clear(); }
T const * ArrayBase() const { return empty() ? NULL : &at( 0 ); }
T * ArrayBaseForEdit() { return empty() ? NULL : &at( 0 ); }
};
template < typename T >
class QuickStack : private std::vector < T >
{
public:
void Push( T const &e ) { push_back( e ); };
int Size( void ) const { return ( int ) size(); };
T const & Top( void ) const { return at( Size() - 1 ); };
void Pop( void ) { pop_back(); }
void Clear( void ) { clear(); }
};
template < typename K, typename V >
class QuickMap : private std::map < K, V >
{
public:
void Append( K const &k, V const &v ) { insert( value_type( k, v ) ); };
int Size( void ) const { return ( int ) size(); };
V const & GetLessOrEq( K &k, V const &v ) const;
V const & Get( K const &k, V const &v ) const { const_iterator it = find( k ); return ( it != end() ? it->second : v ); };
V & GetForEdit( K const &k, V &v ) { iterator it = find( k ); return ( it != end() ? it->second : v ); };
void Clear( void ) { clear(); }
};
template < typename K, typename V >
V const & QuickMap< K, V >::GetLessOrEq( K &k, V const &v ) const
{
const_iterator it = lower_bound( k );
if ( end() == it )
{
if ( empty() )
return v;
-- it;
}
if ( k < it->first )
{
if ( begin() == it )
return v;
-- it;
}
k = it->first;
return it->second;
}
class QuickStrIdx : private std::unordered_map < std::string, int >
{
public:
void Append( char const *szName, int idx ) { insert( value_type( szName, idx ) ); };
int Size( void ) const { return ( int ) size(); };
int Get( char const *szName ) const { const_iterator it = find( szName ); if ( end() != it ) return it->second; else return -1; };
void Clear( void ) { clear(); }
};
class QuickStrUnique : private std::set < std::string >
{
public:
int Size( void ) const { return ( int ) size(); }
bool Add( char const *szString ) { return insert( szString ).second; }
void Remove( char const *szString ) { erase( szString ); }
char const * Lookup( char const *szString ) { const_iterator it = find( szString ); if ( end() != it ) return it->data(); else return NULL; }
char const * AddLookup( char const *szString ) { iterator it = insert( szString ).first; if ( end() != it ) return it->data(); else return NULL; }
void Clear( void ) { clear(); }
};
class QuickString : private std::vector< char >
{
public:
explicit QuickString( char const *szValue, size_t len = -1 );
int Size() const { return ( int ) ( size() - 1 ); }
char * Get() { return &at( 0 ); }
};
QuickString::QuickString( char const *szValue, size_t len )
{
if ( size_t( -1 ) == len )
len = ( size_t ) strlen( szValue );
resize( len + 1, 0 );
memcpy( Get(), szValue, len );
}
//////////////////////////////////////////////////////////////////////////
//
// Define class
//
//////////////////////////////////////////////////////////////////////////
class Define
{
public:
explicit Define( char const *szName, int min, int max, bool bStatic ) : m_sName( szName ), m_min( min ), m_max( max ), m_bStatic( bStatic ) {}
public:
char const * Name() const { return m_sName.data(); };
int Min() const { return m_min; };
int Max() const { return m_max; };
bool IsStatic() const { return m_bStatic; }
protected:
std::string m_sName;
int m_min, m_max;
bool m_bStatic;
};
//////////////////////////////////////////////////////////////////////////
//
// Expression parser
//
//////////////////////////////////////////////////////////////////////////
class IEvaluationContext
{
public:
virtual int GetVariableValue( int nSlot ) = 0;
virtual char const * GetVariableName( int nSlot ) = 0;
virtual int GetVariableSlot( char const *szVariableName ) = 0;
};
class IExpression
{
public:
virtual int Evaluate( IEvaluationContext *pCtx ) const = 0;
virtual void Print( IEvaluationContext *pCtx ) const = 0;
};
#define EVAL virtual int Evaluate( IEvaluationContext *pCtx ) const
#define PRNT virtual void Print( IEvaluationContext *pCtx ) const
class CExprConstant : public IExpression
{
public:
CExprConstant( int value ) : m_value( value ) {}
EVAL { pCtx; return m_value; };
PRNT { pCtx; OutputF( stdout, "%d", m_value ); }
public:
int m_value;
};
class CExprVariable : public IExpression
{
public:
CExprVariable( int nSlot ) : m_nSlot( nSlot ) {}
EVAL { return (m_nSlot >= 0) ? pCtx->GetVariableValue( m_nSlot ) : 0; };
PRNT { (m_nSlot >= 0) ? OutputF( stdout, "$%s", pCtx->GetVariableName( m_nSlot ) ) : OutputF( stdout, "$**@**" ); }
public:
int m_nSlot;
};
class CExprUnary : public IExpression
{
public:
CExprUnary( IExpression *x ) : m_x( x ) {}
public:
IExpression *m_x;
};
#define BEGIN_EXPR_UNARY( className ) class className : public CExprUnary { public: className( IExpression *x ) : CExprUnary( x ) {}
#define END_EXPR_UNARY() };
BEGIN_EXPR_UNARY( CExprUnary_Negate )
EVAL { return ! m_x->Evaluate( pCtx ); };
PRNT { OutputF( stdout, "!" ); m_x->Print(pCtx); }
END_EXPR_UNARY()
class CExprBinary : public IExpression
{
public:
CExprBinary( IExpression *x, IExpression *y ) : m_x( x ), m_y( y ) {}
virtual int Priority() const = 0;
public:
IExpression *m_x;
IExpression *m_y;
};
#define BEGIN_EXPR_BINARY( className ) class className : public CExprBinary { public: className( IExpression *x, IExpression *y ) : CExprBinary( x, y ) {}
#define EXPR_BINARY_PRIORITY( nPriority ) virtual int Priority() const { return nPriority; };
#define END_EXPR_BINARY() };
BEGIN_EXPR_BINARY( CExprBinary_And )
EVAL { return m_x->Evaluate( pCtx ) && m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " && " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 1 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_Or )
EVAL { return m_x->Evaluate( pCtx ) || m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " || " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 2 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_Eq )
EVAL { return m_x->Evaluate( pCtx ) == m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " == " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_Neq )
EVAL { return m_x->Evaluate( pCtx ) != m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " != " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_G )
EVAL { return m_x->Evaluate( pCtx ) > m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " > " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_Ge )
EVAL { return m_x->Evaluate( pCtx ) >= m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " >= " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_L )
EVAL { return m_x->Evaluate( pCtx ) < m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " < " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
BEGIN_EXPR_BINARY( CExprBinary_Le )
EVAL { return m_x->Evaluate( pCtx ) <= m_y->Evaluate( pCtx ); }
PRNT { OutputF( stdout, "( " ); m_x->Print( pCtx ); OutputF( stdout, " <= " ); m_y->Print( pCtx ); OutputF( stdout, " )" ); }
EXPR_BINARY_PRIORITY( 0 );
END_EXPR_BINARY()
class CComplexExpression : public IExpression
{
public:
CComplexExpression( IEvaluationContext *pCtx ) : m_pRoot( NULL ), m_pContext( pCtx ) { }
~CComplexExpression() { Clear(); }
void Parse( char const *szExpression );
void Clear( void );
public:
EVAL { return m_pRoot ? m_pRoot->Evaluate( pCtx ? pCtx : m_pContext ) : 0; };
PRNT { OutputF( stdout, "[ " ); m_pRoot ? m_pRoot->Print( pCtx ? pCtx : m_pContext ) : OutputF( stdout, "**NEXPR**" ); OutputF( stdout, " ]\n" ); }
protected:
IExpression * ParseTopLevel( char *&szExpression );
IExpression * ParseInternal( char *&szExpression );
IExpression * Allocated( IExpression *pExpression );
IExpression * AbortedParse( char *&szExpression ) const { *szExpression = 0; return m_pDefFalse; }
protected:
QuickArray < IExpression * > m_arrAllExpressions;
IExpression *m_pRoot;
IEvaluationContext *m_pContext;
IExpression *m_pDefTrue, *m_pDefFalse;
};
void CComplexExpression::Parse( char const *szExpression )
{
Clear();
m_pDefTrue = Allocated( new CExprConstant( 1 ) );
m_pDefFalse = Allocated( new CExprConstant( 0 ) );
m_pRoot = m_pDefFalse;
if (szExpression)
{
QuickString qs( szExpression );
char *szExpression = qs.Get(), *szExpectEnd = szExpression + qs.Size(), *szParse = szExpression;
m_pRoot = ParseTopLevel( szParse );
if ( szParse != szExpectEnd )
{
m_pRoot = m_pDefFalse;
}
}
}
IExpression * CComplexExpression::ParseTopLevel( char *&szExpression )
{
QuickStack< CExprBinary * > exprStack;
IExpression *pFirstToken = ParseInternal( szExpression );
for ( ; ; )
{
// Skip whitespace
while ( *szExpression && V_isspace( *szExpression ) )
{
++ szExpression;
}
// End of binary expression
if ( !*szExpression || ( *szExpression == ')' ) )
{
break;
}
// Determine the binary expression type
CExprBinary *pBinaryExpression = NULL;
if ( 0 )
{
NULL;
}
else if ( !strncmp( szExpression, "&&", 2 ) )
{
pBinaryExpression = new CExprBinary_And( NULL, NULL );
szExpression += 2;
}
else if ( !strncmp( szExpression, "||", 2 ) )
{
pBinaryExpression = new CExprBinary_Or( NULL, NULL );
szExpression += 2;
}
else if ( !strncmp( szExpression, ">=", 2 ) )
{
pBinaryExpression = new CExprBinary_Ge( NULL, NULL );
szExpression += 2;
}
else if ( !strncmp( szExpression, "<=", 2 ) )
{
pBinaryExpression = new CExprBinary_Le( NULL, NULL );
szExpression += 2;
}
else if ( !strncmp( szExpression, "==", 2 ) )
{
pBinaryExpression = new CExprBinary_Eq( NULL, NULL );
szExpression += 2;
}
else if ( !strncmp( szExpression, "!=", 2 ) )
{
pBinaryExpression = new CExprBinary_Neq( NULL, NULL );
szExpression += 2;
}
else if ( *szExpression == '>' )
{
pBinaryExpression = new CExprBinary_G( NULL, NULL );
++ szExpression;
}
else if ( *szExpression == '<' )
{
pBinaryExpression = new CExprBinary_L( NULL, NULL );
++ szExpression;
}
else
{
return AbortedParse( szExpression );
}
Allocated( pBinaryExpression );
pBinaryExpression->m_y = ParseInternal( szExpression );
// Figure out the expression priority
int nPriority = pBinaryExpression->Priority();
IExpression *pLastExpr = pFirstToken;
while ( exprStack.Size() )
{
CExprBinary *pStickTo = exprStack.Top();
pLastExpr = pStickTo;
if ( nPriority > pStickTo->Priority() )
exprStack.Pop();
else
break;
}
if ( exprStack.Size() )
{
CExprBinary *pStickTo = exprStack.Top();
pBinaryExpression->m_x = pStickTo->m_y;
pStickTo->m_y = pBinaryExpression;
}
else
{
pBinaryExpression->m_x = pLastExpr;
}
exprStack.Push( pBinaryExpression );
}
// Tip-of-the-tree retrieval
{
IExpression *pLastExpr = pFirstToken;
while ( exprStack.Size() )
{
pLastExpr = exprStack.Top();
exprStack.Pop();
}
return pLastExpr;
}
}
IExpression * CComplexExpression::ParseInternal( char *&szExpression )
{
// Skip whitespace
while ( *szExpression && V_isspace( *szExpression ) )
{
++ szExpression;
}
if ( !*szExpression )
return AbortedParse( szExpression );
if ( 0 )
{
NULL;
}
else if ( V_isdigit( *szExpression ) )
{
long lValue = strtol( szExpression, &szExpression, 10 );
return Allocated( new CExprConstant( lValue ) );
}
else if ( !strncmp( szExpression, "defined", 7 ) )
{
szExpression += 7;
IExpression *pNext = ParseInternal( szExpression );
return Allocated( new CExprConstant( pNext->Evaluate( m_pContext ) ) );
}
else if ( *szExpression == '(' )
{
++ szExpression;
IExpression *pBracketed = ParseTopLevel( szExpression );
if ( ')' == *szExpression )
{
++ szExpression;
return pBracketed;
}
else
{
return AbortedParse( szExpression );
}
}
else if ( *szExpression == '$' )
{
size_t lenVariable = 0;
for ( char *szEndVar = szExpression + 1; *szEndVar; ++ szEndVar, ++ lenVariable )
{
if ( !V_isalnum( *szEndVar ) )
{
switch ( *szEndVar )
{
case '_':
break;
default:
goto parsed_variable_name;
}
}
}
parsed_variable_name:
int nSlot = m_pContext->GetVariableSlot( QuickString( szExpression + 1, lenVariable ).Get() );
szExpression += lenVariable + 1;
return Allocated( new CExprVariable( nSlot ) );
}
else if ( *szExpression == '!' )
{
++ szExpression;
IExpression *pNext = ParseInternal( szExpression );
return Allocated( new CExprUnary_Negate( pNext ) );
}
else
{
return AbortedParse( szExpression );
}
}
IExpression * CComplexExpression::Allocated( IExpression *pExpression )
{
m_arrAllExpressions.Append( pExpression );
return pExpression;
}
void CComplexExpression::Clear( void )
{
for ( int k = 0; k < m_arrAllExpressions.Size() ; ++ k )
{
delete m_arrAllExpressions.Get( k );
}
m_arrAllExpressions.Clear();
m_pRoot = NULL;
}
#undef BEGIN_EXPR_UNARY
#undef BEGIN_EXPR_BINARY
#undef END_EXPR_UNARY
#undef END_EXPR_BINARY
#undef EVAL
#undef PRNT
//////////////////////////////////////////////////////////////////////////
//
// Combo Generator class
//
//////////////////////////////////////////////////////////////////////////
class ComboGenerator : public IEvaluationContext
{
public:
void AddDefine( Define const &df );
Define const * const GetDefinesBase( void ) { return m_arrDefines.ArrayBase(); }
Define const * const GetDefinesEnd( void ) { return m_arrDefines.ArrayBase() + m_arrDefines.Size(); }
uint64 NumCombos();
uint64 NumCombos( bool bStaticCombos );
void RunAllCombos( CComplexExpression const &skipExpr );
// IEvaluationContext
public:
virtual int GetVariableValue( int nSlot ) { return m_arrVarSlots.Get( nSlot ); };
virtual char const * GetVariableName( int nSlot ) { return m_arrDefines.Get( nSlot ).Name(); };
virtual int GetVariableSlot( char const *szVariableName ) { return m_mapDefines.Get( szVariableName ); };
protected:
QuickArray< Define > m_arrDefines;
QuickStrIdx m_mapDefines;
QuickArray < int > m_arrVarSlots;
};
void ComboGenerator::AddDefine( Define const &df )
{
m_mapDefines.Append( df.Name(), m_arrDefines.Size() );
m_arrDefines.Append( df );
m_arrVarSlots.Append( 1 );
}
uint64 ComboGenerator::NumCombos()
{
uint64 numCombos = 1;
for ( int k = 0, kEnd = m_arrDefines.Size(); k < kEnd; ++ k )
{
Define const &df = m_arrDefines.Get( k );
numCombos *= ( df.Max() - df.Min() + 1 );
}
return numCombos;
}
uint64 ComboGenerator::NumCombos( bool bStaticCombos )
{
uint64 numCombos = 1;
for ( int k = 0, kEnd = m_arrDefines.Size(); k < kEnd; ++ k )
{
Define const &df = m_arrDefines.Get( k );
( df.IsStatic() == bStaticCombos ) ? numCombos *= ( df.Max() - df.Min() + 1 ) : 0;
}
return numCombos;
}
struct ComboEmission
{
std::string m_sPrefix;
std::string m_sSuffix;
} g_comboEmission;
size_t const g_lenTmpBuffer = 1 * 1024 * 1024; // 1Mb buffer for tmp storage
char g_chTmpBuffer[g_lenTmpBuffer];
void ComboGenerator::RunAllCombos( CComplexExpression const &skipExpr )
{
// Combo numbers
uint64 const nTotalCombos = NumCombos();
// Get the pointers
int * const pnValues = m_arrVarSlots.ArrayBaseForEdit();
int * const pnValuesEnd = pnValues + m_arrVarSlots.Size();
int *pSetValues;
// Defines
Define const * const pDefVars = m_arrDefines.ArrayBase();
Define const *pSetDef;
// Set all the variables to max values
for ( pSetValues = pnValues, pSetDef = pDefVars;
pSetValues < pnValuesEnd;
++ pSetValues, ++ pSetDef )
{
*pSetValues = pSetDef->Max();
}
// Expressions distributed [0] = skips, [1] = evaluated
uint64 nSkipEvalCounters[2] = { 0, 0 };
// Go ahead and run the iterations
{
uint64 nCurrentCombo = nTotalCombos;
next_combo_iteration:
-- nCurrentCombo;
int const valExprSkip = skipExpr.Evaluate( this );
++ nSkipEvalCounters[ !valExprSkip ];
if ( valExprSkip )
{
// TECH NOTE: Giving performance hint to compiler to place a jump here
// since there will be much more skips and actually less than 0.8% cases
// will be "OnCombo" hits.
NULL;
}
else
{
// ------- OnCombo( nCurrentCombo ); ----------
OutputF( stderr, "%s ", g_comboEmission.m_sPrefix.data() );
OutputF( stderr, "/DSHADERCOMBO=%d ", nCurrentCombo );
for ( pSetValues = pnValues, pSetDef = pDefVars;
pSetValues < pnValuesEnd;
++ pSetValues, ++ pSetDef )
{
OutputF( stderr, "/D%s=%d ", pSetDef->Name(), *pSetValues );
}
OutputF( stderr, "%s\n", g_comboEmission.m_sSuffix.data() );
// ------- end of OnCombo ---------------------
}
// Do a next iteration
for ( pSetValues = pnValues, pSetDef = pDefVars;
pSetValues < pnValuesEnd;
++ pSetValues, ++ pSetDef )
{
if ( -- *pSetValues >= pSetDef->Min() )
goto next_combo_iteration;
*pSetValues = pSetDef->Max();
}
}
OutputF( stdout, "Generated %d combos: %d evaluated, %d skipped.\n", nTotalCombos, nSkipEvalCounters[1], nSkipEvalCounters[0] );
}
namespace ConfigurationProcessing
{
class CfgEntry
{
public:
CfgEntry() : m_szName( "" ), m_szShaderSrc( "" ), m_pCg( NULL ), m_pExpr( NULL ) { memset( &m_eiInfo, 0, sizeof( m_eiInfo ) ); }
static void Destroy( CfgEntry const &x ) { delete x.m_pCg; delete x.m_pExpr; }
public:
bool operator < ( CfgEntry const &x ) const { return m_pCg->NumCombos() < x.m_pCg->NumCombos(); }
public:
char const *m_szName;
char const *m_szShaderSrc;
ComboGenerator *m_pCg;
CComplexExpression *m_pExpr;
std::string m_sPrefix;
std::string m_sSuffix;
CfgProcessor::CfgEntryInfo m_eiInfo;
};
QuickStrUnique s_uniqueSections, s_strPool;
std::multiset< CfgEntry > s_setEntries;
class ComboHandleImpl : public IEvaluationContext
{
public:
uint64 m_iTotalCommand;
uint64 m_iComboNumber;
uint64 m_numCombos;
CfgEntry const *m_pEntry;
public:
ComboHandleImpl() : m_iTotalCommand( 0 ), m_iComboNumber( 0 ), m_numCombos( 0 ), m_pEntry( NULL ) {}
// IEvaluationContext
public:
QuickArray < int > m_arrVarSlots;
public:
virtual int GetVariableValue( int nSlot ) { return m_arrVarSlots.Get( nSlot ); };
virtual char const * GetVariableName( int nSlot ) { return m_pEntry->m_pCg->GetVariableName( nSlot ); };
virtual int GetVariableSlot( char const *szVariableName ) { return m_pEntry->m_pCg->GetVariableSlot( szVariableName ); };
// External implementation
public:
bool Initialize( uint64 iTotalCommand, const CfgEntry *pEntry );
bool AdvanceCommands( uint64 &riAdvanceMore );
bool NextNotSkipped( uint64 iTotalCommand );
bool IsSkipped( void ) { return ( m_pEntry->m_pExpr->Evaluate( this ) != 0 ); }
void FormatCommand( char *pchBuffer );
};
QuickMap < uint64, ComboHandleImpl > s_mapComboCommands;
bool ComboHandleImpl::Initialize( uint64 iTotalCommand, const CfgEntry *pEntry )
{
m_iTotalCommand = iTotalCommand;
m_pEntry = pEntry;
m_numCombos = m_pEntry->m_pCg->NumCombos();
// Defines
Define const * const pDefVars = m_pEntry->m_pCg->GetDefinesBase();
Define const * const pDefVarsEnd = m_pEntry->m_pCg->GetDefinesEnd();
Define const *pSetDef;
// Set all the variables to max values
for ( pSetDef = pDefVars;
pSetDef < pDefVarsEnd;
++ pSetDef )
{
m_arrVarSlots.Append( pSetDef->Max() );
}
m_iComboNumber = m_numCombos - 1;
return true;
}
bool ComboHandleImpl::AdvanceCommands( uint64 &riAdvanceMore )
{
if ( !riAdvanceMore )
return true;
// Get the pointers
int * const pnValues = m_arrVarSlots.ArrayBaseForEdit();
int * const pnValuesEnd = pnValues + m_arrVarSlots.Size();
int *pSetValues;
// Defines
Define const * const pDefVars = m_pEntry->m_pCg->GetDefinesBase();
Define const *pSetDef;
if ( m_iComboNumber < riAdvanceMore )
{
riAdvanceMore -= m_iComboNumber;
return false;
}
// Do the advance
m_iTotalCommand += riAdvanceMore;
m_iComboNumber -= riAdvanceMore;
for ( pSetValues = pnValues, pSetDef = pDefVars;
( pSetValues < pnValuesEnd ) && ( riAdvanceMore > 0 );
++ pSetValues, ++ pSetDef )
{
riAdvanceMore += ( pSetDef->Max() - *pSetValues );
*pSetValues = pSetDef->Max();
int iInterval = ( pSetDef->Max() - pSetDef->Min() + 1 );
*pSetValues -= int( riAdvanceMore % iInterval );
riAdvanceMore /= iInterval;
}
return true;
}
bool ComboHandleImpl::NextNotSkipped( uint64 iTotalCommand )
{
// Get the pointers
int * const pnValues = m_arrVarSlots.ArrayBaseForEdit();
int * const pnValuesEnd = pnValues + m_arrVarSlots.Size();
int *pSetValues;
// Defines
Define const * const pDefVars = m_pEntry->m_pCg->GetDefinesBase();
Define const *pSetDef;
// Go ahead and run the iterations
{
next_combo_iteration:
if ( m_iTotalCommand + 1 >= iTotalCommand ||
!m_iComboNumber )
return false;
-- m_iComboNumber;
++ m_iTotalCommand;
// Do a next iteration
for ( pSetValues = pnValues, pSetDef = pDefVars;
pSetValues < pnValuesEnd;
++ pSetValues, ++ pSetDef )
{
if ( -- *pSetValues >= pSetDef->Min() )
goto have_combo_iteration;
*pSetValues = pSetDef->Max();
}
return false;
have_combo_iteration:
if ( m_pEntry->m_pExpr->Evaluate( this ) )
goto next_combo_iteration;
else
return true;
}
}
void ComboHandleImpl::FormatCommand( char *pchBuffer )
{
// Get the pointers
int * const pnValues = m_arrVarSlots.ArrayBaseForEdit();
int * const pnValuesEnd = pnValues + m_arrVarSlots.Size();
int *pSetValues;
// Defines
Define const * const pDefVars = m_pEntry->m_pCg->GetDefinesBase();
Define const *pSetDef;
{
// ------- OnCombo( nCurrentCombo ); ----------
sprintf( pchBuffer, "%s ", m_pEntry->m_sPrefix.data() );
pchBuffer += strlen( pchBuffer );
sprintf( pchBuffer, "/DSHADERCOMBO=%llu ", m_iComboNumber );
pchBuffer += strlen( pchBuffer );
for ( pSetValues = pnValues, pSetDef = pDefVars;
pSetValues < pnValuesEnd;
++ pSetValues, ++ pSetDef )
{
sprintf( pchBuffer, "/D%s=%d ", pSetDef->Name(), *pSetValues );
pchBuffer += strlen( pchBuffer );
}
sprintf( pchBuffer, "%s\n", m_pEntry->m_sSuffix.data() );
pchBuffer += strlen( pchBuffer );
// ------- end of OnCombo ---------------------
}
}
struct CAutoDestroyEntries {
~CAutoDestroyEntries( void ) {
std::for_each( s_setEntries.begin(), s_setEntries.end(), CfgEntry::Destroy );
}
} s_autoDestroyEntries;
FILE *& GetInputStream( FILE * )
{
static FILE *s_fInput = stdin;
return s_fInput;
}
CUtlInplaceBuffer *& GetInputStream( CUtlInplaceBuffer * )
{
static CUtlInplaceBuffer *s_fInput = NULL;
return s_fInput;
}
char * GetLinePtr_Private( void )
{
if ( CUtlInplaceBuffer *pUtlBuffer = GetInputStream( ( CUtlInplaceBuffer * ) NULL ) )
return pUtlBuffer->InplaceGetLinePtr();
if ( FILE *fInput = GetInputStream( ( FILE * ) NULL ) )
return fgets( g_chTmpBuffer, g_lenTmpBuffer, fInput );
return NULL;
}
bool LineEquals( char const *sz1, char const *sz2, int nLen )
{
return 0 == strncmp( sz1, sz2, nLen );
}
char * NextLine( void )
{
if ( char *szLine = GetLinePtr_Private() )
{
// Trim trailing whitespace as well
size_t len = ( size_t ) strlen( szLine );
while ( len -- > 0 && V_isspace( szLine[ len ] ) )
{
szLine[ len ] = 0;
}
return szLine;
}
return NULL;
}
char * WaitFor( char const *szWaitString, int nMatchLength )
{
while ( char *pchResult = NextLine() )
{
if ( LineEquals( pchResult, szWaitString, nMatchLength ) )
return pchResult;
}
return NULL;
}
bool ProcessSection( CfgEntry &cfge )
{
bool bStaticDefines;
// Read the next line for the section src file
if ( char *szLine = NextLine() )
{
cfge.m_szShaderSrc = s_strPool.AddLookup( szLine );
}
if ( char *szLine = WaitFor( "#DEFINES-", 9 ) )
{
bStaticDefines = ( szLine[9] == 'S' );
}
else
return false;
// Combo generator
ComboGenerator &cg = *( cfge.m_pCg = new ComboGenerator );
CComplexExpression &exprSkip = *( cfge.m_pExpr = new CComplexExpression( &cg ) );
// #DEFINES:
while ( char *szLine = NextLine() )
{
if ( LineEquals( szLine, "#SKIP", 5 ) )
break;
// static defines
if ( LineEquals( szLine, "#DEFINES-", 9 ) )
{
bStaticDefines = ( szLine[9] == 'S' );
continue;
}
while ( *szLine && V_isspace(*szLine) )
{
++ szLine;
}
// Find the eq
char *pchEq = strchr( szLine, '=' );
if ( !pchEq )
continue;
char *pchStartRange = pchEq + 1;
*pchEq = 0;
while ( -- pchEq >= szLine &&
V_isspace( *pchEq ) )
{
*pchEq = 0;
}
if ( !*szLine )
continue;
// Find the end of range
char *pchEndRange = strstr( pchStartRange, ".." );
if ( !pchEndRange )
continue;
pchEndRange += 2;
// Create the define
Define df( szLine, atoi( pchStartRange ), atoi( pchEndRange ), bStaticDefines );
if ( df.Max() < df.Min() )
continue;
// Add the define
cg.AddDefine( df );
}
// #SKIP:
if ( char *szLine = NextLine() )
{
exprSkip.Parse( szLine );
}
else
return false;
// #COMMAND:
if ( !WaitFor( "#COMMAND", 8 ) )
return false;
if ( char *szLine = NextLine() )
cfge.m_sPrefix = szLine;
if ( char *szLine = NextLine() )
cfge.m_sSuffix = szLine;
// #END
if ( !WaitFor( "#END", 4 ) )
return false;
return true;
}
void UnrollSectionCommands( CfgEntry const &cfge )
{
// Execute the combo computation
//
//
g_comboEmission.m_sPrefix = cfge.m_sPrefix;
g_comboEmission.m_sSuffix = cfge.m_sSuffix;
OutputF( stdout, "Preparing %d combos for %s...\n", cfge.m_pCg->NumCombos(), cfge.m_szName );
OutputF( stderr, "#%s\n", cfge.m_szName );
time_t tt_start = time( NULL );
cfge.m_pCg->RunAllCombos( *cfge.m_pExpr );
time_t tt_end = time( NULL );
OutputF( stderr, "#%s\n", cfge.m_szName );
OutputF( stdout, "Prepared %s combos. %d sec.\n", cfge.m_szName, ( int ) difftime( tt_end, tt_start ) );
g_comboEmission.m_sPrefix = "";
g_comboEmission.m_sSuffix = "";
}
void RunSection( CfgEntry const &cfge )
{
// Execute the combo computation
//
//
g_comboEmission.m_sPrefix = cfge.m_sPrefix;
g_comboEmission.m_sSuffix = cfge.m_sSuffix;
OutputF( stdout, "Preparing %d combos for %s...\n", cfge.m_pCg->NumCombos(), cfge.m_szName );
OutputF( stderr, "#%s\n", cfge.m_szName );
time_t tt_start = time( NULL );
cfge.m_pCg->RunAllCombos( *cfge.m_pExpr );
time_t tt_end = time( NULL );
OutputF( stderr, "#%s\n", cfge.m_szName );
OutputF( stdout, "Prepared %s combos. %d sec.\n", cfge.m_szName, ( int ) difftime( tt_end, tt_start ) );
g_comboEmission.m_sPrefix = "";
g_comboEmission.m_sSuffix = "";
}
void ProcessConfiguration()
{
static bool s_bProcessOnce = false;
while ( char *szLine = WaitFor( "#BEGIN", 6 ) )
{
if ( ' ' == szLine[6] && !s_uniqueSections.Add(szLine + 7) )
continue;
CfgEntry cfge;
cfge.m_szName = s_uniqueSections.Lookup( szLine + 7 );
ProcessSection( cfge );
s_setEntries.insert( cfge );
}
uint64 nCurrentCommand = 0;
for( std::multiset< CfgEntry >::reverse_iterator it = s_setEntries.rbegin(),
itEnd = s_setEntries.rend(); it != itEnd; ++ it )
{
// We establish a command mapping for the beginning of the entry
ComboHandleImpl chi;
chi.Initialize( nCurrentCommand, &*it );
s_mapComboCommands.Append( nCurrentCommand, chi );
// We also establish mapping by either splitting the
// combos into 500 intervals or stepping by every 1000 combos.
int iPartStep = ( int ) max( 1000, (int)( chi.m_numCombos / 500 ) );
for ( uint64 iRecord = nCurrentCommand + iPartStep;
iRecord < nCurrentCommand + chi.m_numCombos;
iRecord += iPartStep )
{
uint64 iAdvance = iPartStep;
chi.AdvanceCommands( iAdvance );
s_mapComboCommands.Append( iRecord, chi );
}
nCurrentCommand += chi.m_numCombos;
}
// Establish the last command terminator
{
static CfgEntry s_term;
s_term.m_eiInfo.m_iCommandStart = s_term.m_eiInfo.m_iCommandEnd = nCurrentCommand;
s_term.m_eiInfo.m_numCombos = s_term.m_eiInfo.m_numStaticCombos = s_term.m_eiInfo.m_numDynamicCombos = 1;
s_term.m_eiInfo.m_szName = s_term.m_eiInfo.m_szShaderFileName = "";
ComboHandleImpl chi;
chi.m_iTotalCommand = nCurrentCommand;
chi.m_pEntry = &s_term;
s_mapComboCommands.Append( nCurrentCommand, chi );
}
}
}; // namespace ConfigurationProcessing
/*
int main( int argc, char **argv )
{
if ( _isatty( _fileno( stdin ) ) )
{
return Usage();
}
// Go ahead processing the configuration
ConfigurationProcessing::ProcessConfiguration();
return 0;
}
*/
namespace CfgProcessor
{
typedef ConfigurationProcessing::ComboHandleImpl CPCHI_t;
CPCHI_t * FromHandle( ComboHandle hCombo ) { return reinterpret_cast < CPCHI_t * > ( hCombo ); }
ComboHandle AsHandle( CPCHI_t *pImpl ) { return reinterpret_cast < ComboHandle > ( pImpl ); }
void ReadConfiguration( FILE *fInputStream )
{
CAutoPushPop < FILE * > pushInputStream( ConfigurationProcessing::GetInputStream( fInputStream ), fInputStream );
ConfigurationProcessing::ProcessConfiguration();
}
void ReadConfiguration( CUtlInplaceBuffer *fInputStream )
{
CAutoPushPop < CUtlInplaceBuffer * > pushInputStream( ConfigurationProcessing::GetInputStream( fInputStream ), fInputStream );
ConfigurationProcessing::ProcessConfiguration();
}
void DescribeConfiguration( CArrayAutoPtr < CfgEntryInfo > &rarrEntries )
{
rarrEntries.Delete();
rarrEntries.Attach( new CfgEntryInfo [ ConfigurationProcessing::s_setEntries.size() + 1 ] );
CfgEntryInfo *pInfo = rarrEntries.Get();
uint64 nCurrentCommand = 0;
for( std::multiset< ConfigurationProcessing::CfgEntry >::reverse_iterator it =
ConfigurationProcessing::s_setEntries.rbegin(),
itEnd = ConfigurationProcessing::s_setEntries.rend();
it != itEnd; ++ it, ++ pInfo )
{
ConfigurationProcessing::CfgEntry const &e = *it;
pInfo->m_szName = e.m_szName;
pInfo->m_szShaderFileName = e.m_szShaderSrc;
pInfo->m_iCommandStart = nCurrentCommand;
pInfo->m_numCombos = e.m_pCg->NumCombos();
pInfo->m_numDynamicCombos = e.m_pCg->NumCombos( false );
pInfo->m_numStaticCombos = e.m_pCg->NumCombos( true );
pInfo->m_iCommandEnd = pInfo->m_iCommandStart + pInfo->m_numCombos;
const_cast< CfgEntryInfo & > ( e.m_eiInfo ) = *pInfo;
nCurrentCommand += pInfo->m_numCombos;
}
// Terminator
memset( pInfo, 0, sizeof( CfgEntryInfo ) );
pInfo->m_iCommandStart = nCurrentCommand;
pInfo->m_iCommandEnd = nCurrentCommand;
}
ComboHandle Combo_GetCombo( uint64 iCommandNumber )
{
// Find earlier command
uint64 iCommandFound = iCommandNumber;
CPCHI_t emptyCPCHI;
CPCHI_t const &chiFound = ConfigurationProcessing::s_mapComboCommands.GetLessOrEq( iCommandFound, emptyCPCHI );
if ( chiFound.m_iTotalCommand < 0 ||
chiFound.m_iTotalCommand > iCommandNumber )
return NULL;
// Advance the handle as needed
CPCHI_t *pImpl = new CPCHI_t( chiFound );
uint64 iCommandFoundAdvance = iCommandNumber - iCommandFound;
pImpl->AdvanceCommands( iCommandFoundAdvance );
return AsHandle( pImpl );
}
ComboHandle Combo_GetNext( uint64 &riCommandNumber, ComboHandle &rhCombo, uint64 iCommandEnd )
{
// Combo handle implementation
CPCHI_t *pImpl = FromHandle( rhCombo );
if ( !rhCombo )
{
// We don't have a combo handle that corresponds to the command
// Find earlier command
uint64 iCommandFound = riCommandNumber;
CPCHI_t emptyCPCHI;
CPCHI_t const &chiFound = ConfigurationProcessing::s_mapComboCommands.GetLessOrEq( iCommandFound, emptyCPCHI );
if ( !chiFound.m_pEntry ||
!chiFound.m_pEntry->m_pCg ||
!chiFound.m_pEntry->m_pExpr ||
chiFound.m_iTotalCommand < 0 ||
chiFound.m_iTotalCommand > riCommandNumber )
return NULL;
// Advance the handle as needed
pImpl = new CPCHI_t( chiFound );
rhCombo = AsHandle( pImpl );
uint64 iCommandFoundAdvance = riCommandNumber - iCommandFound;
pImpl->AdvanceCommands( iCommandFoundAdvance );
if ( !pImpl->IsSkipped() )
return rhCombo;
}
for ( ; ; )
{
// We have the combo handle now
if ( pImpl->NextNotSkipped( iCommandEnd ) )
{
riCommandNumber = pImpl->m_iTotalCommand;
return rhCombo;
}
// We failed to get the next combo command (out of range)
if ( pImpl->m_iTotalCommand + 1 >= iCommandEnd )
{
delete pImpl;
rhCombo = NULL;
riCommandNumber = iCommandEnd;
return NULL;
}
// Otherwise we just have to obtain the next combo handle
riCommandNumber = pImpl->m_iTotalCommand + 1;
// Delete the old combo handle
delete pImpl;
rhCombo = NULL;
// Retrieve the next combo handle data
uint64 iCommandLookup = riCommandNumber;
CPCHI_t emptyCPCHI;
CPCHI_t const &chiNext = ConfigurationProcessing::s_mapComboCommands.GetLessOrEq( iCommandLookup, emptyCPCHI );
Assert( ( iCommandLookup == riCommandNumber ) && ( chiNext.m_pEntry ) );
// Set up the new combo handle
pImpl = new CPCHI_t( chiNext );
rhCombo = AsHandle( pImpl );
if ( !pImpl->IsSkipped() )
return rhCombo;
}
}
void Combo_FormatCommand( ComboHandle hCombo, char *pchBuffer )
{
CPCHI_t *pImpl = FromHandle( hCombo );
pImpl->FormatCommand( pchBuffer );
}
uint64 Combo_GetCommandNum( ComboHandle hCombo )
{
if ( CPCHI_t *pImpl = FromHandle( hCombo ) )
return pImpl->m_iTotalCommand;
else
return ~uint64(0);
}
uint64 Combo_GetComboNum( ComboHandle hCombo )
{
if ( CPCHI_t *pImpl = FromHandle( hCombo ) )
return pImpl->m_iComboNumber;
else
return ~uint64(0);
}
CfgEntryInfo const *Combo_GetEntryInfo( ComboHandle hCombo )
{
if ( CPCHI_t *pImpl = FromHandle( hCombo ) )
return &pImpl->m_pEntry->m_eiInfo;
else
return NULL;
}
ComboHandle Combo_Alloc( ComboHandle hComboCopyFrom )
{
if ( hComboCopyFrom )
return AsHandle( new CPCHI_t( * FromHandle( hComboCopyFrom ) ) );
else
return AsHandle( new CPCHI_t );
}
void Combo_Assign( ComboHandle hComboDst, ComboHandle hComboSrc )
{
Assert( hComboDst );
* FromHandle( hComboDst ) = * FromHandle( hComboSrc );
}
void Combo_Free( ComboHandle &rhComboFree )
{
delete FromHandle( rhComboFree );
rhComboFree = NULL;
}
}; // namespace CfgProcessor