/** * \brief Entry point. * \param argc The number of input parameters. * \param argv The input parameters. */ int main(int argc, char *argv[]) { /* the resource manager must be initialized before any * further actions are implemented */ rm_init(&resource_mgr); if (process_options(argc, argv) == 1) { rm_cleanup_resources(&resource_mgr); exit(EXIT_FAILURE); } if (cc_options.print_only_errors != 1) { printf("Input: %s\n", cc_options.input_file); printf("Output: %s\n", cc_options.output_file); printf("IR: %s\n", cc_options.ir_file); } yyin = fopen(cc_options.input_file, "r"); if (!yyin) { fprintf(stderr, "Input file could not be opened for reading. Maybe, file does not exist?"); } else { setSymbolTable(createSymbol()); yyparse(); fclose(yyin); irCode_t* ircode = NULL; if (cc_options.ir_file != NULL) { FILE *irFile; irFile = fopen(cc_options.ir_file, "w+"); // Test symbolTable print_symTab(irFile); // get ir code and print it into irFile struct func_t *func, *tmp; HASH_ITER(hh, getSymbolTable()->symFunc, func, tmp) { if (func->symbol != NULL) { fprintf(irFile, "Function %s:\n", func->id); printIRCode(irFile, func->symbol->ircode); } } fclose(irFile); } yyout = fopen(cc_options.output_file, "w+"); if (!yyout) { fprintf(stderr, "Output file could not be opened for writing. Maybe, file does not exist?"); } else { int ret = mips32gen(yyout, ircode, getSymbolTable()); if (ret != 0) { fprintf(stderr, "Error generating mips32 code with code: %d\n", ret); } fclose(yyout); } }
void TranslatorESSL::translate(TIntermNode *root, int) { TInfoSinkBase& sink = getInfoSink().obj; int shaderVer = getShaderVersion(); if (shaderVer > 100) { sink << "#version " << shaderVer << " es\n"; } writePragma(); // Write built-in extension behaviors. writeExtensionBehavior(); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(getSymbolTable(), shaderVer); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, SH_ESSL_OUTPUT); } unsigned int temporaryIndex = 0; RecordConstantPrecision(root, &temporaryIndex); // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().IsOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; if (getShaderType() == GL_FRAGMENT_SHADER) { sink << "#if defined(GL_FRAGMENT_PRECISION_HIGH)\n" << "#define webgl_emu_precision highp\n" << "#else\n" << "#define webgl_emu_precision mediump\n" << "#endif\n\n"; } else { sink << "#define webgl_emu_precision highp\n"; } getBuiltInFunctionEmulator().OutputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Write translated shader. TOutputESSL outputESSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), shaderVer, precisionEmulation); root->traverse(&outputESSL); }
void TranslatorGLSL::translate(TIntermNode *root, int) { TInfoSinkBase& sink = getInfoSink().obj; // Write GLSL version. writeVersion(root); writePragma(); // Write extension behaviour as needed writeExtensionBehavior(); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision; root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, getOutputType()); } // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().IsOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; sink << "#define webgl_emu_precision\n\n"; getBuiltInFunctionEmulator().OutputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Declare gl_FragColor and glFragData as webgl_FragColor and webgl_FragData // if it's core profile shaders and they are used. if (getShaderType() == GL_FRAGMENT_SHADER && IsGLSL130OrNewer(getOutputType())) { TFragmentOutSearcher searcher; root->traverse(&searcher); ASSERT(!(searcher.usesGlFragData() && searcher.usesGlFragColor())); if (searcher.usesGlFragColor()) { sink << "out vec4 webgl_FragColor;\n"; } if (searcher.usesGlFragData()) { sink << "out vec4 webgl_FragData[gl_MaxDrawBuffers];\n"; } } // Write translated shader. TOutputGLSL outputGLSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion(), getOutputType()); root->traverse(&outputGLSL); }
int main(){ printf("******* INTIATING COMPILER ***********\n"); //printf("Choose Relevant stage of compiler:\n"); //printf("1. Lexical Analysis\n"); //printf("2. Parsing\n"); //printf("3. Semantic Analysis\n"); //printf("4. Code Generation\n"); int choice,i; char c; if(1){ hashTable* T = build_hash(); // build the hash table to maintain state of tokens printStoreHash(T); // store hashTable in a file Dnode* DFA = buildDFA(); memset(LexicalUnits,'\0',sizeof(LexicalUnits)); lexerCode(DFA,T,LexicalUnits,tokenValue,line); printf("\nLexer tokens have been generated in Lexer Tokens.txt\n"); pnode* root=NULL; root=parse(LexicalUnits,tokenValue,line); printf("\nParse tree generated in parseTree.txt\n"); pnode* ast=getAST(root); printf("\nAbstarct Syntax Tree Generated in AbstractSyntaxTree.txt\n"); Master *sym = (Master*)malloc(sizeof (Master)); getSymbolTable(sym,ast); printf("\nSymbol Table Generated in symbolTable.txt\n"); GenerateCode(sym,ast); printf("\nCode Generation Successfull\n\n"); } return 0; }
void MatrixInit(ASTnode* ID,ASTnode* rows){ ASTnode* rowsMain=rows; int colSize,curColSize; int n=0; token bufToken; colSize=computeColSize(rows->array[0]); bufToken.lineNumber=rows->array[0]->array[0]->t.lineNumber; while(rows!=NULL){ n++; curColSize=computeColSize(rows->array[0]); rows=rows->array[1]; if(curColSize!=colSize){ semanticError(4,bufToken); return; } } SymbolTableEntryNode* t=getSymbolTableNode(ID); SymbolTable* h=getSymbolTable(ID); t->type.id.initialized=1; t->type.id.length[0]=n; t->type.id.length[1]=colSize; t->type.id.offset=h->offset; populateMatrix(t, rowsMain); h->offset+=n*colSize; //printf("Matrix t->lexeme %s, size initialized: %d %d",t->lexeme,t->type.id.length[0],t->type.id.length[1]); }
void TranslatorGLSL::translate(TIntermNode *root, int) { TInfoSinkBase& sink = getInfoSink().obj; // Write GLSL version. writeVersion(root); writePragma(); // Write extension behaviour as needed writeExtensionBehavior(); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion()); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, getOutputType()); } // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().IsOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; sink << "#define webgl_emu_precision\n\n"; getBuiltInFunctionEmulator().OutputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write translated shader. TOutputGLSL outputGLSL(sink, getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion(), getOutputType()); root->traverse(&outputGLSL); }
void StringInit(ASTnode* ID,char* lexeme){ int len=strlen(lexeme); SymbolTableEntryNode* t=getSymbolTableNode(ID); SymbolTable* h=getSymbolTable(ID); t->type.id.initialized=1; int i; for(i=0; i<len-2;i++){ t->type.id.val.stringValue[i]=lexeme[i+1]; } //printf("<String:%s>",t->type.id.val.stringValue); t->type.id.length[0]=len-2; t->type.id.offset=h->offset; h->offset+=len; //printf("String t->lexeme %s %s, size initialized: %d",t->lexeme,lexeme,t->type.id.length[0]); }
void TranslatorESSL::translate(TIntermNode* root) { TInfoSinkBase& sink = getInfoSink().obj; writePragma(); // Write built-in extension behaviors. writeExtensionBehavior(); // Write emulated built-in functions if needed. getBuiltInFunctionEmulator().OutputEmulatedFunctionDefinition( sink, getShaderType() == GL_FRAGMENT_SHADER); // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Write translated shader. TOutputESSL outputESSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion()); root->traverse(&outputESSL); }
void TranslatorGLSL::translate(TIntermNode *root, int compileOptions) { TInfoSinkBase& sink = getInfoSink().obj; // Write GLSL version. writeVersion(root); writePragma(); // Write extension behaviour as needed writeExtensionBehavior(root); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion()); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, getOutputType()); } // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().IsOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; sink << "#define webgl_emu_precision\n\n"; getBuiltInFunctionEmulator().OutputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Declare gl_FragColor and glFragData as webgl_FragColor and webgl_FragData // if it's core profile shaders and they are used. if (getShaderType() == GL_FRAGMENT_SHADER) { const bool mayHaveESSL1SecondaryOutputs = IsExtensionEnabled(getExtensionBehavior(), "GL_EXT_blend_func_extended") && getShaderVersion() == 100; const bool declareGLFragmentOutputs = IsGLSL130OrNewer(getOutputType()); bool hasGLFragColor = false; bool hasGLFragData = false; bool hasGLSecondaryFragColor = false; bool hasGLSecondaryFragData = false; for (const auto &outputVar : outputVariables) { if (declareGLFragmentOutputs) { if (outputVar.name == "gl_FragColor") { ASSERT(!hasGLFragColor); hasGLFragColor = true; continue; } else if (outputVar.name == "gl_FragData") { ASSERT(!hasGLFragData); hasGLFragData = true; continue; } } if (mayHaveESSL1SecondaryOutputs) { if (outputVar.name == "gl_SecondaryFragColorEXT") { ASSERT(!hasGLSecondaryFragColor); hasGLSecondaryFragColor = true; continue; } else if (outputVar.name == "gl_SecondaryFragDataEXT") { ASSERT(!hasGLSecondaryFragData); hasGLSecondaryFragData = true; continue; } } } ASSERT(!((hasGLFragColor || hasGLSecondaryFragColor) && (hasGLFragData || hasGLSecondaryFragData))); if (hasGLFragColor) { sink << "out vec4 webgl_FragColor;\n"; } if (hasGLFragData) { sink << "out vec4 webgl_FragData[gl_MaxDrawBuffers];\n"; } if (hasGLSecondaryFragColor) { sink << "out vec4 angle_SecondaryFragColor;\n"; } if (hasGLSecondaryFragData) { sink << "out vec4 angle_SecondaryFragData[" << getResources().MaxDualSourceDrawBuffers << "];\n"; } } // Write translated shader. TOutputGLSL outputGLSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion(), getOutputType()); root->traverse(&outputGLSL); }
void TranslatorESSL::translate(TIntermBlock *root, ShCompileOptions compileOptions, PerformanceDiagnostics * /*perfDiagnostics*/) { TInfoSinkBase &sink = getInfoSink().obj; int shaderVer = getShaderVersion(); if (shaderVer > 100) { sink << "#version " << shaderVer << " es\n"; } // Write built-in extension behaviors. writeExtensionBehavior(compileOptions); // Write pragmas after extensions because some drivers consider pragmas // like non-preprocessor tokens. writePragma(compileOptions); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(&getSymbolTable()); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, shaderVer, SH_ESSL_OUTPUT); } RecordConstantPrecision(root, &getSymbolTable()); // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().isOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; if (getShaderType() == GL_FRAGMENT_SHADER) { sink << "#if defined(GL_FRAGMENT_PRECISION_HIGH)\n" << "#define emu_precision highp\n" << "#else\n" << "#define emu_precision mediump\n" << "#endif\n\n"; } else { sink << "#define emu_precision highp\n"; } getBuiltInFunctionEmulator().outputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); if (getShaderType() == GL_COMPUTE_SHADER && isComputeShaderLocalSizeDeclared()) { const sh::WorkGroupSize &localSize = getComputeShaderLocalSize(); sink << "layout (local_size_x=" << localSize[0] << ", local_size_y=" << localSize[1] << ", local_size_z=" << localSize[2] << ") in;\n"; } if (getShaderType() == GL_GEOMETRY_SHADER_EXT) { WriteGeometryShaderLayoutQualifiers( sink, getGeometryShaderInputPrimitiveType(), getGeometryShaderInvocations(), getGeometryShaderOutputPrimitiveType(), getGeometryShaderMaxVertices()); } // Write translated shader. TOutputESSL outputESSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), &getSymbolTable(), getShaderType(), shaderVer, precisionEmulation, compileOptions); root->traverse(&outputESSL); }
int main() { //===================================================================== // Initialize variables //===================================================================== int running,n=0,arg,time=0; double dist=0,angle=0; count = 1; reg_k = 0.35; //===================================================================== // Establish connection to robot sensors and actuators. //===================================================================== if (rhdConnect('w',"localhost",ROBOTPORT)!='w'){ printf("Can't connect to rhd \n"); exit(EXIT_FAILURE); } printf("connected to robot \n"); if ((inputtable=getSymbolTable('r'))== NULL){ printf("Can't connect to rhd \n"); exit(EXIT_FAILURE); } if ((outputtable=getSymbolTable('w'))== NULL){ printf("Can't connect to rhd \n"); exit(EXIT_FAILURE); } // connect to robot I/O variables lenc=getinputref("encl",inputtable); renc=getinputref("encr",inputtable); linesensor=getinputref("linesensor",inputtable); irsensor=getinputref("irsensor",inputtable); speedl=getoutputref("speedl",outputtable); speedr=getoutputref("speedr",outputtable); resetmotorr=getoutputref("resetmotorr",outputtable); resetmotorl=getoutputref("resetmotorl",outputtable); //===================================================================== // Camera server code initialization //===================================================================== /* Create endpoint */ lmssrv.port=24919; strcpy(lmssrv.host,"127.0.0.1"); strcpy(lmssrv.name,"laserserver"); lmssrv.status=1; camsrv.port=24920; strcpy(camsrv.host,"127.0.0.1"); camsrv.config=1; strcpy(camsrv.name,"cameraserver"); camsrv.status=1; if (camsrv.config) { int errno = 0; camsrv.sockfd = socket(AF_INET, SOCK_STREAM, 0); if ( camsrv.sockfd < 0 ) { perror(strerror(errno)); fprintf(stderr," Can not make socket\n"); exit(errno); } serverconnect(&camsrv); xmldata=xml_in_init(4096,32); printf(" camera server xml initialized \n"); } //===================================================================== // LMS server code initialization //===================================================================== /* Create endpoint */ lmssrv.config=1; if (lmssrv.config) { char buf[256]; int errno = 0,len; lmssrv.sockfd = socket(AF_INET, SOCK_STREAM, 0); if ( lmssrv.sockfd < 0 ) { perror(strerror(errno)); fprintf(stderr," Can not make socket\n"); exit(errno); } serverconnect(&lmssrv); if (lmssrv.connected){ xmllaser=xml_in_init(4096,32); printf(" laserserver xml initialized \n"); len=sprintf(buf,"scanpush cmd='zoneobst'\n"); send(lmssrv.sockfd,buf,len,0); } } /* Read sensors and zero our position. */ rhdSync(); odo.w=WHEEL_SEPARATION; odo.cr=DELTA_M; odo.cl=odo.cr; odo.left_enc=lenc->data[0]; odo.right_enc=renc->data[0]; reset_odo(&odo); running=1; mission.state=ms_init; mission.oldstate=-1; reset_sen(&sen); //===================================================================== // Main program loop //===================================================================== while (running){ if (lmssrv.config && lmssrv.status && lmssrv.connected){ while ( (xml_in_fd(xmllaser,lmssrv.sockfd) >0)) xml_proca(xmllaser); } if (camsrv.config && camsrv.status && camsrv.connected){ while ( (xml_in_fd(xmldata,camsrv.sockfd) >0)) xml_proc(xmldata); } rhdSync(); odo.left_enc=lenc->data[0]; odo.right_enc=renc->data[0]; update_odo(&odo); update_sen(&sen); //===================================================================== // Mission reading function !!!!!!MAKE!!!!! //===================================================================== if(turn(-M_PI,0.5,time,&mot) == 1) running = 0; //printf("%f %f %f %f %f %d %d %d\n",sen.irarr[0],sen.irarr[1],sen.irarr[2],sen.irarr[3],sen.irarr[4]); mot.left_pos=odo.left_pos; mot.right_pos=odo.right_pos; //update_motcon(&mot); speedl->data[0]=100*mot.motorspeed_l; speedl->updated=1; speedr->data[0]=100*mot.motorspeed_r; speedr->updated=1; if (time % 100 ==0) time++; /* stop if keyboard is activated * */ ioctl(0, FIONREAD, &arg); if (arg!=0) running=0; }/* end of main control loop */ speedl->data[0]=0; speedl->updated=1; speedr->data[0]=0; speedr->updated=1; rhdSync(); rhdDisconnect(); exit(0); }
void TranslatorGLSL::translate(TIntermNode *root, ShCompileOptions compileOptions) { TInfoSinkBase& sink = getInfoSink().obj; // Write GLSL version. writeVersion(root); // Write extension behaviour as needed writeExtensionBehavior(root); // Write pragmas after extensions because some drivers consider pragmas // like non-preprocessor tokens. writePragma(compileOptions); // If flattening the global invariant pragma, write invariant declarations for built-in // variables. It should be harmless to do this twice in the case that the shader also explicitly // did this. However, it's important to emit invariant qualifiers only for those built-in // variables that are actually used, to avoid affecting the behavior of the shader. if ((compileOptions & SH_FLATTEN_PRAGMA_STDGL_INVARIANT_ALL) && getPragma().stdgl.invariantAll) { ASSERT(wereVariablesCollected()); switch (getShaderType()) { case GL_VERTEX_SHADER: sink << "invariant gl_Position;\n"; // gl_PointSize should be declared invariant in both ESSL 1.00 and 3.00 fragment // shaders if it's statically referenced. conditionallyOutputInvariantDeclaration("gl_PointSize"); break; case GL_FRAGMENT_SHADER: // The preprocessor will reject this pragma if it's used in ESSL 3.00 fragment // shaders, so we can use simple logic to determine whether to declare these // variables invariant. conditionallyOutputInvariantDeclaration("gl_FragCoord"); conditionallyOutputInvariantDeclaration("gl_PointCoord"); break; default: // Currently not reached, but leave this in for future expansion. ASSERT(false); break; } } if ((compileOptions & SH_REWRITE_TEXELFETCHOFFSET_TO_TEXELFETCH) != 0) { sh::RewriteTexelFetchOffset(root, getSymbolTable(), getShaderVersion()); } bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion()); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, getShaderVersion(), getOutputType()); } // Write emulated built-in functions if needed. if (!getBuiltInFunctionEmulator().IsOutputEmpty()) { sink << "// BEGIN: Generated code for built-in function emulation\n\n"; sink << "#define webgl_emu_precision\n\n"; getBuiltInFunctionEmulator().OutputEmulatedFunctions(sink); sink << "// END: Generated code for built-in function emulation\n\n"; } // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Declare gl_FragColor and glFragData as webgl_FragColor and webgl_FragData // if it's core profile shaders and they are used. if (getShaderType() == GL_FRAGMENT_SHADER) { const bool mayHaveESSL1SecondaryOutputs = IsExtensionEnabled(getExtensionBehavior(), "GL_EXT_blend_func_extended") && getShaderVersion() == 100; const bool declareGLFragmentOutputs = IsGLSL130OrNewer(getOutputType()); bool hasGLFragColor = false; bool hasGLFragData = false; bool hasGLSecondaryFragColor = false; bool hasGLSecondaryFragData = false; for (const auto &outputVar : outputVariables) { if (declareGLFragmentOutputs) { if (outputVar.name == "gl_FragColor") { ASSERT(!hasGLFragColor); hasGLFragColor = true; continue; } else if (outputVar.name == "gl_FragData") { ASSERT(!hasGLFragData); hasGLFragData = true; continue; } } if (mayHaveESSL1SecondaryOutputs) { if (outputVar.name == "gl_SecondaryFragColorEXT") { ASSERT(!hasGLSecondaryFragColor); hasGLSecondaryFragColor = true; continue; } else if (outputVar.name == "gl_SecondaryFragDataEXT") { ASSERT(!hasGLSecondaryFragData); hasGLSecondaryFragData = true; continue; } } } ASSERT(!((hasGLFragColor || hasGLSecondaryFragColor) && (hasGLFragData || hasGLSecondaryFragData))); if (hasGLFragColor) { sink << "out vec4 webgl_FragColor;\n"; } if (hasGLFragData) { sink << "out vec4 webgl_FragData[gl_MaxDrawBuffers];\n"; } if (hasGLSecondaryFragColor) { sink << "out vec4 angle_SecondaryFragColor;\n"; } if (hasGLSecondaryFragData) { sink << "out vec4 angle_SecondaryFragData[" << getResources().MaxDualSourceDrawBuffers << "];\n"; } } if (getShaderType() == GL_COMPUTE_SHADER && isComputeShaderLocalSizeDeclared()) { const sh::WorkGroupSize &localSize = getComputeShaderLocalSize(); sink << "layout (local_size_x=" << localSize[0] << ", local_size_y=" << localSize[1] << ", local_size_z=" << localSize[2] << ") in;\n"; } // Write translated shader. TOutputGLSL outputGLSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderType(), getShaderVersion(), getOutputType(), compileOptions); root->traverse(&outputGLSL); }
void TranslatorHLSL::translate(TIntermNode *root, int compileOptions) { const ShBuiltInResources &resources = getResources(); int numRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1; sh::AddDefaultReturnStatements(root); SeparateDeclarations(root); // TODO (oetuaho): Sequence operators should also be split in case there is dynamic indexing of // a vector or matrix as an l-value inside (RemoveDynamicIndexing transformation step generates // statements in this case). SplitSequenceOperator(root, IntermNodePatternMatcher::kExpressionReturningArray | IntermNodePatternMatcher::kUnfoldedShortCircuitExpression | IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue, getTemporaryIndex(), getSymbolTable(), getShaderVersion()); // Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf. UnfoldShortCircuitToIf(root, getTemporaryIndex()); SeparateExpressionsReturningArrays(root, getTemporaryIndex()); // Note that SeparateDeclarations needs to be run before SeparateArrayInitialization. SeparateArrayInitialization(root); // HLSL doesn't support arrays as return values, we'll need to make functions that have an array // as a return value to use an out parameter to transfer the array data instead. ArrayReturnValueToOutParameter(root, getTemporaryIndex()); if (!shouldRunLoopAndIndexingValidation(compileOptions)) { // HLSL doesn't support dynamic indexing of vectors and matrices. RemoveDynamicIndexing(root, getTemporaryIndex(), getSymbolTable(), getShaderVersion()); } // Work around D3D9 bug that would manifest in vertex shaders with selection blocks which // use a vertex attribute as a condition, and some related computation in the else block. if (getOutputType() == SH_HLSL_3_0_OUTPUT && getShaderType() == GL_VERTEX_SHADER) { sh::RewriteElseBlocks(root, getTemporaryIndex()); } bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion()); root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(getInfoSink().obj, getShaderVersion(), getOutputType()); } if ((compileOptions & SH_EXPAND_SELECT_HLSL_INTEGER_POW_EXPRESSIONS) != 0) { sh::ExpandIntegerPowExpressions(root, getTemporaryIndex()); } sh::OutputHLSL outputHLSL(getShaderType(), getShaderVersion(), getExtensionBehavior(), getSourcePath(), getOutputType(), numRenderTargets, getUniforms(), compileOptions); outputHLSL.output(root, getInfoSink().obj); mInterfaceBlockRegisterMap = outputHLSL.getInterfaceBlockRegisterMap(); mUniformRegisterMap = outputHLSL.getUniformRegisterMap(); }
void TranslatorGLSL::translate(TIntermNode* root) { TInfoSinkBase& sink = getInfoSink().obj; // Write GLSL version. writeVersion(getShaderType(), root, sink); // Write extension behaviour as needed writeExtensionBehavior(); // Write emulated built-in functions if needed. getBuiltInFunctionEmulator().OutputEmulatedFunctionDefinition( sink, false); // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Write translated shader. TOutputGLSL outputGLSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion()); root->traverse(&outputGLSL); }
ElfSymbolTable *ElfImage::symbolTable(bool preferDynamicSymbolTable) { return getSymbolTable( preferDynamicSymbolTable, _dynSymbolTable, _symbolTable); }
void TranslatorESSL::translate(TIntermNode *root, int) { TInfoSinkBase& sink = getInfoSink().obj; writePragma(); // Write built-in extension behaviors. writeExtensionBehavior(); bool precisionEmulation = getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; if (precisionEmulation) { EmulatePrecision emulatePrecision; root->traverse(&emulatePrecision); emulatePrecision.updateTree(); emulatePrecision.writeEmulationHelpers(sink, SH_ESSL_OUTPUT); } // Write emulated built-in functions if needed. getBuiltInFunctionEmulator().OutputEmulatedFunctionDefinition( sink, getShaderType() == GL_FRAGMENT_SHADER); // Write array bounds clamping emulation if needed. getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); // Write translated shader. TOutputESSL outputESSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable(), getShaderVersion(), precisionEmulation); root->traverse(&outputESSL); }