static Stmt *BuildProgramReturnAssignments( CgContext *cg, Stmt *fStmt, void *arg1, int arg2)
{
struct BuildReturnAssignments *lstr;
Symbol *program, *lSymb, *voutVar, *outSymb, *retSymb;
Type *lType, *rettype;
Expr *lExpr, *rexpr, *returnVar, *outputVar;
Scope *lScope, *gScope, *voutScope;
Stmt *lStmt, *stmtlist;
int len;
Atom lname;
if (fStmt->kind == RETURN_STMT) {
lstr = (struct BuildReturnAssignments *) arg1;
gScope = lstr->globalScope;
program = lstr->program;
lType = program->type;
rettype = static_cast< TypeFunction * >( lType )->rettype;
TypeCategory category = rettype->category;
if (IsVoid(rettype)) {
fStmt = NULL;
} else {
if (category == TC_Struct) {
stmtlist = NULL;
voutVar = cg->theHal->varyingOut;
voutScope = static_cast< TypeStruct * >( voutVar->type )->members;
lScope = static_cast< TypeStruct * >( rettype )->members;
lSymb = lScope->symbols;
while (lSymb) {
// Create an assignment statement of the bound variable to the $vout member:
lname = lSymb->details.var.semantics.IsValid() ? lSymb->details.var.semantics : lSymb->name;
outSymb = LookupLocalSymbol(cg, voutScope, lname);
retSymb = LookupLocalSymbol(cg, lScope, lSymb->name);
if (outSymb && retSymb) {
// outSymb may not be in the symbol table if it's a "hidden" register.
returnVar = DupExpr( cg, static_cast< ReturnStmt * >( fStmt )->expr);
outputVar = (Expr *) NewSymbNode( cg, VARIABLE_OP, voutVar);
lExpr = GenMemberReference( cg, outputVar, outSymb);
rexpr = GenMemberReference( cg, returnVar, retSymb);
if (IsScalar(lSymb->type) || IsVector(lSymb->type, &len)) {
lStmt = NewSimpleAssignmentStmt( cg, &program->loc, lExpr, rexpr, 0);
stmtlist = ConcatStmts(stmtlist, lStmt);
} else {
FatalError( cg, "Return of unsupported type");
// xxx
}
}
lSymb = lSymb->next;
}
delete fStmt;
fStmt = stmtlist;
} else {
// Already reported:
// SemanticError(&program->loc, ERROR_S_PROGRAM_MUST_RETURN_STRUCT,
// cg->GetString(program->name));
}
}
}
return fStmt;
} // BuildProgramReturnAssignments
Ref * sysVectorLength( Ref *pc, class MachineClass * vm ) {
if ( vm->count != 1 ) throw Ginger::Mishap( "Wrong number of arguments for vectorLength" );
Ref r = vm->fastPeek();
if ( !IsVector( r ) ) throw Ginger::Mishap( "Argument mismatch for vectorLength" );
Ref * obj_K = RefToPtr4( r );
vm->fastPeek() = LongToSmall( sizeAfterKeyOfVectorLayout( obj_K ) );
return pc;
}
bool IsMatrix(const Type *fType, int *len, int *len2)
{
if (fType &&
fType->category == TC_Array &&
(fType->properties & TYPE_MISC_PACKED) &&
IsVector(static_cast< const TypeArray * >( fType )->eltype, len))
{
if (len2)
*len2 = static_cast< const TypeArray * >( fType )->numels;
return true;
}
return false;
} // IsMatrix
int IsMatrix(const Type *fType, int *len, int *len2)
{
if (fType &&
(fType->properties & TYPE_CATEGORY_MASK) == TYPE_CATEGORY_ARRAY &&
(fType->properties & TYPE_MISC_PACKED) &&
IsVector(fType->arr.eltype, len))
{
if (len2)
*len2 = fType->arr.numels;
return 1;
} else {
return 0;
}
} // IsMatrix
Ref * sysVectorExplode( Ref *pc, class MachineClass * vm ) {
if ( vm->count != 1 ) throw Ginger::Mishap( "Wrong number of arguments for vectorExplode" );
Ref r = vm->fastPop();
if ( !IsVector( r ) ) throw Ginger::Mishap( "Argument mismatch for vectorExplode" );
Ref *obj_K = RefToPtr4( r );
unsigned long n = sizeAfterKeyOfVectorLayout( obj_K );
vm->checkStackRoom( n );
memcpy( vm->vp + 1, obj_K + 1, n * sizeof( Ref ));
vm->vp += n;
return pc;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static IMaterialVar *CreateMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
{
switch( pKeyValue->GetDataType() )
{
case KeyValues::TYPE_INT:
{
return IMaterialVar::Create( pMaterial, pKeyValue->GetName(), pKeyValue->GetInt() );
}
case KeyValues::TYPE_FLOAT:
{
return IMaterialVar::Create( pMaterial, pKeyValue->GetName(), pKeyValue->GetFloat() );
}
case KeyValues::TYPE_STRING:
{
char const* pString = pKeyValue->GetString();
if (!pString || !pString[0])
return 0;
// Look for matrices
IMaterialVar *pMatrixVar = CreateMatrixMaterialVarFromKeyValue( pMaterial, pKeyValue );
if ( pMatrixVar )
return pMatrixVar;
// Look for vectors
if ( !IsVector( pString ) )
return IMaterialVar::Create( pMaterial, pKeyValue->GetName(), pString );
// Parse the string as a vector...
return CreateVectorMaterialVarFromKeyValue( pMaterial, pKeyValue );
}
}
return 0;
}
bool isVectorObject() const { return IsVector( this->ref ); }
