void CAipi_ExpParser::declarator_init()
{
declarator_direct();
if( m_lookahead == EQUAL )
{
getToken();
initializer();
emit_declaration(EQUAL);
}
}
void
lp_build_tgsi_aos(LLVMBuilderRef builder,
const struct tgsi_token *tokens,
struct lp_type type,
const unsigned char swizzles[4],
LLVMValueRef consts_ptr,
const LLVMValueRef *inputs,
LLVMValueRef *outputs,
struct lp_build_sampler_aos *sampler,
const struct tgsi_shader_info *info)
{
struct lp_build_tgsi_aos_context bld;
struct tgsi_parse_context parse;
uint num_immediates = 0;
uint num_instructions = 0;
unsigned chan;
int pc = 0;
/* Setup build context */
memset(&bld, 0, sizeof bld);
lp_build_context_init(&bld.base, builder, type);
lp_build_context_init(&bld.int_bld, builder, lp_int_type(type));
for (chan = 0; chan < 4; ++chan) {
bld.swizzles[chan] = swizzles[chan];
bld.inv_swizzles[swizzles[chan]] = chan;
}
bld.inputs = inputs;
bld.outputs = outputs;
bld.consts_ptr = consts_ptr;
bld.sampler = sampler;
bld.indirect_files = info->indirect_files;
bld.instructions = (struct tgsi_full_instruction *)
MALLOC(LP_MAX_INSTRUCTIONS * sizeof(struct tgsi_full_instruction));
bld.max_instructions = LP_MAX_INSTRUCTIONS;
if (!bld.instructions) {
return;
}
tgsi_parse_init(&parse, tokens);
while (!tgsi_parse_end_of_tokens(&parse)) {
tgsi_parse_token(&parse);
switch(parse.FullToken.Token.Type) {
case TGSI_TOKEN_TYPE_DECLARATION:
/* Inputs already interpolated */
emit_declaration(&bld, &parse.FullToken.FullDeclaration);
break;
case TGSI_TOKEN_TYPE_INSTRUCTION:
{
/* save expanded instruction */
if (num_instructions == bld.max_instructions) {
struct tgsi_full_instruction *instructions;
instructions = REALLOC(bld.instructions,
bld.max_instructions
* sizeof(struct tgsi_full_instruction),
(bld.max_instructions + LP_MAX_INSTRUCTIONS)
* sizeof(struct tgsi_full_instruction));
if (!instructions) {
break;
}
bld.instructions = instructions;
bld.max_instructions += LP_MAX_INSTRUCTIONS;
}
memcpy(bld.instructions + num_instructions,
&parse.FullToken.FullInstruction,
sizeof(bld.instructions[0]));
num_instructions++;
}
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
/* simply copy the immediate values into the next immediates[] slot */
{
const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
float imm[4];
assert(size <= 4);
assert(num_immediates < LP_MAX_TGSI_IMMEDIATES);
for (chan = 0; chan < 4; ++chan) {
imm[chan] = 0.0f;
}
for (chan = 0; chan < size; ++chan) {
unsigned swizzle = bld.swizzles[chan];
imm[swizzle] = parse.FullToken.FullImmediate.u[chan].Float;
}
bld.immediates[num_immediates] =
lp_build_const_aos(type,
imm[0], imm[1], imm[2], imm[3],
NULL);
num_immediates++;
}
break;
case TGSI_TOKEN_TYPE_PROPERTY:
break;
default:
assert(0);
}
}
while (pc != -1) {
struct tgsi_full_instruction *instr = bld.instructions + pc;
const struct tgsi_opcode_info *opcode_info =
tgsi_get_opcode_info(instr->Instruction.Opcode);
if (!emit_instruction(&bld, instr, opcode_info, &pc))
_debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
opcode_info->mnemonic);
}
if (0) {
LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
LLVMValueRef function = LLVMGetBasicBlockParent(block);
debug_printf("11111111111111111111111111111 \n");
tgsi_dump(tokens, 0);
lp_debug_dump_value(function);
debug_printf("2222222222222222222222222222 \n");
}
tgsi_parse_free(&parse);
if (0) {
LLVMModuleRef module = LLVMGetGlobalParent(
LLVMGetBasicBlockParent(LLVMGetInsertBlock(bld.base.builder)));
LLVMDumpModule(module);
}
FREE(bld.instructions);
}
void CAipi_ExpParser::declarator_direct()
{
if( m_lookahead == IDENTIFIER )
{
emit_declaration(IDENTIFIER);
getToken();
}
//Function declaration
if( m_lookahead == OPEN_PARENTHESIS )
{
while( m_lookahead == OPEN_PARENTHESIS)
{
getToken();
if( m_lookahead == IDENTIFIER
|| m_lookahead == OPEN_PARENTHESIS
|| m_lookahead == OPEN_BRACKET
)
{
declarator_direct();
}
if( m_lookahead == C_VOID
|| m_lookahead == C_CHAR
|| m_lookahead == C_SHORT
|| m_lookahead == C_INT
|| m_lookahead == C_LONG
|| m_lookahead == C_FLOAT
|| m_lookahead == C_DOUBLE
)
{
parameter_list();
}
getToken();
}
}
//CString str;
//str.Format(_T("Look Ahead...%d " ), m_lookahead);
//AfxMessageBox(str);
//Array declaration
if( m_lookahead == OPEN_BRACKET )
{
getToken();
//matchToken(OPEN_BRACKET);
if( m_lookahead == DIGIT )
{
expression_atom_constant();
}
getToken();
//matchToken(CLOSE_BRACKET);
}
}
