tgsi_text.c File Reference

Include dependency graph for tgsi_text.c:

Go to the source code of this file.

Data Structures
struct	translate_ctx
Functions
static boolean	is_alpha_underscore (const char *cur)
static boolean	is_digit (const char *cur)
static boolean	is_digit_alpha_underscore (const char *cur)
static boolean	uprcase (char c)
static boolean	str_match_no_case (const char **pcur, const char *str)
static void	eat_opt_white (const char **pcur)
static boolean	eat_white (const char **pcur)
static boolean	parse_uint (const char **pcur, uint *val)
static boolean	parse_float (const char **pcur, float *val)
static void	report_error (struct translate_ctx *ctx, const char *msg)
static boolean	parse_header (struct translate_ctx *ctx)
static boolean	parse_label (struct translate_ctx *ctx, uint *val)
static boolean	parse_file (const char **pcur, uint *file)
static boolean	parse_opt_writemask (struct translate_ctx *ctx, uint *writemask)
static boolean	parse_register_file_bracket (struct translate_ctx *ctx, uint *file)
static boolean	parse_register_file_bracket_index (struct translate_ctx *ctx, uint *file, int *index)
static boolean	parse_register_dst (struct translate_ctx *ctx, uint *file, int *index)
static boolean	parse_register_src (struct translate_ctx *ctx, uint *file, int *index, uint *ind_file, int *ind_index)
static boolean	parse_register_dcl (struct translate_ctx *ctx, uint *file, int *first, int *last)
static boolean	parse_dst_operand (struct translate_ctx *ctx, struct tgsi_full_dst_register *dst)
static boolean	parse_optional_swizzle (struct translate_ctx *ctx, uint swizzle[4], boolean *parsed_swizzle, boolean *parsed_extswizzle)
static boolean	parse_src_operand (struct translate_ctx *ctx, struct tgsi_full_src_register *src)
static boolean	parse_instruction (struct translate_ctx *ctx, boolean has_label)
static boolean	parse_declaration (struct translate_ctx *ctx)
static boolean	parse_immediate (struct translate_ctx *ctx)
static boolean	translate (struct translate_ctx *ctx)
boolean	tgsi_text_translate (const char *text, struct tgsi_token *tokens, uint num_tokens)
Variables
static const char *	file_names [TGSI_FILE_COUNT]
static const char *	modulate_names [TGSI_MODULATE_COUNT]
static const char *	texture_names [TGSI_TEXTURE_COUNT]
static const char *	semantic_names [TGSI_SEMANTIC_COUNT]
static const char *	interpolate_names [TGSI_INTERPOLATE_COUNT]

---

Function Documentation

static void eat_opt_white

(

const char **

pcur

)

[static]

Definition at line 78 of file tgsi_text.c.

{
   while (**pcur == ' ' || **pcur == '\t' || **pcur == '\n')
      (*pcur)++;
}

static boolean eat_white

(

const char **

pcur

)

[static]

Definition at line 87 of file tgsi_text.c.

References eat_opt_white().

{
   const char *cur = *pcur;

   eat_opt_white( pcur );
   return *pcur > cur;
}

static boolean is_alpha_underscore

(

const char *

cur

)

[static]

Definition at line 36 of file tgsi_text.c.

{
   return
      (*cur >= 'a' && *cur <= 'z') ||
      (*cur >= 'A' && *cur <= 'Z') ||
      *cur == '_';
}

static boolean is_digit

(

const char *

cur

)

[static]

Definition at line 44 of file tgsi_text.c.

{
   return *cur >= '0' && *cur <= '9';
}

static boolean is_digit_alpha_underscore

(

const char *

cur

)

[static]

Definition at line 49 of file tgsi_text.c.

References is_alpha_underscore(), and is_digit().

{
   return is_digit( cur ) || is_alpha_underscore( cur );
}

static boolean parse_declaration

(

struct translate_ctx *

ctx

)

[static]

Definition at line 880 of file tgsi_text.c.

References translate_ctx::cur, tgsi_full_declaration::Declaration, tgsi_full_declaration::DeclarationRange, eat_opt_white(), eat_white(), FALSE, tgsi_declaration::File, tgsi_declaration_range::First, translate_ctx::header, tgsi_declaration::Interpolate, interpolate_names, is_digit_alpha_underscore(), tgsi_declaration_range::Last, parse_opt_writemask(), parse_register_dcl(), parse_uint(), report_error(), tgsi_declaration::Semantic, tgsi_full_declaration::Semantic, semantic_names, tgsi_declaration_semantic::SemanticIndex, tgsi_declaration_semantic::SemanticName, str_match_no_case(), tgsi_build_full_declaration(), tgsi_default_full_declaration(), TGSI_INTERPOLATE_COUNT, TGSI_SEMANTIC_COUNT, translate_ctx::tokens_cur, translate_ctx::tokens_end, TRUE, and tgsi_declaration::UsageMask.

{
   struct tgsi_full_declaration decl;
   uint file;
   int first;
   int last;
   uint writemask;
   const char *cur;
   uint advance;

   if (!eat_white( &ctx->cur )) {
      report_error( ctx, "Syntax error" );
      return FALSE;
   }
   if (!parse_register_dcl( ctx, &file, &first, &last ))
      return FALSE;
   if (!parse_opt_writemask( ctx, &writemask ))
      return FALSE;

   decl = tgsi_default_full_declaration();
   decl.Declaration.File = file;
   decl.Declaration.UsageMask = writemask;
   decl.DeclarationRange.First = first;
   decl.DeclarationRange.Last = last;

   cur = ctx->cur;
   eat_opt_white( &cur );
   if (*cur == ',') {
      uint i;

      cur++;
      eat_opt_white( &cur );
      for (i = 0; i < TGSI_SEMANTIC_COUNT; i++) {
         if (str_match_no_case( &cur, semantic_names[i] )) {
            const char *cur2 = cur;
            uint index;

            if (is_digit_alpha_underscore( cur ))
               continue;
            eat_opt_white( &cur2 );
            if (*cur2 == '[') {
               cur2++;
               eat_opt_white( &cur2 );
               if (!parse_uint( &cur2, &index )) {
                  report_error( ctx, "Expected literal integer" );
                  return FALSE;
               }
               eat_opt_white( &cur2 );
               if (*cur2 != ']') {
                  report_error( ctx, "Expected `]'" );
                  return FALSE;
               }
               cur2++;

               decl.Semantic.SemanticIndex = index;

               cur = cur2;
            }

            decl.Declaration.Semantic = 1;
            decl.Semantic.SemanticName = i;

            ctx->cur = cur;
            break;
         }
      }
   }

   cur = ctx->cur;
   eat_opt_white( &cur );
   if (*cur == ',') {
      uint i;

      cur++;
      eat_opt_white( &cur );
      for (i = 0; i < TGSI_INTERPOLATE_COUNT; i++) {
         if (str_match_no_case( &cur, interpolate_names[i] )) {
            if (is_digit_alpha_underscore( cur ))
               continue;
            decl.Declaration.Interpolate = i;

            ctx->cur = cur;
            break;
         }
      }
      if (i == TGSI_INTERPOLATE_COUNT) {
         report_error( ctx, "Expected semantic or interpolate attribute" );
         return FALSE;
      }
   }

   advance = tgsi_build_full_declaration(
      &decl,
      ctx->tokens_cur,
      ctx->header,
      (uint) (ctx->tokens_end - ctx->tokens_cur) );
   if (advance == 0)
      return FALSE;
   ctx->tokens_cur += advance;

   return TRUE;
}

static boolean parse_dst_operand	(	struct translate_ctx *	ctx,
		struct tgsi_full_dst_register *	dst
	)			[static]

Definition at line 471 of file tgsi_text.c.

References translate_ctx::cur, tgsi_full_dst_register::DstRegister, tgsi_full_dst_register::DstRegisterExtModulate, eat_opt_white(), FALSE, tgsi_dst_register::File, tgsi_dst_register::Index, is_digit_alpha_underscore(), tgsi_dst_register_ext_modulate::Modulate, modulate_names, parse_opt_writemask(), parse_register_dst(), str_match_no_case(), TGSI_MODULATE_COUNT, TRUE, and tgsi_dst_register::WriteMask.

{
   uint file;
   int index;
   uint writemask;
   const char *cur;

   if (!parse_register_dst( ctx, &file, &index ))
      return FALSE;

   cur = ctx->cur;
   eat_opt_white( &cur );
   if (*cur == '_') {
      uint i;

      for (i = 0; i < TGSI_MODULATE_COUNT; i++) {
         if (str_match_no_case( &cur, modulate_names[i] )) {
            if (!is_digit_alpha_underscore( cur )) {
               dst->DstRegisterExtModulate.Modulate = i;
               ctx->cur = cur;
               break;
            }
         }
      }
   }

   if (!parse_opt_writemask( ctx, &writemask ))
      return FALSE;

   dst->DstRegister.File = file;
   dst->DstRegister.Index = index;
   dst->DstRegister.WriteMask = writemask;
   return TRUE;
}

static boolean parse_file	(	const char **	pcur,
		uint *	file
	)			[static]

Definition at line 238 of file tgsi_text.c.

References FALSE, file_names, is_digit_alpha_underscore(), str_match_no_case(), TGSI_FILE_COUNT, and TRUE.

{
   uint i;

   for (i = 0; i < TGSI_FILE_COUNT; i++) {
      const char *cur = *pcur;

      if (str_match_no_case( &cur, file_names[i] )) {
         if (!is_digit_alpha_underscore( cur )) {
            *pcur = cur;
            *file = i;
            return TRUE;
         }
      }
   }
   return FALSE;
}

static boolean parse_float	(	const char **	pcur,
		float *	val
	)			[static]

Definition at line 114 of file tgsi_text.c.

References FALSE, is_digit(), TRUE, and uprcase().

{
   const char *cur = *pcur;
   boolean integral_part = FALSE;
   boolean fractional_part = FALSE;

   *val = (float) atof( cur );

   if (*cur == '-' || *cur == '+')
      cur++;
   if (is_digit( cur )) {
      cur++;
      integral_part = TRUE;
      while (is_digit( cur ))
         cur++;
   }
   if (*cur == '.') {
      cur++;
      if (is_digit( cur )) {
         cur++;
         fractional_part = TRUE;
         while (is_digit( cur ))
            cur++;
      }
   }
   if (!integral_part && !fractional_part)
      return FALSE;
   if (uprcase( *cur ) == 'E') {
      cur++;
      if (*cur == '-' || *cur == '+')
         cur++;
      if (is_digit( cur )) {
         cur++;
         while (is_digit( cur ))
            cur++;
      }
      else
         return FALSE;
   }
   *pcur = cur;
   return TRUE;
}

static boolean parse_header

(

struct translate_ctx *

ctx

)

[static]

Definition at line 178 of file tgsi_text.c.

References translate_ctx::cur, FALSE, translate_ctx::header, report_error(), str_match_no_case(), tgsi_build_header(), tgsi_build_processor(), tgsi_build_version(), TGSI_PROCESSOR_FRAGMENT, TGSI_PROCESSOR_GEOMETRY, TGSI_PROCESSOR_VERTEX, translate_ctx::tokens_cur, translate_ctx::tokens_end, and TRUE.

{
   uint processor;

   if (str_match_no_case( &ctx->cur, "FRAG1.1" ))
      processor = TGSI_PROCESSOR_FRAGMENT;
   else if (str_match_no_case( &ctx->cur, "VERT1.1" ))
      processor = TGSI_PROCESSOR_VERTEX;
   else if (str_match_no_case( &ctx->cur, "GEOM1.1" ))
      processor = TGSI_PROCESSOR_GEOMETRY;
   else {
      report_error( ctx, "Unknown header" );
      return FALSE;
   }

   if (ctx->tokens_cur >= ctx->tokens_end)
      return FALSE;
   *(struct tgsi_version *) ctx->tokens_cur++ = tgsi_build_version();

   if (ctx->tokens_cur >= ctx->tokens_end)
      return FALSE;
   ctx->header = (struct tgsi_header *) ctx->tokens_cur++;
   *ctx->header = tgsi_build_header();

   if (ctx->tokens_cur >= ctx->tokens_end)
      return FALSE;
   *(struct tgsi_processor *) ctx->tokens_cur++ = tgsi_build_processor( processor, ctx->header );

   return TRUE;
}

static boolean parse_immediate

(

struct translate_ctx *

ctx

)

[static]

Definition at line 983 of file tgsi_text.c.

References translate_ctx::cur, tgsi_immediate::DataType, eat_opt_white(), eat_white(), FALSE, translate_ctx::header, tgsi_full_immediate::Immediate, is_digit_alpha_underscore(), parse_float(), tgsi_full_immediate::Pointer, report_error(), tgsi_immediate::Size, str_match_no_case(), tgsi_build_full_immediate(), tgsi_default_full_immediate(), TGSI_IMM_FLOAT32, translate_ctx::tokens_cur, translate_ctx::tokens_end, TRUE, and tgsi_full_immediate::u.

{
   struct tgsi_full_immediate imm;
   uint i;
   float values[4];
   uint advance;

   if (!eat_white( &ctx->cur )) {
      report_error( ctx, "Syntax error" );
      return FALSE;
   }
   if (!str_match_no_case( &ctx->cur, "FLT32" ) || is_digit_alpha_underscore( ctx->cur )) {
      report_error( ctx, "Expected `FLT32'" );
      return FALSE;
   }
   eat_opt_white( &ctx->cur );
   if (*ctx->cur != '{') {
      report_error( ctx, "Expected `{'" );
      return FALSE;
   }
   ctx->cur++;
   for (i = 0; i < 4; i++) {
      eat_opt_white( &ctx->cur );
      if (i > 0) {
         if (*ctx->cur != ',') {
            report_error( ctx, "Expected `,'" );
            return FALSE;
         }
         ctx->cur++;
         eat_opt_white( &ctx->cur );
      }
      if (!parse_float( &ctx->cur, &values[i] )) {
         report_error( ctx, "Expected literal floating point" );
         return FALSE;
      }
   }
   eat_opt_white( &ctx->cur );
   if (*ctx->cur != '}') {
      report_error( ctx, "Expected `}'" );
      return FALSE;
   }
   ctx->cur++;

   imm = tgsi_default_full_immediate();
   imm.Immediate.Size += 4;
   imm.Immediate.DataType = TGSI_IMM_FLOAT32;
   imm.u.Pointer = values;

   advance = tgsi_build_full_immediate(
      &imm,
      ctx->tokens_cur,
      ctx->header,
      (uint) (ctx->tokens_end - ctx->tokens_cur) );
   if (advance == 0)
      return FALSE;
   ctx->tokens_cur += advance;

   return TRUE;
}

static boolean parse_instruction	(	struct translate_ctx *	ctx,
		boolean	has_label
	)			[static]

Definition at line 745 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), eat_white(), FALSE, tgsi_full_instruction::FullDstRegisters, tgsi_full_instruction::FullSrcRegisters, translate_ctx::header, tgsi_full_instruction::Instruction, tgsi_full_instruction::InstructionExtLabel, tgsi_full_instruction::InstructionExtTexture, tgsi_opcode_info::is_branch, is_digit_alpha_underscore(), tgsi_opcode_info::is_tex, tgsi_instruction_ext_label::Label, tgsi_opcode_info::mnemonic, tgsi_opcode_info::num_dst, tgsi_opcode_info::num_src, tgsi_instruction::NumDstRegs, tgsi_instruction::NumSrcRegs, tgsi_instruction::Opcode, parse_dst_operand(), parse_src_operand(), parse_uint(), report_error(), tgsi_instruction::Saturate, str_match_no_case(), tgsi_instruction_ext_texture::Texture, texture_names, tgsi_build_full_instruction(), tgsi_default_full_instruction(), tgsi_get_opcode_info(), TGSI_OPCODE_LAST, TGSI_SAT_MINUS_PLUS_ONE, TGSI_SAT_NONE, TGSI_SAT_ZERO_ONE, TGSI_TEXTURE_COUNT, translate_ctx::tokens_cur, translate_ctx::tokens_end, and TRUE.

{
   uint i;
   uint saturate = TGSI_SAT_NONE;
   const struct tgsi_opcode_info *info;
   struct tgsi_full_instruction inst;
   uint advance;

   /* Parse instruction name.
    */
   eat_opt_white( &ctx->cur );
   for (i = 0; i < TGSI_OPCODE_LAST; i++) {
      const char *cur = ctx->cur;

      info = tgsi_get_opcode_info( i );
      if (str_match_no_case( &cur, info->mnemonic )) {
         if (str_match_no_case( &cur, "_SATNV" ))
            saturate = TGSI_SAT_MINUS_PLUS_ONE;
         else if (str_match_no_case( &cur, "_SAT" ))
            saturate = TGSI_SAT_ZERO_ONE;

         if (info->num_dst + info->num_src + info->is_tex == 0) {
            if (!is_digit_alpha_underscore( cur )) {
               ctx->cur = cur;
               break;
            }
         }
         else if (*cur == '\0' || eat_white( &cur )) {
            ctx->cur = cur;
            break;
         }
      }
   }
   if (i == TGSI_OPCODE_LAST) {
      if (has_label)
         report_error( ctx, "Unknown opcode" );
      else
         report_error( ctx, "Expected `DCL', `IMM' or a label" );
      return FALSE;
   }

   inst = tgsi_default_full_instruction();
   inst.Instruction.Opcode = i;
   inst.Instruction.Saturate = saturate;
   inst.Instruction.NumDstRegs = info->num_dst;
   inst.Instruction.NumSrcRegs = info->num_src;

   /* Parse instruction operands.
    */
   for (i = 0; i < info->num_dst + info->num_src + info->is_tex; i++) {
      if (i > 0) {
         eat_opt_white( &ctx->cur );
         if (*ctx->cur != ',') {
            report_error( ctx, "Expected `,'" );
            return FALSE;
         }
         ctx->cur++;
         eat_opt_white( &ctx->cur );
      }

      if (i < info->num_dst) {
         if (!parse_dst_operand( ctx, &inst.FullDstRegisters[i] ))
            return FALSE;
      }
      else if (i < info->num_dst + info->num_src) {
         if (!parse_src_operand( ctx, &inst.FullSrcRegisters[i - info->num_dst] ))
            return FALSE;
      }
      else {
         uint j;

         for (j = 0; j < TGSI_TEXTURE_COUNT; j++) {
            if (str_match_no_case( &ctx->cur, texture_names[j] )) {
               if (!is_digit_alpha_underscore( ctx->cur )) {
                  inst.InstructionExtTexture.Texture = j;
                  break;
               }
            }
         }
         if (j == TGSI_TEXTURE_COUNT) {
            report_error( ctx, "Expected texture target" );
            return FALSE;
         }
      }
   }

   if (info->is_branch) {
      uint target;

      eat_opt_white( &ctx->cur );
      if (*ctx->cur != ':') {
         report_error( ctx, "Expected `:'" );
         return FALSE;
      }
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      if (!parse_uint( &ctx->cur, &target )) {
         report_error( ctx, "Expected a label" );
         return FALSE;
      }
      inst.InstructionExtLabel.Label = target;
   }

   advance = tgsi_build_full_instruction(
      &inst,
      ctx->tokens_cur,
      ctx->header,
      (uint) (ctx->tokens_end - ctx->tokens_cur) );
   if (advance == 0)
      return FALSE;
   ctx->tokens_cur += advance;

   return TRUE;
}

static boolean parse_label	(	struct translate_ctx *	ctx,
		uint *	val
	)			[static]

Definition at line 209 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, parse_uint(), and TRUE.

{
   const char *cur = ctx->cur;

   if (parse_uint( &cur, val )) {
      eat_opt_white( &cur );
      if (*cur == ':') {
         cur++;
         ctx->cur = cur;
         return TRUE;
      }
   }
   return FALSE;
}

static boolean parse_opt_writemask	(	struct translate_ctx *	ctx,
		uint *	writemask
	)			[static]

Definition at line 257 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, report_error(), TGSI_WRITEMASK_NONE, TGSI_WRITEMASK_W, TGSI_WRITEMASK_X, TGSI_WRITEMASK_XYZW, TGSI_WRITEMASK_Y, TGSI_WRITEMASK_Z, TRUE, and uprcase().

{
   const char *cur;

   cur = ctx->cur;
   eat_opt_white( &cur );
   if (*cur == '.') {
      cur++;
      *writemask = TGSI_WRITEMASK_NONE;
      eat_opt_white( &cur );
      if (uprcase( *cur ) == 'X') {
         cur++;
         *writemask |= TGSI_WRITEMASK_X;
      }
      if (uprcase( *cur ) == 'Y') {
         cur++;
         *writemask |= TGSI_WRITEMASK_Y;
      }
      if (uprcase( *cur ) == 'Z') {
         cur++;
         *writemask |= TGSI_WRITEMASK_Z;
      }
      if (uprcase( *cur ) == 'W') {
         cur++;
         *writemask |= TGSI_WRITEMASK_W;
      }

      if (*writemask == TGSI_WRITEMASK_NONE) {
         report_error( ctx, "Writemask expected" );
         return FALSE;
      }

      ctx->cur = cur;
   }
   else {
      *writemask = TGSI_WRITEMASK_XYZW;
   }
   return TRUE;
}

static boolean parse_optional_swizzle	(	struct translate_ctx *	ctx,
		uint	swizzle[4],
		boolean *	parsed_swizzle,
		boolean *	parsed_extswizzle
	)			[static]

Definition at line 509 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, report_error(), TGSI_EXTSWIZZLE_ONE, TGSI_EXTSWIZZLE_ZERO, TGSI_SWIZZLE_W, TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Z, TRUE, and uprcase().

{
   const char *cur = ctx->cur;

   *parsed_swizzle = FALSE;
   *parsed_extswizzle = FALSE;

   eat_opt_white( &cur );
   if (*cur == '.') {
      uint i;

      cur++;
      eat_opt_white( &cur );
      for (i = 0; i < 4; i++) {
         if (uprcase( *cur ) == 'X')
            swizzle[i] = TGSI_SWIZZLE_X;
         else if (uprcase( *cur ) == 'Y')
            swizzle[i] = TGSI_SWIZZLE_Y;
         else if (uprcase( *cur ) == 'Z')
            swizzle[i] = TGSI_SWIZZLE_Z;
         else if (uprcase( *cur ) == 'W')
            swizzle[i] = TGSI_SWIZZLE_W;
         else {
            if (*cur == '0')
               swizzle[i] = TGSI_EXTSWIZZLE_ZERO;
            else if (*cur == '1')
               swizzle[i] = TGSI_EXTSWIZZLE_ONE;
            else {
               report_error( ctx, "Expected register swizzle component `x', `y', `z', `w', `0' or `1'" );
               return FALSE;
            }
            *parsed_extswizzle = TRUE;
         }
         cur++;
      }
      *parsed_swizzle = TRUE;
      ctx->cur = cur;
   }
   return TRUE;
}

static boolean parse_register_dcl	(	struct translate_ctx *	ctx,
		uint *	file,
		int *	first,
		int *	last
	)			[static]

Definition at line 427 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, parse_register_file_bracket_index(), parse_uint(), report_error(), and TRUE.

{
   if (!parse_register_file_bracket_index( ctx, file, first ))
      return FALSE;
   eat_opt_white( &ctx->cur );
   if (ctx->cur[0] == '.' && ctx->cur[1] == '.') {
      uint uindex;

      ctx->cur += 2;
      eat_opt_white( &ctx->cur );
      if (!parse_uint( &ctx->cur, &uindex )) {
         report_error( ctx, "Expected literal integer" );
         return FALSE;
      }
      *last = (int) uindex;
      eat_opt_white( &ctx->cur );
   }
   else {
      *last = *first;
   }
   if (*ctx->cur != ']') {
      report_error( ctx, "Expected `]' or `..'" );
      return FALSE;
   }
   ctx->cur++;
   return TRUE;
}

static boolean parse_register_dst	(	struct translate_ctx *	ctx,
		uint *	file,
		int *	index
	)			[static]

Definition at line 344 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, parse_register_file_bracket_index(), report_error(), and TRUE.

{
   if (!parse_register_file_bracket_index( ctx, file, index ))
      return FALSE;
   eat_opt_white( &ctx->cur );
   if (*ctx->cur != ']') {
      report_error( ctx, "Expected `]'" );
      return FALSE;
   }
   ctx->cur++;
   return TRUE;
}

static boolean parse_register_file_bracket	(	struct translate_ctx *	ctx,
		uint *	file
	)			[static]

Definition at line 302 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, parse_file(), report_error(), and TRUE.

{
   if (!parse_file( &ctx->cur, file )) {
      report_error( ctx, "Unknown register file" );
      return FALSE;
   }
   eat_opt_white( &ctx->cur );
   if (*ctx->cur != '[') {
      report_error( ctx, "Expected `['" );
      return FALSE;
   }
   ctx->cur++;
   return TRUE;
}

static boolean parse_register_file_bracket_index	(	struct translate_ctx *	ctx,
		uint *	file,
		int *	index
	)			[static]

Definition at line 322 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, parse_register_file_bracket(), parse_uint(), report_error(), and TRUE.

{
   uint uindex;

   if (!parse_register_file_bracket( ctx, file ))
      return FALSE;
   eat_opt_white( &ctx->cur );
   if (!parse_uint( &ctx->cur, &uindex )) {
      report_error( ctx, "Expected literal unsigned integer" );
      return FALSE;
   }
   *index = (int) uindex;
   return TRUE;
}

static boolean parse_register_src	(	struct translate_ctx *	ctx,
		uint *	file,
		int *	index,
		uint *	ind_file,
		int *	ind_index
	)			[static]

Definition at line 367 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), FALSE, negate(), parse_file(), parse_register_dst(), parse_register_file_bracket(), parse_uint(), report_error(), TGSI_FILE_NULL, and TRUE.

{
   const char *cur;
   uint uindex;

   if (!parse_register_file_bracket( ctx, file ))
      return FALSE;
   eat_opt_white( &ctx->cur );
   cur = ctx->cur;
   if (parse_file( &cur, ind_file )) {
      if (!parse_register_dst( ctx, ind_file, ind_index ))
         return FALSE;
      eat_opt_white( &ctx->cur );
      if (*ctx->cur == '+' || *ctx->cur == '-') {
         boolean negate;

         negate = *ctx->cur == '-';
         ctx->cur++;
         eat_opt_white( &ctx->cur );
         if (!parse_uint( &ctx->cur, &uindex )) {
            report_error( ctx, "Expected literal unsigned integer" );
            return FALSE;
         }
         if (negate)
            *index = -(int) uindex;
         else
            *index = (int) uindex;
      }
      else {
         *index = 0;
      }
   }
   else {
      if (!parse_uint( &ctx->cur, &uindex )) {
         report_error( ctx, "Expected literal unsigned integer" );
         return FALSE;
      }
      *index = (int) uindex;
      *ind_file = TGSI_FILE_NULL;
      *ind_index = 0;
   }
   eat_opt_white( &ctx->cur );
   if (*ctx->cur != ']') {
      report_error( ctx, "Expected `]'" );
      return FALSE;
   }
   ctx->cur++;
   return TRUE;
}

static boolean parse_src_operand	(	struct translate_ctx *	ctx,
		struct tgsi_full_src_register *	src
	)			[static]

Definition at line 555 of file tgsi_text.c.

References tgsi_src_register_ext_mod::Absolute, assert, tgsi_src_register_ext_mod::Bias, tgsi_src_register_ext_mod::Complement, translate_ctx::cur, eat_opt_white(), tgsi_src_register_ext_swz::ExtSwizzleW, tgsi_src_register_ext_swz::ExtSwizzleX, tgsi_src_register_ext_swz::ExtSwizzleY, tgsi_src_register_ext_swz::ExtSwizzleZ, FALSE, tgsi_src_register::File, tgsi_src_register::Index, tgsi_src_register::Indirect, tgsi_src_register::Negate, tgsi_src_register_ext_mod::Negate, parse_float(), parse_optional_swizzle(), parse_register_src(), report_error(), tgsi_src_register_ext_mod::Scale2X, tgsi_full_src_register::SrcRegister, tgsi_full_src_register::SrcRegisterExtMod, tgsi_full_src_register::SrcRegisterExtSwz, tgsi_full_src_register::SrcRegisterInd, swizzle(), tgsi_src_register::SwizzleW, tgsi_src_register::SwizzleX, tgsi_src_register::SwizzleY, tgsi_src_register::SwizzleZ, TGSI_FILE_NULL, and TRUE.

{
   const char *cur;
   float value;
   uint file;
   int index;
   uint ind_file;
   int ind_index;
   uint swizzle[4];
   boolean parsed_swizzle;
   boolean parsed_extswizzle;

   if (*ctx->cur == '-') {
      cur = ctx->cur;
      cur++;
      eat_opt_white( &cur );
      if (*cur == '(') {
         cur++;
         src->SrcRegisterExtMod.Negate = 1;
         eat_opt_white( &cur );
         ctx->cur = cur;
      }
   }

   if (*ctx->cur == '|') {
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      src->SrcRegisterExtMod.Absolute = 1;
   }

   if (*ctx->cur == '-') {
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      src->SrcRegister.Negate = 1;
   }

   cur = ctx->cur;
   if (parse_float( &cur, &value )) {
      if (value == 2.0f) {
         eat_opt_white( &cur );
         if (*cur != '*') {
            report_error( ctx, "Expected `*'" );
            return FALSE;
         }
         cur++;
         if (*cur != '(') {
            report_error( ctx, "Expected `('" );
            return FALSE;
         }
         cur++;
         src->SrcRegisterExtMod.Scale2X = 1;
         eat_opt_white( &cur );
         ctx->cur = cur;
      }
   }

   if (*ctx->cur == '(') {
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      src->SrcRegisterExtMod.Bias = 1;
   }

   cur = ctx->cur;
   if (parse_float( &cur, &value )) {
      if (value == 1.0f) {
         eat_opt_white( &cur );
         if (*cur != '-') {
            report_error( ctx, "Expected `-'" );
            return FALSE;
         }
         cur++;
         if (*cur != '(') {
            report_error( ctx, "Expected `('" );
            return FALSE;
         }
         cur++;
         src->SrcRegisterExtMod.Complement = 1;
         eat_opt_white( &cur );
         ctx->cur = cur;
      }
   }

   if (!parse_register_src( ctx, &file, &index, &ind_file, &ind_index ))
      return FALSE;
   src->SrcRegister.File = file;
   src->SrcRegister.Index = index;
   if (ind_file != TGSI_FILE_NULL) {
      src->SrcRegister.Indirect = 1;
      src->SrcRegisterInd.File = ind_file;
      src->SrcRegisterInd.Index = ind_index;
   }

   /* Parse optional swizzle.
    */
   if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, &parsed_extswizzle )) {
      if (parsed_extswizzle) {
         assert( parsed_swizzle );

         src->SrcRegisterExtSwz.ExtSwizzleX = swizzle[0];
         src->SrcRegisterExtSwz.ExtSwizzleY = swizzle[1];
         src->SrcRegisterExtSwz.ExtSwizzleZ = swizzle[2];
         src->SrcRegisterExtSwz.ExtSwizzleW = swizzle[3];
      }
      else if (parsed_swizzle) {
         src->SrcRegister.SwizzleX = swizzle[0];
         src->SrcRegister.SwizzleY = swizzle[1];
         src->SrcRegister.SwizzleZ = swizzle[2];
         src->SrcRegister.SwizzleW = swizzle[3];
      }
   }

   if (src->SrcRegisterExtMod.Complement) {
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != ')') {
         report_error( ctx, "Expected `)'" );
         return FALSE;
      }
      ctx->cur++;
   }

   if (src->SrcRegisterExtMod.Bias) {
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != ')') {
         report_error( ctx, "Expected `)'" );
         return FALSE;
      }
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != '-') {
         report_error( ctx, "Expected `-'" );
         return FALSE;
      }
      ctx->cur++;
      eat_opt_white( &ctx->cur );
      if (!parse_float( &ctx->cur, &value )) {
         report_error( ctx, "Expected literal floating point" );
         return FALSE;
      }
      if (value != 0.5f) {
         report_error( ctx, "Expected 0.5" );
         return FALSE;
      }
   }

   if (src->SrcRegisterExtMod.Scale2X) {
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != ')') {
         report_error( ctx, "Expected `)'" );
         return FALSE;
      }
      ctx->cur++;
   }

   if (src->SrcRegisterExtMod.Absolute) {
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != '|') {
         report_error( ctx, "Expected `|'" );
         return FALSE;
      }
      ctx->cur++;
   }

   if (src->SrcRegisterExtMod.Negate) {
      eat_opt_white( &ctx->cur );
      if (*ctx->cur != ')') {
         report_error( ctx, "Expected `)'" );
         return FALSE;
      }
      ctx->cur++;
   }

   return TRUE;
}

static boolean parse_uint	(	const char **	pcur,
		uint *	val
	)			[static]

Definition at line 98 of file tgsi_text.c.

References FALSE, is_digit(), and TRUE.

{
   const char *cur = *pcur;

   if (is_digit( cur )) {
      *val = *cur++ - '0';
      while (is_digit( cur ))
         *val = *val * 10 + *cur++ - '0';
      *pcur = cur;
      return TRUE;
   }
   return FALSE;
}

static void report_error	(	struct translate_ctx *	ctx,
		const char *	msg
	)			[static]

Definition at line 167 of file tgsi_text.c.

References debug_printf().

{
   debug_printf( "\nError: %s", msg );
}

static boolean str_match_no_case	(	const char **	pcur,
		const char *	str
	)			[static]

Definition at line 61 of file tgsi_text.c.

References FALSE, TRUE, and uprcase().

{
   const char *cur = *pcur;

   while (*str != '\0' && *str == uprcase( *cur )) {
      str++;
      cur++;
   }
   if (*str == '\0') {
      *pcur = cur;
      return TRUE;
   }
   return FALSE;
}

boolean tgsi_text_translate	(	const char *	text,
		struct tgsi_token *	tokens,
		uint	num_tokens
	)

Definition at line 1081 of file tgsi_text.c.

References translate_ctx::cur, FALSE, translate_ctx::text, tgsi_sanity_check(), translate_ctx::tokens, translate_ctx::tokens_cur, translate_ctx::tokens_end, and translate().

{
   struct translate_ctx ctx;

   ctx.text = text;
   ctx.cur = text;
   ctx.tokens = tokens;
   ctx.tokens_cur = tokens;
   ctx.tokens_end = tokens + num_tokens;

   if (!translate( &ctx ))
      return FALSE;

   return tgsi_sanity_check( tokens );
}

static boolean translate

(

struct translate_ctx *

ctx

)

[static]

Definition at line 1043 of file tgsi_text.c.

References translate_ctx::cur, eat_opt_white(), eat_white(), FALSE, parse_declaration(), parse_header(), parse_immediate(), parse_instruction(), parse_label(), report_error(), str_match_no_case(), and TRUE.

{
   eat_opt_white( &ctx->cur );
   if (!parse_header( ctx ))
      return FALSE;

   while (*ctx->cur != '\0') {
      uint label_val = 0;

      if (!eat_white( &ctx->cur )) {
         report_error( ctx, "Syntax error" );
         return FALSE;
      }

      if (*ctx->cur == '\0')
         break;

      if (parse_label( ctx, &label_val )) {
         if (!parse_instruction( ctx, TRUE ))
            return FALSE;
      }
      else if (str_match_no_case( &ctx->cur, "DCL" )) {
         if (!parse_declaration( ctx ))
            return FALSE;
      }
      else if (str_match_no_case( &ctx->cur, "IMM" )) {
         if (!parse_immediate( ctx ))
            return FALSE;
      }
      else if (!parse_instruction( ctx, FALSE )) {
         return FALSE;
      }
   }

   return TRUE;
}

static boolean uprcase

(

char

c

)

[static]

Definition at line 54 of file tgsi_text.c.

{
   if (c >= 'a' && c <= 'z')
      return c += 'A' - 'a';
   return c;
}

---

Variable Documentation

const char* file_names[TGSI_FILE_COUNT] [static]

Initial value:

{
   "NULL",
   "CONST",
   "IN",
   "OUT",
   "TEMP",
   "SAMP",
   "ADDR",
   "IMM",
   "LOOP"
}

Definition at line 224 of file tgsi_text.c.

const char* interpolate_names[TGSI_INTERPOLATE_COUNT] [static]

Initial value:

{
   "CONSTANT",
   "LINEAR",
   "PERSPECTIVE"
}

Definition at line 873 of file tgsi_text.c.

const char* modulate_names[TGSI_MODULATE_COUNT] [static]

Initial value:

{
   "_1X",
   "_2X",
   "_4X",
   "_8X",
   "_D2",
   "_D4",
   "_D8"
}

Definition at line 459 of file tgsi_text.c.

const char* semantic_names[TGSI_SEMANTIC_COUNT] [static]

Initial value:

{
   "POSITION",
   "COLOR",
   "BCOLOR",
   "FOG",
   "PSIZE",
   "GENERIC",
   "NORMAL"
}

Definition at line 862 of file tgsi_text.c.

const char* texture_names[TGSI_TEXTURE_COUNT] [static]

Initial value:

{
   "UNKNOWN",
   "1D",
   "2D",
   "3D",
   "CUBE",
   "RECT",
   "SHADOW1D",
   "SHADOW2D",
   "SHADOWRECT"
}

Definition at line 731 of file tgsi_text.c.

---