/**************************************************************************
*
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
for (i = 0; i < TGSI_FILE_COUNT; i++) {
const char *cur = *pcur;
- if (str_match_nocase_whole( &cur, tgsi_file_names[i] )) {
+ if (str_match_nocase_whole( &cur, tgsi_file_name(i) )) {
*pcur = cur;
*file = i;
return TRUE;
static boolean
parse_optional_swizzle(
struct translate_ctx *ctx,
- uint swizzle[4],
- boolean *parsed_swizzle )
+ uint *swizzle,
+ boolean *parsed_swizzle,
+ int components)
{
const char *cur = ctx->cur;
cur++;
eat_opt_white( &cur );
- for (i = 0; i < 4; i++) {
+ for (i = 0; i < components; i++) {
if (uprcase( *cur ) == 'X')
swizzle[i] = TGSI_SWIZZLE_X;
else if (uprcase( *cur ) == 'Y')
src->Dimension.Indirect = 0;
src->Dimension.Dimension = 0;
src->Dimension.Index = bracket[0].index;
+ if (bracket[0].ind_file != TGSI_FILE_NULL) {
+ src->Dimension.Indirect = 1;
+ src->DimIndirect.File = bracket[0].ind_file;
+ src->DimIndirect.Index = bracket[0].ind_index;
+ src->DimIndirect.Swizzle = bracket[0].ind_comp;
+ src->DimIndirect.ArrayID = bracket[0].ind_array;
+ }
bracket[0] = bracket[1];
}
src->Register.Index = bracket[0].index;
/* Parse optional swizzle.
*/
- if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle )) {
+ if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 4 )) {
if (parsed_swizzle) {
src->Register.SwizzleX = swizzle[0];
src->Register.SwizzleY = swizzle[1];
return TRUE;
}
+static boolean
+parse_texoffset_operand(
+ struct translate_ctx *ctx,
+ struct tgsi_texture_offset *src )
+{
+ uint file;
+ uint swizzle[3];
+ boolean parsed_swizzle;
+ struct parsed_bracket bracket;
+
+ if (!parse_register_src(ctx, &file, &bracket))
+ return FALSE;
+
+ src->File = file;
+ src->Index = bracket.index;
+
+ /* Parse optional swizzle.
+ */
+ if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 3 )) {
+ if (parsed_swizzle) {
+ src->SwizzleX = swizzle[0];
+ src->SwizzleY = swizzle[1];
+ src->SwizzleZ = swizzle[2];
+ }
+ }
+
+ return TRUE;
+}
+
static boolean
match_inst(const char **pcur,
unsigned *saturate,
if (!parse_register_1d( ctx, &file, &index ))
return FALSE;
- if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle )) {
+ if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 4 )) {
if (parsed_swizzle) {
inst.Predicate.SwizzleX = swizzle[0];
inst.Predicate.SwizzleY = swizzle[1];
/*
* These are not considered tex opcodes here (no additional
* target argument) however we're required to set the Texture
- * bit so we can set the number of tex offsets (offsets aren't
- * actually handled here yet in any case).
+ * bit so we can set the number of tex offsets.
*/
inst.Instruction.Texture = 1;
inst.Texture.Texture = TGSI_TEXTURE_UNKNOWN;
}
}
+ cur = ctx->cur;
+ eat_opt_white( &cur );
+ for (i = 0; inst.Instruction.Texture && *cur == ','; i++) {
+ cur++;
+ eat_opt_white( &cur );
+ ctx->cur = cur;
+ if (!parse_texoffset_operand( ctx, &inst.TexOffsets[i] ))
+ return FALSE;
+ cur = ctx->cur;
+ eat_opt_white( &cur );
+ }
+ inst.Texture.NumOffsets = i;
+
cur = ctx->cur;
eat_opt_white( &cur );
if (info->is_branch && *cur == ':') {
cur2 = cur;
cur2++;
eat_opt_white( &cur2 );
- if (str_match_nocase_whole( &cur2, "ARRAY(" )) {
+ if (str_match_nocase_whole( &cur2, "ARRAY" )) {
int arrayid;
+ if (*cur2 != '(') {
+ report_error( ctx, "Expected `('" );
+ return FALSE;
+ }
+ cur2++;
eat_opt_white( &cur2 );
if (!parse_int( &cur2, &arrayid )) {
report_error( ctx, "Expected `,'" );
}
eat_opt_white( &cur2 );
if (*cur2 != ')') {
- report_error( ctx, "Expected `,'" );
+ report_error( ctx, "Expected `)'" );
return FALSE;
}
+ cur2++;
decl.Declaration.Array = 1;
decl.Array.ArrayID = arrayid;
- cur = cur2;
+ ctx->cur = cur = cur2;
}
}
++cur;
eat_opt_white( &cur );
for (j = 0; j < 4; ++j) {
- for (i = 0; i < PIPE_TYPE_COUNT; ++i) {
- if (str_match_nocase_whole(&cur, tgsi_type_names[i])) {
+ for (i = 0; i < TGSI_RETURN_TYPE_COUNT; ++i) {
+ if (str_match_nocase_whole(&cur, tgsi_return_type_names[i])) {
switch (j) {
case 0:
decl.SamplerView.ReturnTypeX = i;
break;
}
}
- if (i == PIPE_TYPE_COUNT) {
+ if (i == TGSI_RETURN_TYPE_COUNT) {
if (j == 0 || j > 2) {
report_error(ctx, "Expected type name");
return FALSE;
}
}
+ cur = ctx->cur;
+ eat_opt_white( &cur );
+ if (*cur == ',' && !is_vs_input) {
+ uint i;
+
+ cur++;
+ eat_opt_white( &cur );
+ for (i = 0; i < TGSI_INTERPOLATE_LOC_COUNT; i++) {
+ if (str_match_nocase_whole( &cur, tgsi_interpolate_locations[i] )) {
+ decl.Interp.Location = i;
+
+ ctx->cur = cur;
+ break;
+ }
+ }
+ }
+
advance = tgsi_build_full_declaration(
&decl,
ctx->tokens_cur,
struct tgsi_token *tokens,
uint num_tokens )
{
- struct translate_ctx ctx;
+ struct translate_ctx ctx = {0};
ctx.text = text;
ctx.cur = text;