hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
108
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
67k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b450d88f447f738250d3e469f6ba87e28f67dde4 | 3,316 | cpp | C++ | src/esp/scene/SemanticScene.cpp | narekvslife/habitat-sim | 69ae4848503d5dcc74d6b5920957c1a641ef0a9b | [
"MIT"
] | 1 | 2020-08-05T22:25:02.000Z | 2020-08-05T22:25:02.000Z | src/esp/scene/SemanticScene.cpp | narekvslife/habitat-sim | 69ae4848503d5dcc74d6b5920957c1a641ef0a9b | [
"MIT"
] | null | null | null | src/esp/scene/SemanticScene.cpp | narekvslife/habitat-sim | 69ae4848503d5dcc74d6b5920957c1a641ef0a9b | [
"MIT"
] | null | null | null | // Copyright (c) Facebook, Inc. and its affiliates.
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
#include "SemanticScene.h"
#include "GibsonSemanticScene.h"
#include "Mp3dSemanticScene.h"
#include "ReplicaSemanticScene.h"
#include <algorithm>
#include <fstream>
#include <map>
#include <sophus/se3.hpp>
#include <sstream>
#include <string>
#include "esp/io/Io.h"
#include "esp/io/Json.h"
namespace esp {
namespace scene {
bool SemanticScene::
loadSemanticSceneDescriptor(const std::string& ssdFileName, SemanticScene& scene, const quatf& rotation /* = quatf::FromTwoVectors(-vec3f::UnitZ(), geo::ESP_GRAVITY) */) {
bool success = false;
bool exists = checkFileExists(ssdFileName, "loadSemanticSceneDescriptor");
if (exists) {
// TODO: we need to investigate the possibility of adding an identifying tag
// to the SSD config files.
// Try file load mechanisms for various types
// first try Mp3d
try {
// only returns false if file does not exist, or attempting to open it
// fails
// open stream and determine house format version
try {
std::ifstream ifs = std::ifstream(ssdFileName);
std::string header;
std::getline(ifs, header);
if (header.find("ASCII 1.1") != std::string::npos) {
success = buildMp3dHouse(ifs, scene, rotation);
} else if (header.find("HM3D Semantic Annotations") !=
std::string::npos) {
success = buildHM3DHouse(ifs, scene, rotation);
}
} catch (...) {
success = false;
}
if (!success) {
// if not successful then attempt to load known json files
const io::JsonDocument& jsonDoc = io::parseJsonFile(ssdFileName);
// if no error thrown, then we have loaded a json file of given name
bool hasCorrectObjects =
(jsonDoc.HasMember("objects") && jsonDoc["objects"].IsArray());
// check if also has "classes" tag, otherwise will assume it is a
// gibson file
if (jsonDoc.HasMember("classes") && jsonDoc["classes"].IsArray()) {
// attempt to load replica or replicaCAD if has classes (replicaCAD
// does not have objects in SSDescriptor)
success =
buildReplicaHouse(jsonDoc, scene, hasCorrectObjects, rotation);
} else if (hasCorrectObjects) {
// attempt to load gibson if has objects but not classes
success = buildGibsonHouse(jsonDoc, scene, rotation);
}
}
if (success) {
// if successfully loaded, return true;
return true;
}
} catch (...) {
// if error thrown, assume it is because file load attempt fails
success = false;
}
}
// should only reach here if not successfully loaded
namespace FileUtil = Cr::Utility::Directory;
// check if constructed replica file exists in directory of passed
// ssdFileName
const std::string tmpFName =
FileUtil::join(FileUtil::path(ssdFileName), "info_semantic.json");
if (FileUtil::exists(tmpFName)) {
success = scene::SemanticScene::loadReplicaHouse(tmpFName, scene);
}
return success;
} // SemanticScene::loadSemanticSceneDescriptor
} // namespace scene
} // namespace esp
| 36.43956 | 175 | 0.652895 | narekvslife |
b45133d8540bdf687d88fd16ceb45b083c6d9fde | 20,604 | cxx | C++ | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 252 | 2020-12-16T15:34:43.000Z | 2022-03-31T23:21:37.000Z | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 23 | 2020-12-20T18:02:54.000Z | 2022-03-28T16:58:32.000Z | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 42 | 2020-12-19T04:32:33.000Z | 2022-03-30T06:00:28.000Z | /* drdec3.f -- translated by f2c (version 19990311).
*/
#include <ivp_physics.hxx>
#if !( (defined(__MWERKS__) && defined(__POWERPC__)) || defined(GEKKO) )
#include <malloc.h>
#endif
#include <ivp_betterdebugmanager.hxx>
#include <geompack.hxx>
int IVP_Geompack::i_sign(int a, int b) {
int x;
x = (a >= 0 ? a : - a);
return( b >= 0 ? x : -x);
}
double IVP_Geompack::d_sign(double a, double b) {
double x;
x = (a >= 0 ? a : - a);
return( b >= 0 ? x : -x);
}
int IVP_Geompack::increase_memory(void **mem_block, int *mem_size, int size_of_element) {
//// void *new_mem = p_realloc(*mem_block, (*mem_size) * 2 * size_of_element);
#ifndef GEKKO
void *new_mem = p_realloc(*mem_block, (*mem_size + 1024) * size_of_element);
#else
void *new_mem = p_malloc( (*mem_size + 1024) * size_of_element );
#endif
if ( !new_mem ) {
return(0);
}
#ifdef GEKKO
memcpy(new_mem, mem_block, *mem_size);
#endif
*mem_block = new_mem;
return(1);
}
void IVP_Geompack::decompose(struct geompack_parameters *params) {
// Local variables
int i;
int retry_counter;
// Initializing variables
this->size_intworkarray = 12; // orig: maxiw [5000]. Should be divisible by 3 & 4!;
this->size_doubleworkarray = 12; // orig: maxwk [5000]. Should be divisible by 3 & 4!;
this->size_vcl = params->nvc + 2; // number of vertices (NOT bytesize of array!)
this->size_polyhedronfirstfaceoffset = 2; // Leave this to "2" if there will never be more than one polyhedron to decompose. <orig. maxhf [200]>
this->size_polyhedronfaceindices = 1; // number of entries (NOT bytesize of array!) <orig: maxpf [2000]>
this->size_facearrays = params->nface + 2; // <orig. maxfp [800]>
this->size_facevertexarrays = params->facep[params->nface*3]+2; // <orig. maxfv>
this->size_ev = 200;
this->hashtable_maxsize = 307;
int * n_original_vertices_out = params->nvc_out;
int * nface_out = params->nface_out;
int * n_work_vertices_out = params->nvert_out;
int * npolh_out = params->npolh_out;
double ** vcl_out = params->vcl_out;
int ** facep_out = params->facep_out;
int ** fvl_out = params->fvl_out;
*n_original_vertices_out = 0;
*nface_out = 0;
*n_work_vertices_out = 0;
*npolh_out = 0;
// TOLIN - relative tolerance used to determine TOL
// TOL - relative tolerance MAX(TOLIN,100.0D0*EPS) where
// EPS is approximation to machine epsilon
// ANGACC - min acceptable dihedral angle in degrees produced by
// a cut face
// RDACC - minimum acceptable relative distance between a cut
// plane and vertices not on plane
this->angacc = params->angacc * IVP_PI / 180.0;
this->rdacc = params->rdacc;
// Initialize some basic values
this->initcb_(params->tolin);
// allocate necessary dynamic memory
this->g_hashtable = (int *) p_calloc(this->hashtable_maxsize , sizeof(int));
this->g_intworkarray = (int *) p_calloc(this->size_intworkarray , sizeof(int)); // [5000]
this->g_doubleworkarray = (double *)p_calloc(this->size_doubleworkarray , sizeof(double)); // [5000]
this->g_polyhedronfirstfaceoffset = (int *) p_calloc(this->size_polyhedronfirstfaceoffset, sizeof(int)); // [200]
this->g_polyhedronfaceindices = (int *) p_calloc(this->size_polyhedronfaceindices , 2*sizeof(int)); // [4000]
this->g_normals = (double *)p_calloc(this->size_facearrays , 3*sizeof(double)); // [2400]
this->g_facesdata = (int *) p_calloc(this->size_facearrays , 3*sizeof(int)); // [2400]
this->g_facestype = (int *) p_calloc(this->size_facearrays , sizeof(int));
this->g_faceverticeslist = (int *) p_calloc(this->size_facevertexarrays , 6*sizeof(int)); // [21000]
this->g_edge_angles = (double *)p_calloc(this->size_facevertexarrays , sizeof(double)); // [3500]
this->g_ev = (int *) p_calloc(this->size_ev , sizeof(int));
if ( !this->g_facesdata || !this->g_facestype || !this->g_hashtable || !this->g_polyhedronfirstfaceoffset || !this->g_polyhedronfaceindices || !this->g_faceverticeslist || !this->g_intworkarray || !this->g_doubleworkarray || !this->g_edge_angles || !this->g_normals || !this->g_ev ) {
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
}
goto out_of_memory;
}
// N_ORIGINAL_VERTICES - number of original vertex coordinates (i.e. total number of polyhedron points without any duplicated points for different polygons!)
// NFACE - number of faces in decomposition
// NPOLH - number of polyhedra in decomposition
this->n_original_vertices = params->nvc;
this->nface = params->nface;
this->npolh = 1; // if changed to anything higher than 1 you will have to adjust the variable 'this->size_polyhedronfirstfaceoffset' accordingly!
// -----------------------------------------------------------------------
// Initializing polyhedral decomposition data structure.
// -----------------------------------------------------------------------
// init 'vertex coordinate list'
this->g_vcl = params->vcl;
// init 'face pointer' list (offsets for each face into faceverticeslist)
this->g_facesdata = params->facep;
// set face type for each face to ZERO
for (i=0; i<this->nface; i++) {
this->g_facestype[i] = 0;
}
this->n_work_vertices = this->g_facesdata[this->nface*3] - 1;
// face list: offsets of (face defining) points in VCL
for (i=0; i<this->n_work_vertices; i++) {
this->g_faceverticeslist[i*6] = params->fvl[i];
}
// offsets into face list for each polyhedron (we will only process ONE polyhedron!)
this->g_polyhedronfirstfaceoffset[0] = 1;
this->g_polyhedronfirstfaceoffset[1] = this->nface+1;
this->n_polyhedronfaces = this->g_polyhedronfirstfaceoffset[this->npolh] - 1;
while ( ((2+this->n_polyhedronfaces)*1) > this->size_polyhedronfaceindices ) { // 2000
int res = increase_memory((void **)&this->g_polyhedronfaceindices, &this->size_polyhedronfaceindices, 2*sizeof(int));
if ( res == 0 ) {
this->ierr = 500;
goto GEOMPACK_abort;
}
// size_polyhedronfaceindices *= 2;
this->size_polyhedronfaceindices += 1024;
}
// init 'this->g_polyhedronfaceindices' (?)... we will simply set these values to the number of the
// corresponding face.
for (i=1; i<=this->n_polyhedronfaces; i++) {
this->g_polyhedronfaceindices[(i<<1)-2] = i;
}
this->hashtable_size = min(prime_(this->n_original_vertices + 2), this->hashtable_maxsize);
// ***********************************************************************
// -----------------------------------------------------------------------
// Init data structure
// -----------------------------------------------------------------------
dsphdc_();
if (this->ierr != 0) {
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
if ( this->ierr == 500 ) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to above error.\n\n");
}
}
goto GEOMPACK_abort;
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
int n_reflex_edges;
double minimum_angle;
int mem_iwa;
int mem_dwa;
int mem_vcl;
int mem_pffl;
int mem_pfil;
int mem_fl;
int mem_fvl;
int mem_total;
// calculate some statistical values
n_reflex_edges = 0;
minimum_angle = IVP_PI * 2.0f; // set minimum angle to 2*pi
for (i=0; i<this->n_work_vertices; i++) {
if (this->g_edge_angles[i] > IVP_PI + this->tolerance) {
n_reflex_edges++;
}
if (this->g_edge_angles[i] > -1.0) {
// Computing minimum angle in convex decomposition
minimum_angle = min(minimum_angle, this->g_edge_angles[i]);
}
}
minimum_angle = minimum_angle * 180.0f / IVP_PI;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Statistics after initializing polyhedral decomposition data structure:\n");
mem_iwa = this->size_intworkarray*sizeof(int);
mem_dwa = this->size_doubleworkarray*sizeof(double);
mem_vcl = this->size_vcl*3*sizeof(double);
mem_pffl = this->size_polyhedronfirstfaceoffset*sizeof(int);
mem_pfil = this->size_polyhedronfaceindices*2*sizeof(int);
mem_fl = this->size_facearrays*sizeof(int)+this->size_facearrays*3*sizeof(int)+this->size_facearrays*3*sizeof(double);
mem_fvl = this->size_facevertexarrays*6*sizeof(int)+this->size_facevertexarrays*sizeof(double);
mem_total = mem_iwa+ mem_dwa + mem_vcl + mem_pffl + mem_pfil + mem_fl + mem_fvl;
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for int WORK ARRAY: %d bytes\n" , mem_iwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for DOUBLE WORK ARRAY: %d bytes\n" , mem_dwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for VERTEX COORDINATE LIST: %d bytes\n" , mem_vcl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FIRST FACE LIST: %d bytes\n", mem_pffl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FACE INDEX LIST: %d bytes\n", mem_pfil);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE LISTS: %d bytes\n" , mem_fl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE VERTICES LISTS: %d bytes\n" , mem_fvl);
}
else {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Total memory allocated: %d bytes\n", mem_total);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES = %d\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE = %d\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES = %d\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH = %d\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_POLYHEDRONFACES = %d\n", this->n_polyhedronfaces);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_REFLEX_EDGES = %d\n", n_reflex_edges);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "MINIMUM_ANGLE = %f\n", minimum_angle);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n");
}
}
// -----------------------------------------------------------------------
// Decompose polyhedral region into convex parts.
// -----------------------------------------------------------------------
retry_counter = 1;
Retry_convex_decomposition:
// ***********************************************************************
this->cvdec3_();
if ( (this->ierr != 0) && (this->ierr != 327) ) { // abort on error but skip "reflex edge" resolving problems
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
if ( this->ierr == 500 ) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to above error.\n\n");
}
}
goto GEOMPACK_abort;
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
int n_reflex_edges;
double minimum_angle;
int mem_iwa;
int mem_dwa;
int mem_vcl;
int mem_pffl;
int mem_pfil;
int mem_fl;
int mem_fvl;
int mem_total;
// calculate some statistical values
n_reflex_edges = 0;
minimum_angle = IVP_PI * 2.0f; // set minimum angle to 2*pi
for (i=0; i<this->n_work_vertices; i++) {
if (this->g_edge_angles[i] > IVP_PI + this->tolerance) {
n_reflex_edges++;
}
if (this->g_edge_angles[i] > -1.0) {
// Computing minimum angle in convex decomposition
minimum_angle = min(minimum_angle, this->g_edge_angles[i]);
}
}
minimum_angle = minimum_angle * 180.0f / IVP_PI;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Intermediate decomposition statistics:\n");
mem_iwa = this->size_intworkarray*sizeof(int);
mem_dwa = this->size_doubleworkarray*sizeof(double);
mem_vcl = this->size_vcl*3*sizeof(double);
mem_pffl = this->size_polyhedronfirstfaceoffset*sizeof(int);
mem_pfil = this->size_polyhedronfaceindices*2*sizeof(int);
mem_fl = this->size_facearrays*sizeof(int)+this->size_facearrays*3*sizeof(int)+this->size_facearrays*3*sizeof(double);
mem_fvl = this->size_facevertexarrays*6*sizeof(int)+this->size_facevertexarrays*sizeof(double);
mem_total = mem_iwa+ mem_dwa + mem_vcl + mem_pffl + mem_pfil + mem_fl + mem_fvl;
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for int WORK ARRAY: %d bytes\n" , mem_iwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for DOUBLE WORK ARRAY: %d bytes\n" , mem_dwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for VERTEX COORDINATE LIST: %d bytes\n" , mem_vcl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FIRST FACE LIST: %d bytes\n", mem_pffl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FACE INDEX LIST: %d bytes\n", mem_pfil);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE LISTS: %d bytes\n" , mem_fl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE VERTICES LISTS: %d bytes\n" , mem_fvl);
}
else {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Total memory allocated: %d bytes\n", mem_total);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES = %d\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE = %d\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES = %d\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH = %d\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_POLYHEDRONFACES = %d\n", this->n_polyhedronfaces);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_REFLEX_EDGES = %d\n", n_reflex_edges);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "MINIMUM_ANGLE = %f\n", minimum_angle);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n");
}
}
if (this->ierr == 327) { // unresolved reflex edge
if (retry_counter < 36) { // orig. 3
this->angacc -= IVP_PI / 36.0; // orig. 36.0
if (this->angacc > 0.0) {
this->rdacc *= 0.95;
this->ierr = 0;
retry_counter++;
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Retrying with <angacc=%f> and <rdacc=%f>\n\n", this->angacc, this->rdacc);
}
}
goto Retry_convex_decomposition;
}
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to difficulties in resolving some reflex edge(s).\n\n");
}
}
goto GEOMPACK_abort;
}
// -----------------------------------------------------------------------
// Final output.
// -----------------------------------------------------------------------
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "+++ Convex decomposition successful!\n\n");
}
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "VCL (vertex coordinate list)\n");
for (i=1; i<=this->n_original_vertices; i++) {
int j;
printf("#%d : \t", i);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%f ", this->g_vcl[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
for (i=1; i<=this->nface; i++) {
int j;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "i=%d\tfacesdata={", i);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%d ", this->g_facesdata[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "} facestype[%d]=%d\tnormals={", i-1, this->g_facestype[i-1]);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%f ", this->g_normals[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n\n");
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "FaceVertexList >>FVL<<\n");
for (i=1; i<=this->n_work_vertices; i++) {
int j;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "#%d\t", i);
for (j=1; j<=6; j++) {
switch (j) {
case 1:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "LOC = ");
break;
case 2:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "FACN = ");
break;
case 3:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "SUCC = ");
break;
case 4:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "PRED = ");
break;
case 5:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "EDGA = ");
break;
case 6:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "EDGC = ");
break;
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%d\t", this->g_faceverticeslist[j+(i*6)-7]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\t(%f Grad)\n", this->g_edge_angles[i-1]/IVP_PI*180.0);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n\n");
}
#if 0
s_wsfe(&io___90);
for (i=0; i<this->npolh; i++) {
do_fio(1, (char *)&this->g_polyhedronfirstfaceoffset[i], (ftnlen)sizeof(int));
}
e_wsfe();
s_wsfe(&io___91);
for (i__ = 1; i__ <= this->n_polyhedronfaces; i__++) {
int j;
do_fio(1, (char *)&i__, (ftnlen)sizeof(int));
for (j=1; j<=2; j++) {
do_fio(1, (char *)&this->g_polyhedronfaceindices[j + (i__ << 1) - 3], (ftnlen)
sizeof(int));
}
}
e_wsfe();
#endif
}
GEOMPACK_abort:
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Final GEOMPACK statistics:\n");
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES \t= %d (number of vertex coordinates)\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE \t= %d (number of faces in polyhedral decomposition)\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES \t= %d (number of positions used in FVL array)\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH \t= %d (number of polyhedra in decomposition)\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n\n");
}
}
*n_original_vertices_out = this->n_original_vertices;
*nface_out = this->nface;
*n_work_vertices_out = this->n_work_vertices;
*npolh_out = this->npolh;
*facep_out = &this->g_facesdata[0];
*fvl_out = &this->g_faceverticeslist[0];
*vcl_out = &this->g_vcl[0];
out_of_memory:
P_FREE(this->g_facestype);
P_FREE(this->g_hashtable);
P_FREE(this->g_polyhedronfirstfaceoffset);
P_FREE(this->g_polyhedronfaceindices);
P_FREE(this->g_intworkarray);
P_FREE(this->g_doubleworkarray);
P_FREE(this->g_edge_angles);
P_FREE(this->g_normals);
P_FREE(this->g_ev);
return;
}
| 42.04898 | 289 | 0.625315 | DannyParker0001 |
b45164c4ea436932bc0693a779e65670c40426da | 4,772 | cpp | C++ | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | 1 | 2017-05-07T00:58:10.000Z | 2017-05-07T00:58:10.000Z | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | null | null | null | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | null | null | null | /*
* Copyright (c) 2010-2012 OTClient <https://github.com/edubart/otclient>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#include "particle.h"
#include "particleaffector.h"
#include <framework/core/clock.h>
ParticleAffector::ParticleAffector()
{
m_active = false;
m_finished = false;
m_delay = 0;
m_duration = 0;
m_elapsedTime = 0;
}
void ParticleAffector::update(float elapsedTime)
{
if(m_duration >= 0 && m_elapsedTime >= m_duration + m_delay) {
m_finished = true;
return;
}
if(!m_active && m_elapsedTime > m_delay)
m_active = true;
m_elapsedTime += elapsedTime;
}
bool ParticleAffector::load(const OTMLNodePtr& node)
{
float minDelay = 0, maxDelay = 0;
float minDuration = -1, maxDuration = -1;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "delay") {
minDelay = childNode->value<float>();
maxDelay = childNode->value<float>();
}
else if(childNode->tag() == "min-delay")
minDelay = childNode->value<float>();
else if(childNode->tag() == "max-delay")
maxDelay = childNode->value<float>();
if(childNode->tag() == "duration") {
minDuration = childNode->value<float>();
maxDuration = childNode->value<float>();
}
else if(childNode->tag() == "min-duration")
minDuration = childNode->value<float>();
else if(childNode->tag() == "max-duration")
maxDuration = childNode->value<float>();
}
m_delay = Fw::randomRange(minDelay, maxDelay);
m_duration = Fw::randomRange(minDuration, maxDuration);
return true;
}
bool GravityAffector::load(const OTMLNodePtr& node)
{
if(!ParticleAffector::load(node))
return false;
m_angle = 270 * DEG_TO_RAD;
m_gravity = 9.8;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "angle")
m_angle = childNode->value<float>() * DEG_TO_RAD;
else if(childNode->tag() == "gravity")
m_gravity = childNode->value<float>();
}
return true;
}
void GravityAffector::updateParticle(const ParticlePtr& particle, float elapsedTime)
{
if(!m_active)
return;
PointF velocity = particle->getVelocity();
velocity += PointF(m_gravity * elapsedTime * cos(m_angle), m_gravity * elapsedTime * sin(m_angle));
particle->setVelocity(velocity);
}
bool AttractionAffector::load(const OTMLNodePtr& node)
{
if(!ParticleAffector::load(node))
return false;
m_acceleration = 32;
m_reduction = 0;
m_repelish = false;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "position")
m_position = childNode->value<Point>();
else if(childNode->tag() == "acceleration")
m_acceleration = childNode->value<float>();
else if(childNode->tag() == "velocity-reduction-percent")
m_reduction = childNode->value<float>();
else if(childNode->tag() == "repelish")
m_repelish = childNode->value<bool>();
}
return true;
}
void AttractionAffector::updateParticle(const ParticlePtr& particle, float elapsedTime)
{
if(!m_active)
return;
PointF pPosition = particle->getPosition();
PointF d = PointF(m_position.x - pPosition.x, pPosition.y - m_position.y);
if(d.length() == 0)
return;
PointF direction = PointF(1, 1);
if(m_repelish)
direction = PointF(-1, -1);
PointF pVelocity = particle->getVelocity() + (d / d.length() * m_acceleration * elapsedTime) * direction;
particle->setVelocity(pVelocity - pVelocity * m_reduction/100.0 * elapsedTime);
}
| 32.684932 | 109 | 0.652347 | Cayan |
b4526aed1f1dc2688cd704458b42397eafd3d59d | 8,923 | hpp | C++ | lib/boost/mpl/aux_/numeric_op.hpp | efedo/Utilogeny | 03b7e7d2650c326f8493df35c14470f21de3be78 | [
"MIT"
] | null | null | null | lib/boost/mpl/aux_/numeric_op.hpp | efedo/Utilogeny | 03b7e7d2650c326f8493df35c14470f21de3be78 | [
"MIT"
] | null | null | null | lib/boost/mpl/aux_/numeric_op.hpp | efedo/Utilogeny | 03b7e7d2650c326f8493df35c14470f21de3be78 | [
"MIT"
] | null | null | null |
#if !defined(BOOST_PP_IS_ITERATING)
///// header body
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include "Utilogeny/lib/boost/mpl/numeric_cast.hpp"
# include "Utilogeny/lib/boost/mpl/apply_wrap.hpp"
# include "Utilogeny/lib/boost/mpl/if.hpp"
# include "Utilogeny/lib/boost/mpl/tag.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/numeric_cast_utils.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/na.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/na_spec.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/lambda_support.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/msvc_eti_base.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/value_wknd.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/config/eti.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/nttp_decl.hpp"
#endif
#include "Utilogeny/lib/boost/mpl/aux_/config/static_constant.hpp"
#if defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
|| defined(BOOST_MPL_PREPROCESSING_MODE)
# include "Utilogeny/lib/boost/mpl/limits/arity.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/partial_spec_params.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/repeat.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/ext_params.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/params.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/enum.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/add.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/preprocessor/sub.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/config/ctps.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/config/eti.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/config/msvc.hpp"
# include "Utilogeny/lib/boost/mpl/aux_/config/workaround.hpp"
# include "Utilogeny/lib/boost/preprocessor/dec.hpp"
# include "Utilogeny/lib/boost/preprocessor/inc.hpp"
# include "Utilogeny/lib/boost/preprocessor/iterate.hpp"
# include "Utilogeny/lib/boost/preprocessor/cat.hpp"
#if !defined(AUX778076_OP_ARITY)
# define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY
#endif
#if !defined(AUX778076_OP_IMPL_NAME)
# define AUX778076_OP_IMPL_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_impl)
#endif
#if !defined(AUX778076_OP_TAG_NAME)
# define AUX778076_OP_TAG_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_tag)
#endif
namespace boost { namespace mpl {
template<
typename Tag1
, typename Tag2
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
, BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value
, BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value
>
struct AUX778076_OP_IMPL_NAME
: if_c<
( tag1_ > tag2_ )
#else
>
struct AUX778076_OP_IMPL_NAME
: if_c<
( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1)
> BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2)
)
#endif
, aux::cast2nd_impl< AUX778076_OP_IMPL_NAME<Tag1,Tag1>,Tag1,Tag2 >
, aux::cast1st_impl< AUX778076_OP_IMPL_NAME<Tag2,Tag2>,Tag1,Tag2 >
>::type
{
};
/// for Digital Mars C++/compilers with no CTPS/TTP support
template<> struct AUX778076_OP_IMPL_NAME<na,na>
{
template< typename U1, typename U2 > struct apply
{
typedef apply type;
BOOST_STATIC_CONSTANT(int, value = 0);
};
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< typename Tag > struct AUX778076_OP_IMPL_NAME<na,Tag>
{
template< typename U1, typename U2 > struct apply
{
typedef apply type;
BOOST_STATIC_CONSTANT(int, value = 0);
};
};
template< typename Tag > struct AUX778076_OP_IMPL_NAME<Tag,na>
{
template< typename U1, typename U2 > struct apply
{
typedef apply type;
BOOST_STATIC_CONSTANT(int, value = 0);
};
};
#else
template<> struct AUX778076_OP_IMPL_NAME<na,integral_c_tag>
{
template< typename U1, typename U2 > struct apply
{
typedef apply type;
BOOST_STATIC_CONSTANT(int, value = 0);
};
};
template<> struct AUX778076_OP_IMPL_NAME<integral_c_tag,na>
{
template< typename U1, typename U2 > struct apply
{
typedef apply type;
BOOST_STATIC_CONSTANT(int, value = 0);
};
};
#endif
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& BOOST_WORKAROUND(BOOST_MSVC, >= 1300)
template< typename T > struct AUX778076_OP_TAG_NAME
: tag<T,na>
{
};
#else
template< typename T > struct AUX778076_OP_TAG_NAME
{
typedef typename T::tag type;
};
#endif
#if AUX778076_OP_ARITY != 2
# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
# define AUX778076_OP_RIGHT_OPERAND(unused, i, N) , BOOST_PP_CAT(N, BOOST_MPL_PP_ADD(i, 2))>
# define AUX778076_OP_N_CALLS(i, N) \
BOOST_MPL_PP_REPEAT( BOOST_PP_DEC(i), BOOST_MPL_PP_REPEAT_IDENTITY_FUNC, AUX778076_OP_NAME< ) \
N1 BOOST_MPL_PP_REPEAT( BOOST_MPL_PP_SUB(i, 1), AUX778076_OP_RIGHT_OPERAND, N ) \
/**/
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename N, na)
>
struct AUX778076_OP_NAME
: AUX778076_OP_N_CALLS(AUX778076_OP_ARITY, N)
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(
AUX778076_OP_ARITY
, AUX778076_OP_NAME
, ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) )
)
};
#define BOOST_PP_ITERATION_PARAMS_1 \
(3,( BOOST_PP_DEC(AUX778076_OP_ARITY), 2, "Utilogeny/lib/boost/mpl/aux_/numeric_op.hpp" ))
#include BOOST_PP_ITERATE()
# undef AUX778076_OP_N_CALLS
# undef AUX778076_OP_RIGHT_OPERAND
# else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
/// forward declaration
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
>
struct BOOST_PP_CAT(AUX778076_OP_NAME,2);
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename N, na)
>
struct AUX778076_OP_NAME
#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
: aux::msvc_eti_base< typename if_<
#else
: if_<
#endif
is_na<N3>
, BOOST_PP_CAT(AUX778076_OP_NAME,2)<N1,N2>
, AUX778076_OP_NAME<
BOOST_PP_CAT(AUX778076_OP_NAME,2)<N1,N2>
, BOOST_MPL_PP_EXT_PARAMS(3, BOOST_PP_INC(AUX778076_OP_ARITY), N)
>
>::type
#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
>
#endif
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(
AUX778076_OP_ARITY
, AUX778076_OP_NAME
, ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) )
)
};
template<
typename N1
, typename N2
>
struct BOOST_PP_CAT(AUX778076_OP_NAME,2)
#endif
#else // AUX778076_OP_ARITY == 2
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
>
struct AUX778076_OP_NAME
#endif
#if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
: AUX778076_OP_IMPL_NAME<
typename AUX778076_OP_TAG_NAME<N1>::type
, typename AUX778076_OP_TAG_NAME<N2>::type
>::template apply<N1,N2>::type
#else
: aux::msvc_eti_base< typename apply_wrap2<
AUX778076_OP_IMPL_NAME<
typename AUX778076_OP_TAG_NAME<N1>::type
, typename AUX778076_OP_TAG_NAME<N2>::type
>
, N1
, N2
>::type >::type
#endif
{
#if AUX778076_OP_ARITY != 2
# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
AUX778076_OP_ARITY
, AUX778076_OP_NAME
, ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(2, N, na) )
)
# else
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, BOOST_PP_CAT(AUX778076_OP_NAME,2), (N1, N2))
# endif
#else
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, AUX778076_OP_NAME, (N1, N2))
#endif
};
BOOST_MPL_AUX_NA_SPEC2(2, AUX778076_OP_ARITY, AUX778076_OP_NAME)
}}
#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
///// iteration, depth == 1
// For gcc 4.4 compatability, we must include the
// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
#else // BOOST_PP_IS_ITERATING
#if BOOST_PP_ITERATION_DEPTH() == 1
# define i_ BOOST_PP_FRAME_ITERATION(1)
template<
BOOST_MPL_PP_PARAMS(i_, typename N)
>
struct AUX778076_OP_NAME<BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(i_, N, na)>
#if i_ != 2
: AUX778076_OP_N_CALLS(i_, N)
{
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
AUX778076_OP_ARITY
, AUX778076_OP_NAME
, ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(i_, N, na) )
)
};
#endif
# undef i_
#endif // BOOST_PP_ITERATION_DEPTH()
#endif // BOOST_PP_IS_ITERATING
| 28.237342 | 99 | 0.71523 | efedo |
b4528070e3ff4a83bebbad9ddb7b9137c4e8c283 | 1,225 | cpp | C++ | unit-tests/utilities/number/stabilized/test-60-percent.cpp | ksvbka/librealsense | 72ada08ab2f6e9876d47135eea12325963205a04 | [
"Apache-2.0"
] | 6,457 | 2016-01-21T03:56:07.000Z | 2022-03-31T11:57:15.000Z | unit-tests/utilities/number/stabilized/test-60-percent.cpp | ksvbka/librealsense | 72ada08ab2f6e9876d47135eea12325963205a04 | [
"Apache-2.0"
] | 8,393 | 2016-01-21T09:47:28.000Z | 2022-03-31T22:21:42.000Z | unit-tests/utilities/number/stabilized/test-60-percent.cpp | ksvbka/librealsense | 72ada08ab2f6e9876d47135eea12325963205a04 | [
"Apache-2.0"
] | 4,874 | 2016-01-21T09:20:08.000Z | 2022-03-31T15:18:00.000Z | // License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2020 Intel Corporation. All Rights Reserved.
//#cmake:add-file ../../../../common/utilities/number/stabilized-value.h
#include "../../../test.h"
#include <../common/utilities/number/stabilized-value.h>
using namespace utilities::number;
// Test group description:
// * This tests group verifies stabilized_value class.
//
// Current test description:
// * Verify if history is filled with a stable value at the required percentage , the user
// will get it when asked for even if other inputs exist in history
TEST_CASE( "get 60% stability", "[stabilized value]" )
{
stabilized_value< float > stab_value( 10 );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 55.0f ) );
CHECK_NOTHROW( stab_value.add( 60.0f ) );
CHECK_NOTHROW( stab_value.add( 60.0f ) );
CHECK_NOTHROW( stab_value.add( 60.0f ) );
CHECK_NOTHROW( stab_value.add( 60.0f ) );
CHECK( 55.0f == stab_value.get( 0.6f ) );
}
| 36.029412 | 96 | 0.675102 | ksvbka |
b453f30cb136b59fb690154bb07e569a718bb9b8 | 8,327 | cc | C++ | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 6 | 2020-02-06T01:08:55.000Z | 2020-02-11T14:44:25.000Z | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 25 | 2020-02-03T13:28:20.000Z | 2021-09-02T07:48:32.000Z | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 1 | 2020-03-03T01:44:40.000Z | 2020-03-03T01:44:40.000Z | #include "source_wrap.h"
#include <napi.h>
#include <uv.h>
#include "log_message.h"
Napi::FunctionReference Source::constructor;
Napi::Object Source::Init(Napi::Env env, Napi::Object exports) {
Napi::HandleScope scope(env);
constexpr auto name = "_Source";
Napi::Function func =
DefineClass(env,
name,
{
InstanceMethod("prepare", &Source::Prepare),
InstanceMethod("start", &Source::Start),
InstanceMethod("stop", &Source::Stop),
InstanceMethod("pause", &Source::Pause),
InstanceMethod("seek", &Source::Seek),
InstanceMethod("requestPidChannel", &Source::RequestPidChannel),
InstanceMethod("findStream", &Source::FindStream),
InstanceAccessor("datasource", &Source::dataSource, &Source::SetDataSource),
InstanceAccessor("audioPid", &Source::audioPid, nullptr),
InstanceAccessor("hasAudio", &Source::hasAudio, nullptr),
InstanceAccessor("videoPid", &Source::videoPid, nullptr),
InstanceAccessor("hasVideo", &Source::hasVideo, nullptr),
InstanceAccessor("trace", &Source::log_enabled, &Source::EnableLog),
InstanceAccessor("duration", &Source::duration, nullptr),
});
constructor = Napi::Persistent(func);
constructor.SuppressDestruct();
exports.Set(name, func);
return exports;
}
Source::Source(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Source>(info) {
if(log_enabled_) LOG(INFO) << __func__;
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
source_.reset(new gurum::Source);
}
void Source::SetDataSource(const Napi::CallbackInfo& info, const Napi::Value &value) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !value.IsString()) {
Napi::TypeError::New(env, "String expected").ThrowAsJavaScriptException();
return;
}
source_->SetDataSource(value.ToString().Utf8Value());
}
Napi::Value Source::dataSource(const Napi::CallbackInfo& info) {
return Napi::String::New(info.Env(), source_->dataSource());
}
Napi::Value Source::audioPid(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->audioPid());
}
Napi::Value Source::hasAudio(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), source_->HasAudio());
}
Napi::Value Source::videoPid(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->videoPid());
}
Napi::Value Source::hasVideo(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), source_->HasVideo());
}
Napi::Value Source::Prepare(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
auto root = Napi::Object::New(env);
auto format = Napi::Object::New(env);
const AVFormatContext *fmt = source_->Prepare();
format["native"] = Napi::External<AVFormatContext>::New(env, (AVFormatContext *)fmt);
format["duration"] = fmt->duration;
AVDictionary* meta_data = fmt->metadata;
AVDictionaryEntry* entry = NULL;
while ((entry = av_dict_get((const AVDictionary*)meta_data, "", entry, AV_DICT_IGNORE_SUFFIX))) {
format[entry->key] = entry->value;
}
root["format"] = format;
auto streams = Napi::Array::New(env, fmt->nb_streams);
for (int i = 0; i < (int)fmt->nb_streams; i++) {
auto stream = Napi::Object::New(env);
AVStream *strm = fmt->streams[i];
stream["native"] = Napi::External<AVStream>::New(env, strm);
AVCodecParameters *codec_param = strm->codecpar;
stream["duration"] = Napi::Number::New(env, strm->duration);
AVCodecID codec_id = codec_param->codec_id;
stream["codec"] = Napi::String::New(env, avcodec_get_name(codec_id));
stream["bitrate"] = Napi::Number::New(env, codec_param->bit_rate);
stream["channels"] = Napi::Number::New(env, codec_param->channels);
stream["samplerate"] = Napi::Number::New(env, codec_param->sample_rate);
AVDictionary* meta_data = strm->metadata;
while ((entry = av_dict_get((const AVDictionary*)meta_data, "", entry, AV_DICT_IGNORE_SUFFIX))) {
stream[entry->key] = Napi::String::New(env, entry->value);
}
streams[i] = stream;
}
root["streams"] = streams;
return root;
}
void Source::Start(const Napi::CallbackInfo& info) {
assert(source_);
source_->Start();
}
void Source::Stop(const Napi::CallbackInfo& info) {
assert(source_);
source_->Stop();
}
void Source::Pause(const Napi::CallbackInfo& info) {
assert(source_);
source_->Pause();
}
void Source::Seek(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !info[0].IsObject()) {
Napi::TypeError::New(env, "Object expected").ThrowAsJavaScriptException();
return;
}
Napi::Object obj = info[0].ToObject();
do {
if(!obj.HasOwnProperty("pos")) {
Napi::TypeError::New(env, "no pos").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["pos"]).IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return;
}
} while(0);
int64_t pos = (int64_t) static_cast<Napi::Value>(obj["pos"]).ToNumber();
do {
if(!obj.HasOwnProperty("backward")) {
Napi::TypeError::New(env, "no backward").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["backward"]).IsBoolean()) {
Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
return;
}
} while(0);
bool backward = static_cast<Napi::Value>(obj["backward"]).ToBoolean();
do {
if(!obj.HasOwnProperty("callback")) {
Napi::TypeError::New(env, "no callback").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["callback"]).IsFunction()) {
Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
return;
}
} while(0);
int flag = backward ? AVSEEK_FLAG_BACKWARD : 0;
assert(source_);
source_->Seek(pos, flag, [&]{
auto callback = static_cast<Napi::Value>(obj["callback"]).As<Napi::Function>();
callback.Call(env.Global(), {});
});
}
Napi::Value Source::RequestPidChannel(const Napi::CallbackInfo& info){
Napi::Env env = info.Env();
if (info.Length() <= 0) {
Napi::TypeError::New(env, "Object expected").ThrowAsJavaScriptException();
return env.Undefined();
}
Napi::Value value;
if (info[0].IsObject()) {
Napi::Object obj = info[0].ToObject();
if(!obj.HasOwnProperty("pid")) {
Napi::TypeError::New(env, "no pid").ThrowAsJavaScriptException();
return env.Undefined();
}
value = obj["pid"];
if(! value.IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
}
else if(info[0].IsNumber()) {
value = info[0].ToNumber();
}
else {
Napi::TypeError::New(env, "Object | Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
Napi::Number number = value.As<Napi::Number>();
int pid = (int) number;
auto pidchannel = source_->RequestPidChannel(pid);
assert(pidchannel);
return Napi::External<gurum::PidChannel>::New(env, pidchannel);
}
Napi::Value Source::FindStream(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !info[0].IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
int pid = (int) info[0].ToNumber();
auto stream = source_->FindStream(pid);
assert(stream);
return Napi::External<AVStream>::New(env, stream);
}
void Source::EnableLog(const Napi::CallbackInfo& info, const Napi::Value &value) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !value.IsBoolean()) {
Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
return;
}
log_enabled_ = value.ToBoolean();
if(source_) source_->EnableLog(log_enabled_);
}
Napi::Value Source::log_enabled(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), log_enabled_);
}
Napi::Value Source::duration(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->GetDuration());
} | 32.654902 | 101 | 0.646691 | gurumlab |
b45478b16a13104c236e555cd7eced9e63f7dbe1 | 5,805 | cpp | C++ | clang/test/CodeGenCXX/member-expr-references-variable.cpp | ornata/llvm-project | 494913b8b4e4bce0b3525e5569d8e486e82b9a52 | [
"Apache-2.0"
] | null | null | null | clang/test/CodeGenCXX/member-expr-references-variable.cpp | ornata/llvm-project | 494913b8b4e4bce0b3525e5569d8e486e82b9a52 | [
"Apache-2.0"
] | null | null | null | clang/test/CodeGenCXX/member-expr-references-variable.cpp | ornata/llvm-project | 494913b8b4e4bce0b3525e5569d8e486e82b9a52 | [
"Apache-2.0"
] | null | null | null | // RUN: %clang_cc1 -no-opaque-pointers -std=c++11 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
struct Agg { const char * x; const char * y; constexpr Agg() : x(0), y(0) {} };
struct Struct {
constexpr static const char *name = "foo";
constexpr static __complex float complexValue = 42.0;
static constexpr const Agg &agg = Agg();
Struct();
Struct(int x);
};
void use(int n, const char *c);
Struct *getPtr();
// CHECK: @[[STR:.*]] = private unnamed_addr constant [4 x i8] c"foo\00", align 1
void scalarStaticVariableInMemberExpr(Struct *ptr, Struct &ref) {
use(1, Struct::name);
// CHECK: call void @_Z3useiPKc(i32 noundef 1, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
Struct s;
use(2, s.name);
// CHECK: call void @_Z3useiPKc(i32 noundef 2, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
use(3, ptr->name);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 3, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
use(4, ref.name);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 4, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
use(5, Struct(2).name);
// CHECK: call void @_ZN6StructC1Ei(%struct.Struct* {{[^,]*}} %{{.*}}, i32 noundef 2)
// CHECK: call void @_Z3useiPKc(i32 noundef 5, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
use(6, getPtr()->name);
// CHECK: call noundef %struct.Struct* @_Z6getPtrv()
// CHECK: call void @_Z3useiPKc(i32 noundef 6, i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR]], i32 0, i32 0))
}
void use(int n, __complex float v);
void complexStaticVariableInMemberExpr(Struct *ptr, Struct &ref) {
use(1, Struct::complexValue);
// CHECK: store float 4.200000e+01, float* %[[coerce0:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce0]].{{.*}}, align 4
// CHECK: %[[cast0:.*]] = bitcast { float, float }* %[[coerce0]] to <2 x float>*
// CHECK: %[[vector0:.*]] = load <2 x float>, <2 x float>* %[[cast0]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 1, <2 x float> noundef %[[vector0]])
Struct s;
use(2, s.complexValue);
// CHECK: store float 4.200000e+01, float* %[[coerce1:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce1]].{{.*}}, align 4
// CHECK: %[[cast1:.*]] = bitcast { float, float }* %[[coerce1]] to <2 x float>*
// CHECK: %[[vector1:.*]] = load <2 x float>, <2 x float>* %[[cast1]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 2, <2 x float> noundef %[[vector1]])
use(3, ptr->complexValue);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: store float 4.200000e+01, float* %[[coerce2:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce2]].{{.*}}, align 4
// CHECK: %[[cast2:.*]] = bitcast { float, float }* %[[coerce2]] to <2 x float>*
// CHECK: %[[vector2:.*]] = load <2 x float>, <2 x float>* %[[cast2]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 3, <2 x float> noundef %[[vector2]])
use(4, ref.complexValue);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: store float 4.200000e+01, float* %[[coerce3:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce3]].{{.*}}, align 4
// CHECK: %[[cast3:.*]] = bitcast { float, float }* %[[coerce3]] to <2 x float>*
// CHECK: %[[vector3:.*]] = load <2 x float>, <2 x float>* %[[cast3]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 4, <2 x float> noundef %[[vector3]])
use(5, Struct(2).complexValue);
// CHECK: call void @_ZN6StructC1Ei(%struct.Struct* {{[^,]*}} %{{.*}}, i32 noundef 2)
// CHECK: store float 4.200000e+01, float* %[[coerce4:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce4]].{{.*}}, align 4
// CHECK: %[[cast4:.*]] = bitcast { float, float }* %[[coerce4]] to <2 x float>*
// CHECK: %[[vector4:.*]] = load <2 x float>, <2 x float>* %[[cast4]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 5, <2 x float> noundef %[[vector4]])
use(6, getPtr()->complexValue);
// CHECK: call noundef %struct.Struct* @_Z6getPtrv()
// CHECK: store float 4.200000e+01, float* %[[coerce5:.*]].{{.*}}, align 4
// CHECK: store float 0.000000e+00, float* %[[coerce5]].{{.*}}, align 4
// CHECK: %[[cast5:.*]] = bitcast { float, float }* %[[coerce5]] to <2 x float>*
// CHECK: %[[vector5:.*]] = load <2 x float>, <2 x float>* %[[cast5]], align 4
// CHECK: call void @_Z3useiCf(i32 noundef 6, <2 x float> noundef %[[vector5]])
}
void aggregateRefInMemberExpr(Struct *ptr, Struct &ref) {
use(1, Struct::agg.x);
// CHECK: %[[value0:.*]] = load i8*, i8** getelementptr inbounds (%struct.Agg, %struct.Agg* @_ZGRN6Struct3aggE_, i32 0, i32 0), align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 1, i8* noundef %[[value0]])
Struct s;
use(2, s.agg.x);
// CHECK: %[[value1:.*]] = load i8*, i8** getelementptr inbounds (%struct.Agg, %struct.Agg* @_ZGRN6Struct3aggE_, i32 0, i32 0), align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 2, i8* noundef %[[value1]])
use(3, ptr->agg.x);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: %[[value2:.*]] = load i8*, i8** getelementptr inbounds (%struct.Agg, %struct.Agg* @_ZGRN6Struct3aggE_, i32 0, i32 0), align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 3, i8* noundef %[[value2]])
use(4, ref.agg.x);
// CHECK: load %struct.Struct*, %struct.Struct** %{{.*}}, align 8
// CHECK: %[[value3:.*]] = load i8*, i8** getelementptr inbounds (%struct.Agg, %struct.Agg* @_ZGRN6Struct3aggE_, i32 0, i32 0), align 8
// CHECK: call void @_Z3useiPKc(i32 noundef 4, i8* noundef %[[value3]])
}
| 55.285714 | 135 | 0.618605 | ornata |
b4559a4bbfd577a4dfc79b5b8d4c42b6eb9bf1e0 | 854 | cpp | C++ | MyCurve25519/MyCurve25519/ed25519/sign.cpp | BayrakMustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 18 | 2016-04-04T16:09:17.000Z | 2017-09-02T02:55:55.000Z | MyCurve25519/MyCurve25519/ed25519/sign.cpp | bayrakmustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 12 | 2016-04-07T02:48:24.000Z | 2017-04-11T11:19:58.000Z | MyCurve25519/MyCurve25519/ed25519/sign.cpp | bayrakmustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 9 | 2017-12-06T04:16:16.000Z | 2021-06-17T09:18:47.000Z | #include "pch.h"
#include <string.h>
#include "nacl_includes\crypto_sign.h"
#include "additions\crypto_hash_sha512.h"
#include "ge.h"
#include "sc.h"
int crypto_sign(
unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk
)
{
unsigned char pk[32];
unsigned char az[64];
unsigned char nonce[64];
unsigned char hram[64];
ge_p3 R;
memmove(pk, sk + 32, 32);
crypto_hash_sha512(az, sk, 32);
az[0] &= 248;
az[31] &= 63;
az[31] |= 64;
*smlen = mlen + 64;
memmove(sm + 64, m, mlen);
memmove(sm + 32, az + 32, 32);
crypto_hash_sha512(nonce, sm + 32, mlen + 32);
memmove(sm + 32, pk, 32);
sc_reduce(nonce);
ge_scalarmult_base(&R, nonce);
ge_p3_tobytes(sm, &R);
crypto_hash_sha512(hram, sm, mlen + 64);
sc_reduce(hram);
sc_muladd(sm + 32, hram, az, nonce);
return 0;
} | 20.333333 | 49 | 0.667447 | BayrakMustafa |
b455ceae3e79cee92de6c620b0d64d23f62c6d62 | 630 | hpp | C++ | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | null | null | null | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | 1 | 2018-04-18T01:17:01.000Z | 2018-08-06T15:34:33.000Z | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | 2 | 2018-04-12T21:41:19.000Z | 2018-04-13T01:41:45.000Z | // Preprocessor Directives
#ifndef GLITTER
#define GLITTER
#pragma once
// System Headers
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <btBulletDynamicsCommon.h>
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// Reference: https://github.com/nothings/stb/blob/master/stb_image.h#L4
// To use stb_image, add this in *one* C++ source file.
// #define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
// Define Some Constants
const int mWidth = 1280;
const int mHeight = 800;
#endif //~ Glitter Header
| 24.230769 | 72 | 0.746032 | gabrielrodriguesrocha |
b45657b78fd435544b441cb78fc8c5b9c9ce44b4 | 147,876 | cpp | C++ | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 107 | 2018-08-16T05:32:52.000Z | 2022-02-11T19:44:25.000Z | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 3 | 2018-11-04T05:09:32.000Z | 2019-07-16T19:18:42.000Z | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 16 | 2018-08-21T09:45:13.000Z | 2021-12-11T03:32:15.000Z | #include <algorithm>
#include <regex>
#include "AutoSchedule.h"
#include "AutoScheduleUtils.h"
#include "ExprUsesVar.h"
#include "FindCalls.h"
#include "Func.h"
#include "IREquality.h"
#include "Inline.h"
#include "ParallelRVar.h"
#include "RealizationOrder.h"
#include "RegionCosts.h"
#include "Scope.h"
#include "Simplify.h"
#include "Util.h"
namespace Halide {
namespace Internal {
using std::deque;
using std::make_pair;
using std::map;
using std::pair;
using std::set;
using std::string;
using std::vector;
namespace {
// Substitute parameter estimates into the exprs describing the box bounds.
void substitute_estimates_box(Box &box) {
box.used = subsitute_var_estimates(box.used);
for (auto &b : box.bounds) {
b.min = subsitute_var_estimates(b.min);
b.max = subsitute_var_estimates(b.max);
}
}
// Substitute parameter estimates into the boxes in 'region'.
void substitute_estimates_region(map<string, Box> ®ion) {
for (auto &iter : region) {
substitute_estimates_box(iter.second);
}
}
// Return true if any of the box dimension is unbounded.
bool is_box_unbounded(const Box &b) {
for (size_t i = 0; i < b.size(); i++) {
if (!b[i].is_bounded()) {
return true;
}
}
return false;
}
// Helper function to simplify the upper and lower bounds of each dimension of a box.
void simplify_box(Box &b) {
for (size_t i = 0; i < b.size(); i++) {
b[i].min = simplify(b[i].min);
b[i].max = simplify(b[i].max);
}
}
// Helper function to merge the partial region map into the result region map.
void merge_regions(map<string, Box> &result, const map<string, Box> &partial) {
// Merge regions from 'partial' with an existing region in 'result'.
for (const auto ® : partial) {
auto iter = result.find(reg.first);
if (iter == result.end()) {
result.emplace(reg.first, reg.second);
} else {
merge_boxes(iter->second, reg.second);
}
}
}
// Replace all occurrences of non-alphanumeric chars in 'name' with '_'.
string get_sanitized_name(string name) {
if (isdigit(name[0])) {
name = "_" + name;
}
for (size_t i = 0; i < name.size(); ++i) {
if (!isalnum(name[i])) {
name[i] = '_';
}
}
return name;
}
// Representation of a function stage in the pipeline.
struct FStage {
Function func;
uint32_t stage_num;
FStage(Function func, uint32_t stage_num) : func(func), stage_num(stage_num) {}
bool operator==(const FStage &other_stage) const {
return (func.name() == other_stage.func.name()) &&
(stage_num == other_stage.stage_num);
}
bool operator<(const FStage &other_stage) const {
return func.name() < other_stage.func.name() ||
((func.name() == other_stage.func.name()) &&
(stage_num < other_stage.stage_num));
}
friend std::ostream& operator<<(std::ostream &stream, const FStage &s) {
if (s.stage_num == 0) {
stream << s.func.name();
} else {
stream << s.func.name() << ".update(" << (s.stage_num - 1) << ")";
}
return stream;
}
};
struct DependenceAnalysis {
// Map containing all the functions in the pipeline.
map<string, Function> env;
vector<string> order;
FuncValueBounds func_val_bounds;
struct RegionsRequiredQuery {
string f;
int stage;
set<string> prods;
bool only_regions_computed;
RegionsRequiredQuery(const string &f, int stage, const set<string> &prods,
bool only_regions_computed)
: f(f), stage(stage), prods(prods),
only_regions_computed(only_regions_computed) {}
bool operator==(const RegionsRequiredQuery &other) const {
return (f == other.f) && (stage == other.stage) && (prods == other.prods) &&
(only_regions_computed == other.only_regions_computed);
}
bool operator<(const RegionsRequiredQuery &other) const {
if (f < other.f) {
return true;
} else if (f > other.f) {
return false;
}
if (stage < other.stage) {
return true;
} else if (stage > other.stage) {
return false;
}
if (only_regions_computed < other.only_regions_computed) {
return true;
} else if (only_regions_computed > other.only_regions_computed) {
return false;
}
return prods < other.prods;
}
};
struct RegionsRequired {
DimBounds bounds;
// Regions required to compute 'bounds' given a particular
// RegionsRequiredQuery.
map<string, Box> regions;
RegionsRequired(const DimBounds &b, const map<string, Box> &r)
: bounds(b), regions(r) {}
};
// Cache for bounds queries (bound queries with the same parameters are
// common during the grouping process).
map<RegionsRequiredQuery, vector<RegionsRequired>> regions_required_cache;
DependenceAnalysis(const map<string, Function> &env, const vector<string> &order,
const FuncValueBounds &func_val_bounds)
: env(env), order(order), func_val_bounds(func_val_bounds) {}
// Return the regions of the producers ('prods') required to compute the region
// of the function stage ('f', 'stage_num') specified by 'bounds'. When
// 'only_regions_computed' is set to true, this only returns the computed
// regions and not the total allocated regions.
map<string, Box> regions_required(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return the regions of the producers ('prods') required to compute the region
// of the function specified by 'pure_bounds'. When 'only_regions_computed'
// is set to true, this only returns the computed regions and not the total
// allocated regions.
map<string, Box> regions_required(Function f,
const DimBounds &pure_bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return redundantly computed regions of producers ('prods') while computing
// a region of the function stage ('f', 'stage_num') specified by 'bounds'.
// 'var' is the dimension along which redundant computation is accounted for.
// When 'only_regions_computed' is set to true, this only returns the computed
// regions and not the total allocated regions. When 'only_regions_computed'
// is set to true, this only returns the computed regions and not the total
// allocated regions.
map<string, Box> redundant_regions(Function f, int stage_num, string var,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return overlapping regions of producers ('prods') while computing a function
// stage along each of the dimensions.
vector<map<string, Box>>
overlap_regions(Function f, int stage_num, const DimBounds &bounds,
const set<string> &prods, bool only_regions_computed,
const Scope<Interval> *input_estimates);
};
// Return the regions of the producers ('prods') required to compute the region
// of the function specified by 'pure_bounds'.
map<string, Box>
DependenceAnalysis::regions_required(Function f, const DimBounds &pure_bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Find the regions required for each stage and merge them.
map<string, Box> regions;
int num_stages = f.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
DimBounds bounds = get_stage_bounds(f, s, pure_bounds);
map<string, Box> stage_regions =
regions_required(f, s, bounds, prods, only_regions_computed, input_estimates);
merge_regions(regions, stage_regions);
}
return regions;
}
struct StageBounds {
FStage f_stage;
DimBounds bounds;
StageBounds(const FStage &fs, const DimBounds &b) : f_stage(fs), bounds(b) {}
StageBounds(Function func, uint32_t stage_num, const DimBounds &b) :
f_stage(FStage(func, stage_num)), bounds(b) {}
bool operator==(const StageBounds &other) const {
return (f_stage == other.f_stage) && (bounds == other.bounds);
}
bool operator<(const StageBounds &other) const {
return (f_stage < other.f_stage) ||
((f_stage == other.f_stage) && (bounds.size() < other.bounds.size()));
}
friend std::ostream& operator<<(std::ostream &stream, const StageBounds &s) {
stream << "Stage: " << s.f_stage << "\n";
stream << "Bounds:\n";
for (const auto &iter : s.bounds) {
stream << "\t" << iter.first << " -> [" << iter.second.min << ", " << iter.second.max << "]\n";
}
stream << "\n";
return stream;
}
};
// Helper function to queue regions that need to be traversed. 'fs_bounds' is
// the queue into which the regions specified by 'prod_func' and 'region'
// will be added.
void queue_func_regions(map<FStage, DimBounds> &fs_bounds,
const Function &prod_func, const Box ®ion,
const set<StageBounds>& visited) {
DimBounds prod_pure_bounds;
const vector<string> &args = prod_func.args();
internal_assert(region.size() == args.size());
// The region only specifies the extent of each dimension
// by position. Populating a map which is keyed by name.
for (size_t v = 0; v < args.size(); v++) {
prod_pure_bounds[args[v]] = region[v];
}
// Get the bounds of all stages in a function from the
// bounds on the pure dimensions.
vector<DimBounds> prod_bounds = get_stage_bounds(prod_func, prod_pure_bounds);
size_t num_stages = prod_func.updates().size() + 1;
internal_assert(prod_bounds.size() == num_stages);
// Add all stages of a function into the queue.
for (size_t prod_s = 0; prod_s < num_stages; prod_s++) {
StageBounds sb(prod_func, prod_s, prod_bounds[prod_s]);
if (visited.find(sb) == visited.end()) {
auto iter = fs_bounds.find(sb.f_stage);
if (iter == fs_bounds.end()) {
fs_bounds.emplace(sb.f_stage, sb.bounds);
} else {
for (const auto &b : sb.bounds) {
DimBounds &curr_bounds = iter->second;
auto b_iter = curr_bounds.find(b.first);
if (b_iter == curr_bounds.end()) {
curr_bounds.emplace(b.first, b.second);
} else {
if (b_iter->second.has_lower_bound() && b.second.has_lower_bound()) {
b_iter->second.min = simplify(Interval::make_min(b_iter->second.min, b.second.min));
} else {
b_iter->second.min = Interval::neg_inf;
}
if (b_iter->second.has_upper_bound() && b.second.has_upper_bound()) {
b_iter->second.max = simplify(Interval::make_max(b_iter->second.max, b.second.max));
} else {
b_iter->second.max = Interval::pos_inf;
}
}
}
}
}
}
}
// Helper function for merging 'curr_regions' to the global map of regions
// and adding them to the queue of regions that need to be traversed.
// 'prods' is the set of producer functions that are under consideration.
void merge_and_queue_regions(map<FStage, DimBounds> &fs_bounds,
map<string, Box> ®ions,
map<string, Box> &curr_regions,
const set<string> &prods,
const map<string, Function> &env,
bool only_regions_computed,
string curr_func_name,
const set<StageBounds>& visited) {
for (const auto ® : curr_regions) {
// Merge region with an existing region of a function in the
// global map. Do not merge the parent function itself to the region
// when querying only for the values computed.
if (!only_regions_computed || (only_regions_computed && (reg.first != curr_func_name))) {
auto iter = regions.find(reg.first);
if (iter == regions.end()) {
regions.emplace(reg.first, reg.second);
} else {
merge_boxes(iter->second, reg.second);
}
}
// Skip adding the current region into to the queue if the function
// is not in 'prods'.
if (prods.find(reg.first) == prods.end()) {
continue;
}
const auto &it = env.find(reg.first);
if ((it != env.end()) && (reg.first != curr_func_name)) {
// Add all stages of the function representing the
// region into the queue.
queue_func_regions(fs_bounds, it->second, reg.second, visited);
}
}
}
// Return the regions of the producers ('prods') required to compute the region
// of the function stage ('f', 'stage_num') specified by 'bounds'.
map<string, Box>
DependenceAnalysis::regions_required(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Iteratively compute the required regions by traversing the chain
// of dependencies.
// Check the cache if we've already computed this previously.
RegionsRequiredQuery query(f.name(), stage_num, prods, only_regions_computed);
const auto &iter = regions_required_cache.find(query);
if (iter != regions_required_cache.end()) {
const auto &it = std::find_if(iter->second.begin(), iter->second.end(),
[&bounds](const RegionsRequired &r) { return (r.bounds == bounds); });
if (it != iter->second.end()) {
internal_assert((iter->first == query) && (it->bounds == bounds));
return it->regions;
}
}
// Map of all the required regions.
map<string, Box> regions;
map<FStage, DimBounds> fs_bounds;
set<StageBounds> visited;
// Add the query function and its region to the queue.
fs_bounds.emplace(FStage(f, stage_num), bounds);
while (!fs_bounds.empty()) {
for (int i = order.size() - 1; i >= 0; --i) {
const Function &f = env.find(order[i])->second;
int num_stages = f.updates().size() + 1;
for (int stage_num = 0; stage_num < num_stages; ++stage_num) {
FStage s(f, stage_num);
const auto &iter = fs_bounds.find(s);
if (iter == fs_bounds.end()) {
continue;
}
DimBounds curr_bounds = iter->second;
visited.insert(StageBounds(s, curr_bounds));
// Scope for containing all the estimates on parameters and intervals.
Scope<Interval> curr_scope;
curr_scope.set_containing_scope(input_estimates);
// If the function has an extern definition, there is no visibility into
// the expression defining the function. So the regions required will be
// the entire domain of the inputs to the extern func. Use the estimates
// on the inputs to the extern function if available.
//
// TODO: Query the extern function for bounds of the functions which it
// it depends on. This can be done by calling the extern func in the
// bounds query mode.
if (s.func.has_extern_definition()) {
for (const ExternFuncArgument &arg : s.func.extern_arguments()) {
if (arg.is_func()) {
// If the argument is an entire function, the bounds of the
// function required are unknown. Create an infinite region
// of the correct dimension, update the region map, and
// add it to the queue.
string prod_name = Function(arg.func).name();
const Function &prod_func = get_element(env, prod_name);
map<string, Box> prod_reg;
const vector<string> &args = prod_func.args();
for (size_t v = 0; v < args.size(); v++) {
prod_reg[prod_name].push_back(Interval());
}
merge_and_queue_regions(fs_bounds, regions, prod_reg, prods, env,
only_regions_computed, s.func.name(), visited);
} else if (arg.is_expr()) {
// Find the boxes required for the expression and add the regions
// to the queue.
Expr subs_arg = subsitute_var_estimates(arg.expr);
map<string, Box> arg_regions = boxes_required(subs_arg, curr_scope, func_val_bounds);
substitute_estimates_region(arg_regions);
merge_and_queue_regions(fs_bounds, regions, arg_regions, prods, env,
only_regions_computed, s.func.name(), visited);
} else if (arg.is_image_param() || arg.is_buffer()) {
// If the argument is an image or a buffer, the required
// bounds are unknown. Create an infinite region of the
// correct dimension and update the region map.
Buffer<> buf;
if (arg.is_image_param()) {
buf = arg.image_param.buffer();
} else {
buf = arg.buffer;
}
map<string, Box> buf_reg;
for (int v = 0; v < buf.dimensions(); v++) {
buf_reg[buf.name()].push_back(Interval());
}
merge_regions(regions, buf_reg);
}
}
} else {
Definition def = get_stage_definition(s.func, s.stage_num);
const vector<Dim> &dims = def.schedule().dims();
// Substitute parameter estimates into the bounds and add them to the
// current scope.
for (int d = 0; d < (int)dims.size() - 1; d++) {
Interval simple_bounds = get_element(curr_bounds, dims[d].var);
simple_bounds.min = subsitute_var_estimates(simple_bounds.min);
simple_bounds.max = subsitute_var_estimates(simple_bounds.max);
curr_scope.push(dims[d].var, simple_bounds);
}
// Find the regions required for each value of the current function stage,
// update the region map, and add them to the queue.
for (const auto &val : def.values()) {
// Substitute the parameter estimates into the expression and get
// the regions required for the expression.
Expr subs_val = subsitute_var_estimates(val);
map<string, Box> curr_regions = boxes_required(subs_val, curr_scope, func_val_bounds);
substitute_estimates_region(curr_regions);
// Arguments to the definition may require regions of functions.
// For example, update definitions in histograms where the bin is
// based on the value of a function.
Box left_reg;
for (const Expr &arg : def.args()) {
Expr subs_arg = subsitute_var_estimates(arg);
map<string, Box> arg_regions = boxes_required(subs_arg, curr_scope, func_val_bounds);
substitute_estimates_region(arg_regions);
// Merge the regions with the regions found while looking at
// the values.
merge_regions(curr_regions, arg_regions);
Interval arg_bounds = bounds_of_expr_in_scope(arg, curr_scope, func_val_bounds);
left_reg.push_back(arg_bounds);
}
auto iter_curr = curr_regions.find(s.func.name());
if (iter_curr == curr_regions.end()) {
curr_regions.emplace(s.func.name(), left_reg);
} else {
merge_boxes(iter_curr->second, left_reg);
}
// Update the region map, and add 'curr_regions' to the queue.
merge_and_queue_regions(fs_bounds, regions, curr_regions, prods, env,
only_regions_computed, s.func.name(), visited);
}
}
// Remove processed region from the queue.
fs_bounds.erase(iter);
}
}
}
// Simplify the bounds on each region and substitute global pipeline
// bounds for function regions which lower and upper bounds could not be
// determined.
map<string, Box> concrete_regions;
for (auto &f_reg : regions) {
simplify_box(f_reg.second);
Box concrete_box;
for (size_t i = 0; i < f_reg.second.size(); i++) {
Expr lower = f_reg.second[i].min;
Expr upper = f_reg.second[i].max;
auto iter = env.find(f_reg.first);
bool in_env = (iter != env.end());
if (!lower.as<IntImm>() && in_env) {
const Function &curr_f = iter->second;
for (const auto &b : curr_f.schedule().estimates()) {
size_t num_pure_args = curr_f.args().size();
if ((i < num_pure_args) && (b.var == curr_f.args()[i])) {
lower = b.min;
}
}
}
if (!upper.as<IntImm>() && in_env) {
const Function &curr_f = iter->second;
for (const auto &b : curr_f.schedule().estimates()) {
size_t num_pure_args = curr_f.args().size();
if ((i < num_pure_args) && (b.var == curr_f.args()[i])) {
const IntImm *bmin = b.min.as<IntImm>();
const IntImm *bextent = b.extent.as<IntImm>();
upper = IntImm::make(Int(32), bmin->value + bextent->value - 1);
}
}
}
Interval concrete_bounds = Interval(lower, upper);
concrete_box.push_back(concrete_bounds);
}
concrete_regions[f_reg.first] = concrete_box;
}
regions_required_cache[query].push_back(RegionsRequired(bounds, concrete_regions));
return concrete_regions;
}
// Return redundantly computed regions of producers ('prods') while computing a
// region of the function stage ('f', 'stage_num') specified by 'bounds'. 'var'
// is the dimension along which redundant computation is accounted for.
map<string, Box>
DependenceAnalysis::redundant_regions(Function f, int stage_num, string var,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Find the regions required to compute the region of 'f' specified
// by 'bounds'.
map<string, Box> regions = regions_required(
f, stage_num, bounds, prods, only_regions_computed, input_estimates);
// Shift the bounds by the size of the interval along the direction
// of var.
DimBounds shifted_bounds;
for (const auto &b : bounds) {
if (b.first == var) {
Expr len = b.second.max - b.second.min + 1;
Interval bound = Interval(b.second.min + len, b.second.max + len);
shifted_bounds[b.first] = bound;
} else {
shifted_bounds[b.first] = b.second;
}
}
// Find the regions required to compute the region of f specified
// by shifted_bounds.
map<string, Box> regions_shifted = regions_required(
f, stage_num, shifted_bounds, prods, only_regions_computed, input_estimates);
// Compute the overlaps between 'regions_shifted' and the original
// regions required.
map<string, Box> overlaps;
for (const auto ® : regions) {
auto iter = regions_shifted.find(reg.first);
if (iter == regions.end()) {
// It will be interesting to log cases where this actually happens
// i.e., the shifted regions do not contain a function that was
// there in the original regions.
continue;
}
const Box &b = reg.second;
const Box &b_shifted = iter->second;
// The boxes should be of the same size.
internal_assert(b.size() == b_shifted.size());
Box b_intersect;
for (uint32_t i = 0 ; i < b.size(); i++) {
b_intersect.push_back(Interval::make_intersection(b[i], b_shifted[i]));
}
// A function should appear once in the regions and therefore cannot
// already be present in the overlaps map.
internal_assert(overlaps.find(reg.first) == overlaps.end());
overlaps.emplace(reg.first, b_intersect);
}
// Simplify the bounds of each of the overlap regions.
for (auto &f : overlaps) {
simplify_box(f.second);
}
return overlaps;
}
// Return overlapping regions of producers ('prods') while computing a function
// stage along each of the dimensions.
vector<map<string, Box>>
DependenceAnalysis::overlap_regions(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
vector<map<string, Box>> conc_overlaps;
const vector<Dim> &dims = get_stage_dims(f, stage_num);
// Get the redundant regions along each dimension of f.
for (int d = 0; d < (int)dims.size() - 1; d++) {
map<string, Box> conc_reg = redundant_regions(f, stage_num, dims[d].var, bounds,
prods, only_regions_computed, input_estimates);
conc_overlaps.push_back(conc_reg);
}
return conc_overlaps;
}
// Return the regions of each function required for computing the
// outputs of the pipeline.
map<string, Box> get_pipeline_bounds(DependenceAnalysis &analysis,
const vector<Function> &outputs,
const Scope<Interval> *input_estimates) {
map<string, Box> pipeline_bounds;
// Find the regions required for each of the outputs and merge them
// to compute the full pipeline_bounds.
for (const auto &out : outputs) {
DimBounds pure_bounds;
Box out_box;
// Use the estimates on the output for determining the output bounds.
// If there are duplicates, use the most recent estimate.
const auto &estimates = out.schedule().estimates();
for (const auto &arg : out.args()) {
int i;
for (i = estimates.size() - 1; i >= 0; --i) {
const auto &est = estimates[i];
if ((est.var == arg) && est.min.defined() && est.extent.defined()) {
Interval in = Interval(est.min, simplify(est.min + est.extent - 1));
pure_bounds.emplace(arg, in);
out_box.push_back(in);
break;
}
}
internal_assert(i >= 0) << "Could not find estimate for " << arg << "\n";
}
set<string> prods;
for (const pair<string, Function> &fpair : analysis.env) {
prods.insert(fpair.first);
}
map<string, Box> regions = analysis.regions_required(out, pure_bounds, prods,
false, input_estimates);
// Add the output region to the pipeline bounds as well.
regions.emplace(out.name(), out_box);
merge_regions(pipeline_bounds, regions);
}
return pipeline_bounds;
}
struct AutoSchedule {
struct Stage {
string function;
size_t stage;
Stage(const string &f, size_t s) : function(f), stage(s) {}
bool operator==(const Stage &other) const {
return (function == other.function) && (stage == other.stage);
}
bool operator<(const Stage &other) const {
return (function < other.function) || ((function == other.function) && (stage < other.stage));
}
};
const map<string, Function> &env;
// Contain maps from function name to the topological order of the pipeline.
map<string, size_t> topological_order;
// Cache for storing all internal vars/rvars that have been declared during
// the course of schedule generation, to ensure that we don't introduce any
// duplicates in the string representation of the schedules.
map<string, VarOrRVar> internal_vars;
// Store the list of schedules applied to some function stages (most recent
// schedule is placed last in the list).
map<string, map<int, vector<string>>> func_schedules;
// Store the list of vars/rvars used in the schedule applied to some
// function stages.
map<string, map<int, set<string>>> used_vars;
AutoSchedule(const map<string, Function> &env, const vector<string> &order) : env(env) {
for (size_t i = 0; i < order.size(); ++i) {
topological_order.emplace(order[i], i);
}
// Allocate a slot in 'used_vars' for each function stages in the pipeline
for (const auto &iter : env) {
for (size_t i = 0; i < iter.second.updates().size() + 1; ++i) {
used_vars[iter.first][i];
}
}
}
// Given a function name, return a string representation of getting the
// function handle
string get_func_handle(const string &name) const {
size_t index = get_element(topological_order, name);
return "pipeline.get_func(" + std::to_string(index) + ")";
}
friend std::ostream& operator<<(std::ostream &stream, const AutoSchedule &sched) {
stream << "// Delete this line if not using Generator\n";
stream << "Pipeline pipeline = get_pipeline();\n\n";
for (const auto &iter : sched.internal_vars) {
if (iter.second.is_rvar) {
stream << "RVar ";
} else {
stream << "Var ";
}
stream << iter.first << "(\"" << iter.first << "\");\n";
}
stream << "\n";
// Declare all the functions + schedules
std::ostringstream func_ss;
std::ostringstream schedule_ss;
for (const auto &f : sched.func_schedules) {
const string &fname = get_sanitized_name(f.first);
func_ss << "Func " << fname << " = " << sched.get_func_handle(f.first) << ";\n";
schedule_ss << "{\n";
// Declare all the Vars and RVars that are actually used in the schedule
const Function &func = get_element(sched.env, f.first);
for (size_t i = 0; i < func.args().size(); ++i) {
if (sched.used_vars.at(func.name()).at(0).find(func.args()[i])
!= sched.used_vars.at(func.name()).at(0).end()) {
schedule_ss << " Var " << func.args()[i] << " = "
<< fname << ".args()[" << i << "];\n";
}
}
set<string> declared_rvars;
for (size_t i = 0; i < func.updates().size(); ++i) {
const vector<ReductionVariable> &rvars = func.updates()[i].schedule().rvars();
const set<string> &var_list = sched.used_vars.at(func.name()).at(i+1);
for (size_t j = 0; j < rvars.size(); ++j) {
if ((var_list.find(rvars[j].var) == var_list.end()) ||
(declared_rvars.find(rvars[j].var) != declared_rvars.end())) {
continue;
}
declared_rvars.insert(rvars[j].var);
schedule_ss << " RVar " << rvars[j].var << "("
<< fname << ".update(" << i << ").get_schedule().rvars()[" << j << "].var);\n";
}
}
for (const auto &s : f.second) {
internal_assert(!s.second.empty());
schedule_ss << " " << fname;
if (s.first > 0) {
schedule_ss << ".update(" << std::to_string(s.first - 1) << ")";
}
for (size_t i = 0; i < s.second.size(); ++i) {
schedule_ss << "\n ." << s.second[i];
}
schedule_ss << ";\n";
}
schedule_ss << "}\n";
}
stream << func_ss.str() << "\n";
stream << schedule_ss.str() << "\n";
return stream;
}
void push_schedule(const string &stage_name, size_t stage_num,
const string &sched, const set<string> &vars) {
vector<string> v = split_string(stage_name, ".");
internal_assert(!v.empty());
used_vars[v[0]][stage_num].insert(vars.begin(), vars.end());
// If the previous schedule applied is the same as this one,
// there is no need to re-apply the schedule
auto &schedules = func_schedules[v[0]][stage_num];
if (schedules.empty()) {
schedules.push_back(sched);
} else {
if (schedules[schedules.size()-1] != sched) {
schedules.push_back(sched);
}
}
}
};
// Implement the grouping algorithm and the cost model for making the grouping
// choices.
struct Partitioner {
// GroupingChoice encodes the grouping of the 'prod' function into the 'cons' stage.
struct GroupingChoice {
string prod;
FStage cons;
GroupingChoice(const string &prod, const FStage &cons) : prod(prod), cons(cons) {}
bool operator==(const GroupingChoice &other) const {
return (prod == other.prod) && (cons == other.cons);
}
bool operator<(const GroupingChoice &other) const {
return (prod < other.prod) || ((prod == other.prod) && (cons < other.cons));
}
friend std::ostream& operator<<(std::ostream &stream, const GroupingChoice &choice) {
stream << "Choice: " << choice.prod << " -> " << choice.cons << '\n';
return stream;
}
};
// A group is a sub-pipeline with a single output. Members of a group are
// either inlined into the consumer functions within the group or computed
// at tiles of the output, specified by 'tile_sizes'.
//
// TODO: The restriction of computing either at the inline or tile level
// makes the space of scheduling choices for a group very tractable.
// However, the restriction might miss good schedules which can only be
// realized by computing the members of the group at different levels of
// the group.
//
// There are two approaches to extend the space of schedules considered:
// 1) Recursive grouping: Treat the problem of determining the compute levels
// within a group as a smaller instance of the grouping problem with
// different parameters for the input, output sizes, and cache model.
//
// 2) Tightening: Always compute a function at the lowest level possible
// without introducing redundant work. This is a restricted form of recursive
// grouping which does not explore the trade-off between redundant work and
// locality.
//
// Either approach can be implemented as a post process for each group
// after the initial grouping process finishes. The cost model may
// already make sub-optimal higher level partitioning when it is not aware
// of the benefits of the post processing. However, it should strictly be
// an improvement over the initial grouping. As a first step, it is good
// to make it a post process.
//
// Incorporating the recursive grouping process into the cost model can be
// tricky and can potentially make the cost of analyzing a group
// prohibitive, as it requires solving smaller instances of the grouping
// problem for analyzing each configuration. On the other hand, tightening
// can be integrated into the cost model with out significantly increasing
// the time to analyze a grouping configuration.
//
// TODO: Add sliding window optimizations. For start, it may be enough to
// implement sliding window as a post-pass by moving the store level of all
// the members of the group to the outermost serial loop. This could possibly
// be incorporated in the cost model with some effort. Line-buffering
// presents additional challenges for this post-processing strategy though.
// A typical line-buffer would use terrible tile size for tiling, but its
// performance will improve significantly once sliding window is turned on.
//
// TODO: Register tiling is an important transformation especially for
// benchmarks with significant reuse of the data (like matrix multiply and
// convolutional layers). The mechanism for realizing register tiling is to
// completely unroll small tiles of the innermost kernels. Unrolling
// interacts with vectorization, storage layout, and depends on the outer
// level tiling.
struct Group {
// The output stage representing the group.
FStage output;
// Functions that belong to the group.
vector<FStage> members;
// Members of the group which are inlined.
set<string> inlined;
// Tile sizes along dimensions of the output function of the group.
map<string, Expr> tile_sizes;
Group(const FStage &output, const vector<FStage> &members)
: output(output), members(members) {}
friend std::ostream& operator<<(std::ostream &stream, const Group &g) {
stream << "Output FStage: " << g.output << '\n';
stream << "Members: " << '{';
for (size_t i = 0; i < g.members.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << g.members[i];
}
stream << "}" << '\n';
stream << "Inlined: " << '{';
for (auto iter = g.inlined.begin(); iter != g.inlined.end(); ++iter) {
if (std::distance(g.inlined.begin(), iter) > 0) {
stream << ", ";
}
stream << *iter;
}
stream << "}" << '\n';
stream << "Tile sizes: " << "{";
for (auto iter = g.tile_sizes.begin(); iter != g.tile_sizes.end(); ++iter) {
if (std::distance(g.tile_sizes.begin(), iter) > 0) {
stream << ", ";
}
stream << "(" << iter->first << ", " << iter->second << ")";
}
stream << "}" << '\n';
return stream;
}
};
// Result of the analysis of a group.
struct GroupAnalysis {
// Estimate of the arithmetic and memory cost for computing the group.
Cost cost;
// Estimate of the parallelism that can be exploited while computing
// the group.
Expr parallelism;
GroupAnalysis() : cost(Cost()) , parallelism(Expr()) {}
GroupAnalysis(const Cost &c, Expr p) : cost(c), parallelism(std::move(p)) {}
inline bool defined() const {
return cost.defined() && parallelism.defined();
}
void simplify() {
cost.simplify();
if (parallelism.defined()) {
parallelism = Internal::simplify(parallelism);
}
}
friend std::ostream& operator<<(std::ostream &stream, const GroupAnalysis &analysis) {
stream << "[arith cost:" << analysis.cost.arith << ", ";
stream << "memory cost:" << analysis.cost.memory << ", ";
stream << "parallelism:" << analysis.parallelism << "]\n";
return stream;
}
};
// Configuration of a group and the corresponding analysis. A group is the
// set of functions that are computed together in tiles and the group config
// specifies at what granularity they are computed together ('tile_sizes').
struct GroupConfig {
map<string, Expr> tile_sizes;
GroupAnalysis analysis;
GroupConfig(const map<string, Expr> &tile_sizes, const GroupAnalysis &analysis)
: tile_sizes(tile_sizes), analysis(analysis) {}
GroupConfig() : tile_sizes(map<string, Expr>()), analysis(GroupAnalysis()) {}
};
// Cache for storing the best configuration for the grouping choice. During
// the grouping process, the impact of grouping two groups together is only
// limited to the producers and consumers of the groups that are being grouped
// together. The best grouping choices for the rest of the pipeline need not be
// re-evaluated and caching them improves performance significantly.
map<GroupingChoice, GroupConfig> grouping_cache;
// Each group in the pipeline has a single output stage. A group is comprised
// of function stages that are computed together in tiles (stages of a function
// are always grouped together). 'groups' is the mapping from the output stage
// of the group to the group.
map<FStage, Group> groups;
// The child stages of each stage (i.e. stages that depend on or use the values
// computed by a particular stage) in the pipeline.
map<FStage, set<FStage>> children;
// Map from the output stage of the group to the analysis of the group. The mapping
// needs to be updated whenever the grouping changes.
map<FStage, GroupAnalysis> group_costs;
// Levels that are targeted by the grouping algorithm. In the 'Inline' mode, the grouping
// algorithm groups the functions by inlining the expression for the producer function
// into the consumer stage. In the 'FastMem' mode, the grouping is done at the level of
// tiles of the group output stage.
enum class Level {Inline, FastMem};
// Bounds of each function stage in the pipeline. These bounds are inferred from the
// estimates of the outputs and other functions in the pipeline.
const map<string, Box> &pipeline_bounds;
// Parameters of the machine model that is used for estimating the cost of each
// group in the pipeline.
const MachineParams &arch_params;
// Dependency analysis of the pipeline. This support queries on regions
// accessed and computed for producing some regions of some functions.
DependenceAnalysis &dep_analysis;
// The arithmetic and memory costs of evaluating the expressions which define
// each function in the pipeline.
RegionCosts &costs;
// Output functions of the pipeline.
const vector<Function> &outputs;
Partitioner(const map<string, Box> &_pipeline_bounds,
const MachineParams &_arch_params,
const vector<Function> &_outputs,
DependenceAnalysis &_dep_analysis,
RegionCosts &_costs);
void initialize_groups();
// Merge 'prod_group' into 'cons_group'. The output stage of 'cons_group'
// will be the output stage of the merged group.
Group merge_groups(const Group &prod_group, const Group &cons_group);
// Merge 'prods' in 'choice' into 'cons'. Set the tile size of the new group
// to the one specified by 'eval'. If 'level' is set to Inline, all members
// of 'prods' will be inlined in the new group.
void merge_groups(const GroupingChoice &choice, const GroupConfig &eval,
Partitioner::Level level);
// Given a grouping 'g', compute the estimated cost (arithmetic + memory) and
// parallelism that can be potentially exploited when computing that group.
GroupAnalysis analyze_group(const Group &g, bool show_analysis);
// For each group in the partition, return the regions of the producers
// need to be allocated to compute a tile of the group's output.
map<FStage, map<string, Box>> group_storage_bounds();
// For each group in the partition, return the regions of the producers
// required to compute a tile of the group's output.
map<FStage, map<FStage, DimBounds>> group_loop_bounds();
// Partition the pipeline by iteratively merging groups until a fixpoint is
// reached.
void group(Partitioner::Level level);
// Given a grouping choice, return a configuration for the group that gives
// the highest estimated benefits.
GroupConfig evaluate_choice(const GroupingChoice &group, Partitioner::Level level);
// Pick the best choice among all the grouping options currently available. Uses
// the cost model to estimate the benefit of each choice. This returns a vector of
// choice and configuration pairs which describe the best grouping choice.
vector<pair<GroupingChoice, GroupConfig>>
choose_candidate_grouping(const vector<pair<string, string>> &cands,
Partitioner::Level level);
// Return the bounds required to produce a function stage.
DimBounds get_bounds(const FStage &stg);
// Return the bounds required to produce a tile of a function stage.
DimBounds get_bounds_from_tile_sizes(const FStage &stg,
const map<string, Expr> &tile_sizes);
// Return the estimated size of the bounds.
map<string, Expr> bounds_to_estimates(const DimBounds &bounds);
// Given a function stage, return a vector of possible tile configurations for
// that function stage.
vector<map<string, Expr>> generate_tile_configs(const FStage &stg);
// Find the best tiling configuration for a group 'g' among a set of tile
// configurations. This returns a pair of configuration with the highest
// estimated benefit and the estimated benefit.
pair<map<string, Expr>, GroupAnalysis> find_best_tile_config(const Group &g);
// Estimate the benefit (arithmetic + memory) of 'new_grouping' over 'old_grouping'.
// Positive values indicates that 'new_grouping' may be preferrable over 'old_grouping'.
// When 'ensure_parallelism' is set to true, this will return an undefined cost
// if the estimated parallelism is smaller than the machine parameters.
// If 'no_redundant_work' is set, we only consider the arithmetic cost, i.e. if
// the arithmetic benefit is negative, we will treat it as no benefits and we
// should not perform the new grouping.
Expr estimate_benefit(const GroupAnalysis &old_grouping, const GroupAnalysis &new_grouping,
bool no_redundant_work, bool ensure_parallelism);
// Same as above; however, 'new_grouping' is a vector of function pairs that
// are to be grouped together.
Expr estimate_benefit(const vector<pair<GroupingChoice, GroupConfig>> &new_grouping,
bool no_redundant_work, bool ensure_parallelism);
// Return the total estimate on arithmetic and memory costs of computing all
// groups within the pipeline.
Cost get_pipeline_cost();
// Return the maximum access stride to allocation of 'func_acc' along any
// loop variable specified in 'vars'. Access expressions along each dimension
// of the allocation are specified by 'acc_exprs'. The dimension bounds of the
// allocation are specified by 'buffer_bounds'.
Expr find_max_access_stride(const Scope<> &vars, const string &func_acc,
const vector<Expr> &acc_exprs, const Box &buffer_bounds);
// Return the sum of access strides along each of the loop variables in
// a function stage. The bounds of all the allocations accessed are specified
// in 'allocation_bounds'. Return an empty map if it can't figure out any of
// the stride dimension.
map<string, Expr> analyze_spatial_locality(
const FStage &stg, const map<string, Box> &parent_bounds,
const set<string> &inlines = set<string>());
map<string, Expr> evaluate_reuse(const FStage &stg, const set<string> &prods);
// Generate and apply schedules for all functions within a pipeline by
// following their grouping structure.
//
// TODO: A mode where schedules are not applied to the functions might be
// interesting.
//
// TODO: The current form of the schedule returned is not very useful since it
// cannot be manipulated and introspected very easily. The problem is that all
// of the scheduling uses internal function and variable names which are not
// visible to the user. Additionally, functions like sum and maximum are not
// user visible. More thought needs to go into interaction between the user and
// auto scheduling.
void generate_cpu_schedule(const Target &t, AutoSchedule &sched);
// Same as \ref Partitioner::generate_cpu_schedule, but this generates and
// applies schedules for a group of function stages.
void generate_group_cpu_schedule(const Group &g, const Target &t,
const map<FStage, DimBounds> &group_loop_bounds,
const map<string, Box> &group_storage_bounds,
const set<string> &inlines,
AutoSchedule &sched);
// Split the dimension of stage 'f_handle' along 'v' into inner and outer
// dimensions. Modify 'estimates' according to the split and append the split
// schedule to 'sched'.
pair<VarOrRVar, VarOrRVar> split_dim(
const Group &g, Stage f_handle, int stage_num, Definition def,
bool is_group_output, VarOrRVar v, const Expr &factor, string in_suffix,
string out_suffix, map<string, Expr> &estimates, AutoSchedule &sched);
// Loop over the dimensions of function stage 'f_handle' starting from innermost
// and vectorize the first pure dimension encountered.
void vectorize_stage(
const Group &g, Stage f_handle, int stage_num, Definition def,
Function func, bool is_group_output, const Target &t, set<string> &rvars,
map<string, Expr> &estimates, AutoSchedule &sched);
// Reorder the dimensions to preserve spatial locality. This function
// checks the stride of each access. The dimensions of the loop are reordered
// such that the dimension with the smallest access stride is innermost.
// This takes the strides along each dimension as input.
void reorder_dims(Stage f_handle, int stage_num, Definition def,
map<string, Expr> strides, AutoSchedule &sched);
// Helper functions to display partition information of the pipeline.
void disp_pipeline_costs();
void disp_pipeline_bounds();
void disp_pipeline_graph();
void disp_grouping();
};
void Partitioner::disp_grouping() {
debug(0) << "\n=========" << '\n';
debug(0) << "Grouping:" << '\n';
debug(0) << "=========" << '\n';
for (const auto &g : groups) {
debug(0) << g.second << '\n';
}
debug(0) << "=========" << '\n';
}
void Partitioner::disp_pipeline_graph() {
debug(0) << "\n================" << '\n';
debug(0) << "Pipeline graph:" << '\n';
debug(0) << "================" << '\n';
for (const auto &f : children) {
debug(0) << f.first << ": {";
for (auto iter = f.second.begin(); iter != f.second.end(); ++iter) {
if (std::distance(f.second.begin(), iter) > 0) {
debug(0) << ", ";
}
debug(0) << *iter;
}
debug(0) << "}" << '\n';
}
debug(0) << "================" << '\n';
}
void Partitioner::disp_pipeline_bounds() {
debug(0) << "\n================" << '\n';
debug(0) << "Pipeline bounds:" << '\n';
debug(0) << "================" << '\n';
disp_regions(pipeline_bounds);
debug(0) << "===============" << '\n';
}
Cost Partitioner::get_pipeline_cost() {
internal_assert(!group_costs.empty());
Cost total_cost(0, 0);
for (const pair<FStage, Group> &g : groups) {
const GroupAnalysis &analysis = get_element(group_costs, g.first);
if (!analysis.cost.defined()) {
return Cost();
}
total_cost.arith += analysis.cost.arith;
total_cost.memory += analysis.cost.memory;
}
total_cost.simplify();
return total_cost;
}
void Partitioner::disp_pipeline_costs() {
internal_assert(!group_costs.empty());
Cost total_cost(0, 0);
debug(0) << "\n===============" << '\n';
debug(0) << "Pipeline costs:" << '\n';
debug(0) << "===============" << '\n';
debug(0) << "Group: (name) [arith cost, mem cost, parallelism]" << '\n';
for (const pair<FStage, Group> &g : groups) {
const GroupAnalysis &analysis = get_element(group_costs, g.first);
if (!total_cost.arith.defined()) {
continue;
} else if (!analysis.cost.arith.defined()) {
total_cost.arith = Expr();
} else {
total_cost.arith += analysis.cost.arith;
}
if (!total_cost.memory.defined()) {
continue;
} else if (!analysis.cost.memory.defined()) {
total_cost.memory = Expr();
} else {
total_cost.memory += analysis.cost.memory;
}
debug(0) << "Group: " << g.first << " [";
debug(0) << analysis.cost.arith << ", " << analysis.cost.memory
<< ", " << analysis.parallelism << "]\n";
}
total_cost.simplify();
debug(0) << "Total arithmetic cost: " << total_cost.arith << '\n';
debug(0) << "Total memory cost: " << total_cost.memory << '\n';
debug(0) << "===============" << '\n';
}
// Construct a partitioner and build the pipeline graph on which the grouping
// algorithm operates.
Partitioner::Partitioner(const map<string, Box> &_pipeline_bounds,
const MachineParams &_arch_params,
const vector<Function> &_outputs,
DependenceAnalysis &_dep_analysis,
RegionCosts &_costs)
: pipeline_bounds(_pipeline_bounds), arch_params(_arch_params),
dep_analysis(_dep_analysis), costs(_costs), outputs(_outputs) {
// Place each stage of a function in its own group. Each stage is
// a node in the pipeline graph.
for (const auto &f : dep_analysis.env) {
if (!pipeline_bounds.count(f.first)) {
// If a function does not have a pipeline bound (i.e. it can be
// statically proven that no one ever uses it), we should not
// consider it during the grouping.
debug(5) << "Creating partitioner: ignore function \"" << f.first
<< "\" since it has empty pipeline bounds\n";
continue;
}
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
FStage stg(f.second, s);
Group g(stg, {stg});
groups.insert(make_pair(stg, g));
}
}
// Find the consumers of each function and use it to populate the children map.
for (const auto &f : dep_analysis.env) {
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
set<string> parents = get_parents(f.second, s);
for (const string &c : parents) {
// Filter out the calls to pipeline inputs. 'env' only contains
// the functions computed and not the inputs.
auto iter = dep_analysis.env.find(c);
if ((c != f.first) && (iter != dep_analysis.env.end())) {
// Consumer depends only on the last stage of a producer
// with multiple stages.
const Function &prod_func = iter->second;
int final_stage = prod_func.updates().size();
FStage prod_stage(prod_func, final_stage);
FStage cons_stage(f.second, s);
children[prod_stage].insert(cons_stage);
}
}
if (s > 0) {
// Update the children map to reflect the dependencies between
// different stages of the same function.
FStage prod_stage(f.second, s - 1);
FStage cons_stage(f.second, s);
children[prod_stage].insert(cons_stage);
}
}
}
}
void Partitioner::initialize_groups() {
for (pair<const FStage, Group> &g : groups) {
pair<map<string, Expr>, GroupAnalysis> best = find_best_tile_config(g.second);
g.second.tile_sizes = best.first;
group_costs.emplace(g.second.output, best.second);
}
grouping_cache.clear();
}
map<string, Expr> Partitioner::evaluate_reuse(const FStage &stg,
const set<string> &prods) {
map<string, Expr> reuse;
Function f = stg.func;
// TODO: Check if tile size of 1 in each dimension gives a reasonable
// answer or reuse should be evaluated at a much larger granularity or
// symbolically. Using a symbolic version might be better if the objective
// is to prove the dimension has no reuse. The only downside with the
// symbolic method is that it is totally at the mercy of the simplifier.
// Another option is sampling or using a larger granularity.
map<string, Expr> tile_sizes;
const vector<Dim> &dims = get_stage_dims(stg.func, stg.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
tile_sizes[dims[d].var] = 1;
}
DimBounds bounds = get_bounds_from_tile_sizes(stg, tile_sizes);
vector<map<string, Box>> reuse_regions =
dep_analysis.overlap_regions(stg.func, stg.stage_num, bounds, prods,
false, &costs.input_estimates);
for (int d = 0; d < (int)dims.size() - 1; d++) {
Expr total_reuse = make_zero(Int(64));
if (debug::debug_level() >= 3) {
disp_regions(reuse_regions[d]);
}
for (const auto ® : reuse_regions[d]) {
Expr size = box_size(reg.second);
if (!size.defined()) {
total_reuse = Expr();
break;
} else {
total_reuse += size;
}
}
reuse.emplace(dims[d].var, simplify(total_reuse));
}
return reuse;
}
vector<pair<Partitioner::GroupingChoice, Partitioner::GroupConfig>>
Partitioner::choose_candidate_grouping(const vector<pair<string, string>> &cands,
Partitioner::Level level) {
vector<pair<GroupingChoice, GroupConfig>> best_grouping;
Expr best_benefit = make_zero(Int(64));
for (const auto &p : cands) {
// Compute the aggregate benefit of inlining into all the children.
vector<pair<GroupingChoice, GroupConfig>> grouping;
const Function &prod_f = get_element(dep_analysis.env, p.first);
int final_stage = prod_f.updates().size();
FStage prod(prod_f, final_stage);
for (const FStage &c : get_element(children, prod)) {
GroupConfig best_config;
GroupingChoice cand_choice(prod_f.name(), c);
// Check if the candidate has been evaluated for grouping before
const auto &iter = grouping_cache.find(cand_choice);
if (iter != grouping_cache.end()) {
best_config = iter->second;
} else {
best_config = evaluate_choice(cand_choice, level);
// Cache the result of the evaluation for the pair
grouping_cache.emplace(cand_choice, best_config);
}
grouping.push_back(make_pair(cand_choice, best_config));
}
bool no_redundant_work = false;
Expr overall_benefit = estimate_benefit(grouping, no_redundant_work, true);
debug(3) << "Candidate grouping:\n";
for (const auto &g : grouping) {
debug(3) << " " << g.first;
}
debug(3) << "Candidate benefit: " << overall_benefit << '\n';
// TODO: The grouping process can be non-deterministic when the costs
// of two choices are equal
if (overall_benefit.defined() && can_prove(best_benefit < overall_benefit)) {
best_grouping = grouping;
best_benefit = overall_benefit;
}
}
debug(3) << "\nBest grouping:\n";
for (const auto &g : best_grouping) {
debug(3) << " " << g.first;
}
if (best_grouping.size() > 0) {
debug(3) << "Best benefit: " << best_benefit << '\n';
}
return best_grouping;
}
inline bool operator==(const map<string, Expr> &m1, const map<string, Expr> &m2) {
if (m1.size() != m2.size()) {
return false;
}
for (const auto &it1 : m1) {
const auto &it2 = m2.find(it1.first);
if (it2 == m2.end()) {
return false;
} else if (!equal(it1.second, it2->second)) {
return false;
}
}
return true;
}
vector<map<string, Expr>> Partitioner::generate_tile_configs(const FStage &stg) {
// TODO: This is a wart due to the cost model not taking vectorization
// and pre-fetching into account. Ensuring the innermost dimension has
// at least size of 64 gives enough values for vectorization and can help
// with prefetching. This also interacts with the number of parallel tasks
// that are generated.
int min_inner_dim_size = 64;
const vector<Dim> &dims = get_stage_dims(stg.func, stg.stage_num);
// Get the dimensions that are going to be tiled in this stage.
// Skipping rvars for now.
vector<string> tile_vars;
for (int d = 0; d < (int)dims.size() - 1; d++) {
if (!dims[d].is_rvar()) {
tile_vars.push_back(dims[d].var);
}
}
vector<int> size_variants = {1, 4, 8, 16, 32, 64, 128, 256};
vector<map<string, Expr>> tile_configs;
// For all the tile configurations generated, we force the innermost dimension
// to be at least of size 64 to ensure enough values for vectorization.
// Skewed tile configurations
for (size_t i = 0; i < tile_vars.size(); i++) {
for (const auto &dim_size : size_variants) {
map<string, Expr> tiling;
tiling.emplace(tile_vars[i],
(i == 0) ? std::max(dim_size, min_inner_dim_size): dim_size);
for (size_t j = 0; j < tile_vars.size(); j++) {
if (j < i) {
tiling.emplace(tile_vars[j], size_variants[size_variants.size() - 1]);
} else if (j > i) {
tiling.emplace(tile_vars[j], size_variants[0]);
}
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
}
// Almost square tile configurations
for (const auto &dim_size : size_variants) {
map<string, Expr> tiling;
for (size_t j = 0; j < tile_vars.size(); j++) {
tiling.emplace(tile_vars[j],
(j == 0) ? std::max(dim_size, min_inner_dim_size): dim_size);
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
// Reorder tile configurations
for (int i = 0; i < (1 << (tile_vars.size())); i++) {
map<string, Expr> tiling;
for (size_t j = 0; j < tile_vars.size(); j++) {
if (((i >> (j)) & 1) == 1) {
if (j == 0) {
tiling.emplace(tile_vars[j], min_inner_dim_size);
} else {
tiling.emplace(tile_vars[j], 1);
}
}
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
return tile_configs;
}
pair<map<string, Expr>, Partitioner::GroupAnalysis>
Partitioner::find_best_tile_config(const Group &g) {
// Initialize to no tiling
map<string, Expr> no_tile_config;
Group no_tile = g;
no_tile.tile_sizes = no_tile_config;
bool show_analysis = false;
GroupAnalysis no_tile_analysis = analyze_group(no_tile, show_analysis);
GroupAnalysis best_analysis = no_tile_analysis;
map<string, Expr> best_config = no_tile_config;
if (!best_analysis.cost.defined()) {
return make_pair(best_config, best_analysis);
}
// Generate tiling configurations
vector<map<string, Expr>> configs = generate_tile_configs(g.output);
Group best_group = g;
for (const auto &config : configs) {
Group new_group = g;
new_group.tile_sizes = config;
GroupAnalysis new_analysis = analyze_group(new_group, show_analysis);
bool no_redundant_work = false;
Expr benefit = estimate_benefit(best_analysis, new_analysis,
no_redundant_work, true);
if (show_analysis) {
debug(0) << "Benefit relative to not tiling:" << benefit << '\n';
debug(0) << "Best analysis:" << new_analysis;
debug(0) << "No tile analysis:" << no_tile_analysis;
debug(0)
<< "arith cost:" << cast<float>(new_analysis.cost.arith / no_tile_analysis.cost.arith)
<< ", mem cost:" << cast<float>(new_analysis.cost.memory / no_tile_analysis.cost.memory) << '\n';
}
if (benefit.defined() && can_prove(benefit > 0)) {
best_config = config;
best_analysis = new_analysis;
best_group = new_group;
}
}
return make_pair(best_config, best_analysis);
}
void Partitioner::group(Partitioner::Level level) {
bool fixpoint = false;
while (!fixpoint) {
Cost pre_merge = get_pipeline_cost();
fixpoint = true;
vector<pair<string, string>> cand;
for (const pair<FStage, Group> &g : groups) {
bool is_output = false;
for (const Function &f : outputs) {
if (g.first.func.name() == f.name()) {
is_output = true;
break;
}
}
// All stages of a function are computed at a single location.
// The last stage of the function represents the candidate choice
// of grouping the function into a consumer.
const Function &prod_f = get_element(dep_analysis.env, g.first.func.name());
bool is_final_stage = (g.first.stage_num == prod_f.updates().size());
if (is_output || !is_final_stage) {
continue;
}
const auto &iter = children.find(g.first);
if (iter != children.end()) {
// All the stages belonging to a function are considered to be a
// single child.
set<string> child_groups;
for (const FStage &s : iter->second) {
child_groups.insert(s.func.name());
}
int num_children = child_groups.size();
// Only groups with a single child are considered for grouping
// when grouping for computing in tiles.
// TODO: The current scheduling model does not allow functions
// to be computed at different points.
if ((num_children == 1) && (level == Partitioner::Level::FastMem)) {
const string &prod_name = prod_f.name();
const string &cons_name = (*child_groups.begin());
cand.push_back(make_pair(prod_name, cons_name));
} else if((level == Partitioner::Level::Inline) && prod_f.is_pure()) {
const string &prod_name = prod_f.name();
cand.push_back(make_pair(prod_name, ""));
}
}
}
debug(3) << "\n============================" << '\n';
debug(3) << "Current grouping candidates:" << '\n';
debug(3) << "============================" << '\n';
for (size_t i = 0; i < cand.size(); ++i) {
debug(3) << "{" << cand[i].first << ", " << cand[i].second << "}" << '\n';
}
vector<pair<GroupingChoice, GroupConfig>> best = choose_candidate_grouping(cand, level);
if (best.empty()) {
continue;
} else {
fixpoint = false;
}
// The following code makes the assumption that all the stages of a function
// will be in the same group. 'choose_candidate_grouping' ensures that the
// grouping choice being returned adheres to this constraint.
const string &prod = best[0].first.prod;
const Function &prod_f = get_element(dep_analysis.env, prod);
size_t num_stages = prod_f.updates().size() + 1;
FStage final_stage(prod_f, num_stages - 1);
set<FStage> prod_group_children = get_element(children, final_stage);
// Invalidate entries of the grouping cache
set<GroupingChoice> invalid_keys;
for (const auto &c : prod_group_children) {
for (const auto &entry : grouping_cache) {
if ((entry.first.prod == c.func.name()) || (entry.first.cons == c)) {
invalid_keys.insert(entry.first);
}
}
}
for (const auto &key : invalid_keys) {
grouping_cache.erase(key);
}
for (const auto &group : best) {
internal_assert(group.first.prod == prod);
merge_groups(group.first, group.second, level);
}
for (size_t s = 0; s < num_stages; s++) {
FStage prod_group(prod_f, s);
groups.erase(prod_group);
group_costs.erase(prod_group);
// Update the children mapping
children.erase(prod_group);
for (auto &f : children) {
set<FStage> &cons = f.second;
auto iter = cons.find(prod_group);
if (iter != cons.end()) {
cons.erase(iter);
// For a function with multiple stages, all the stages will
// be in the same group and the consumers of the function
// only depend on the last stage. Therefore, when the
// producer group has multiple stages, parents of the
// producers should point to the consumers of the last
// stage of the producer.
cons.insert(prod_group_children.begin(), prod_group_children.end());
}
}
}
Cost post_merge = get_pipeline_cost();
if (debug::debug_level() >= 3) {
disp_pipeline_costs();
}
}
}
DimBounds Partitioner::get_bounds(const FStage &s) {
DimBounds bounds;
const vector<string> &args = s.func.args();
for (size_t d = 0; d < args.size(); d++) {
bounds[args[d]] = get_element(pipeline_bounds, s.func.name())[d];
}
return get_stage_bounds(s.func, s.stage_num, bounds);
}
DimBounds Partitioner::get_bounds_from_tile_sizes(const FStage &s,
const map<string, Expr> &tile_sizes) {
map<string, Interval> bounds;
const map<string, Interval> &def_bounds = get_bounds(s);
const vector<Dim> &dims = get_stage_dims(s.func, s.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var = dims[d].var;
const Interval &bound = get_element(def_bounds, var);
const auto &iter = tile_sizes.find(var);
if (iter != tile_sizes.end()) {
const Expr &size = iter->second;
// Check if the bounds allow for tiling with the given tile size,
// i.e. ensure at least 2 tiles
Expr extent = get_extent(bound);
internal_assert(extent.defined());
if (can_prove(extent >= 2 * size)) {
// TODO: Maybe shift this to the center of the pipeline bound
bounds[var] = Interval(0, simplify(size - 1));
} else {
// If the dimension is too small, do not tile it and set the
// extent of the bounds to that of the dimension estimate
bounds[var] = bound;
}
} else {
bounds[var] = bound;
}
}
return bounds;
}
Partitioner::GroupAnalysis Partitioner::analyze_group(const Group &g, bool show_analysis) {
set<string> group_inputs;
set<string> group_members;
for (const auto &stg : g.members) {
group_members.insert(stg.func.name());
set<string> parents = get_parents(stg.func, stg.stage_num);
for (const auto &c : parents) {
bool is_member = false;
for (const auto &m : g.members) {
if (m.func.name() == c) {
is_member = true;
break;
}
}
if (!is_member) {
group_inputs.insert(c);
}
}
}
// Count the number of tiles
Expr estimate_tiles = make_one(Int(64));
Expr parallelism = make_one(Int(64));
if (!g.output.func.has_extern_definition()) {
// Get the definition corresponding to the group output
Definition def = get_stage_definition(g.output.func, g.output.stage_num);
const vector<Dim> &dims = def.schedule().dims();
DimBounds stg_bounds = get_bounds(g.output);
for (int d = 0; d < (int)dims.size() - 1; d++) {
const string &var = dims[d].var;
const auto &iter = g.tile_sizes.find(var);
if (iter != g.tile_sizes.end()) {
const Expr &size = iter->second;
Expr extent = get_extent(get_element(stg_bounds, var));
if (!extent.defined()) {
return GroupAnalysis();
}
Expr dim_tiles = simplify((extent + size - 1) / size);
estimate_tiles *= dim_tiles;
// Since all Vars are inherently parallelizable by construct, we
// only need to take RVars into account for the analysis.
if (can_parallelize_rvar(var, g.output.func.name(), def)) {
parallelism *= dim_tiles;
}
}
}
}
// Get the regions of the pipeline required to compute a tile of the group
DimBounds tile_bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
map<string, Box> alloc_regions = dep_analysis.regions_required(
g.output.func, g.output.stage_num, tile_bounds, group_members, false, &costs.input_estimates);
map<string, Box> compute_regions = dep_analysis.regions_required(
g.output.func, g.output.stage_num, tile_bounds, group_members, true, &costs.input_estimates);
map<string, Box> group_reg, prod_reg, input_reg;
// Separating into regions that computed within the group and regions that
// are input to the group
for (const auto ® : compute_regions) {
if ((group_members.find(reg.first) != group_members.end()) &&
(reg.first != g.output.func.name())) {
group_reg.emplace(reg.first, reg.second);
} else if (group_inputs.find(reg.first) != group_inputs.end()) {
if (dep_analysis.env.find(reg.first) != dep_analysis.env.end()) {
prod_reg.emplace(reg.first, reg.second);
} else {
input_reg.emplace(reg.first, reg.second);
}
}
}
// Aggregate costs for intermediate functions in a tile and the
// tile output
Cost tile_cost = costs.region_cost(group_reg, g.inlined);
if (!tile_cost.defined()) {
return GroupAnalysis();
}
Cost out_cost = costs.stage_region_cost(g.output.func.name(),
g.output.stage_num,
tile_bounds, g.inlined);
if (!out_cost.defined()) {
return GroupAnalysis();
}
for (const auto ® : alloc_regions) {
if (!box_size(reg.second).defined()) {
return GroupAnalysis();
}
}
Cost group_cost(simplify(tile_cost.arith + out_cost.arith),
simplify(tile_cost.memory + out_cost.memory));
// Detailed load costs for all the group intermediates
map<string, Expr> group_load_costs =
costs.detailed_load_costs(group_reg, g.inlined);
map<string, Expr> out_load_costs =
costs.stage_detailed_load_costs(g.output.func.name(),
g.output.stage_num,
tile_bounds, g.inlined);
combine_load_costs(group_load_costs, out_load_costs);
Box out_tile_extent;
if (g.output.stage_num == 0) {
const vector<string> &args = g.output.func.args();
for (size_t d = 0; d < args.size(); d++) {
const auto &iter = tile_bounds.find(args[d]);
if (iter != tile_bounds.end()) {
out_tile_extent.push_back(iter->second);
} else {
out_tile_extent.push_back(Interval());
}
}
}
Cost per_tile_cost(group_cost.arith, make_zero(Int(64)));
// This is the old cost model; keeping it here for reference, for now.
/*
if (tile_inter_size > arch_params.l1_size) {
// Conservative estimate of accesses to memory
//per_tile_mem_cost = tile_inter_size;
// Aggressive estimate of accesses to memory
per_tile_mem_cost = tile_cost.second;
} else {
// The tile_input_size captures the region of the input
// required to compute the tile. However, all of it many not be
// accessed during the computation of the tile when the access
// is sparse. A better estimate is given by the smaller of
// the number of memory accesses and the region size
per_tile_mem_cost = std::min(tile_input_size + tile_output_size,
tile_cost.second);
}*/
// TODO: Use smooth step curve from Jon to better model cache behavior,
// where each step corresponds to different cache level.
//
// The current cost model drops off linearly. Larger memory footprint is
// penalized more than smaller memory footprint (since smaller one can fit
// more in the cache). The cost is clamped at 'balance', which is roughly at
// memory footprint equal to or larger than the last level cache size.
// If 'model_reuse' is set, the cost model should take into account memory
// reuse within the tile, e.g. matrix multiply reuses inputs multiple times.
// TODO: Implement a better reuse model.
bool model_reuse = false;
// Linear dropoff
Expr load_slope = cast<float>(arch_params.balance) / arch_params.last_level_cache_size;
for (const auto &f_load : group_load_costs) {
internal_assert(g.inlined.find(f_load.first) == g.inlined.end())
<< "Intermediates of inlined pure fuction \"" << f_load.first
<< "\" should not have been in the group_load_costs\n";
const auto &alloc_reg = get_element(alloc_regions, f_load.first);
Expr footprint;
bool is_group_member = (group_members.find(f_load.first) != group_members.end());
bool is_output = (f_load.first == g.output.func.name());
// We use allocated region as conservative estimate of the footprint since
// the loads could be from any random locations of the allocated regions.
if (!is_output && is_group_member) {
footprint = costs.region_size(f_load.first, alloc_reg);
} else {
Expr initial_footprint;
const auto &f_load_pipeline_bounds = get_element(pipeline_bounds, f_load.first);
bool is_function = (dep_analysis.env.find(f_load.first) != dep_analysis.env.end());
if (!is_function) { // It is a load to some input buffer
// Initial loads
initial_footprint = costs.input_region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.input_region_size(f_load.first, alloc_reg);
} else if (is_output) { // Load to the output function of the group
internal_assert(is_group_member)
<< "Output " << f_load.first << " should have been a group member\n";
// Initial loads
initial_footprint = costs.region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.region_size(f_load.first, out_tile_extent);
} else { // Load to some non-member function (i.e. function from other groups)
// Initial loads
initial_footprint = costs.region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.region_size(f_load.first, alloc_reg);
}
if (model_reuse) {
Expr initial_factor =
cast<int64_t>(min(1 + initial_footprint * load_slope, arch_params.balance));
per_tile_cost.memory += initial_factor * footprint;
} else {
footprint = initial_footprint;
}
if (!footprint.defined()) {
return GroupAnalysis();
}
}
Expr cost_factor = cast<int64_t>(min(1 + footprint * load_slope, arch_params.balance));
per_tile_cost.memory += cost_factor * f_load.second;
}
if (show_analysis) {
debug(0) << "\nDetailed loads:\n";
for (const auto &f_load : group_load_costs) {
debug(0) << "(" << f_load.first << "," << f_load.second << ")";
}
debug(0) << '\n';
debug(0) << "\nPer tile memory cost:" << per_tile_cost.memory << '\n';
debug(0) << "Per tile arith cost:" << per_tile_cost.arith << '\n';
}
GroupAnalysis g_analysis(
Cost(per_tile_cost.arith * estimate_tiles, per_tile_cost.memory * estimate_tiles),
parallelism);
g_analysis.simplify();
return g_analysis;
}
Partitioner::Group Partitioner::merge_groups(const Group &prod_group,
const Group &cons_group) {
vector<FStage> group_members;
for (const auto &s : prod_group.members) {
group_members.push_back(s);
}
for (const auto &s : cons_group.members) {
group_members.push_back(s);
}
Group group(cons_group.output, group_members);
for (const auto &f : prod_group.inlined) {
group.inlined.insert(f);
}
for (const auto &f : cons_group.inlined) {
group.inlined.insert(f);
}
return group;
}
void Partitioner::merge_groups(const GroupingChoice &choice, const GroupConfig &eval,
Partitioner::Level level) {
const Function &prod_f = get_element(dep_analysis.env, choice.prod);
size_t num_stages = prod_f.updates().size() + 1;
const FStage &child = choice.cons;
Group &child_group = get_element(groups, child);
for (size_t s = 0; s < num_stages; s++) {
FStage cand(prod_f, s);
Group &cand_group = get_element(groups, cand);
child_group.members.insert(child_group.members.end(),
cand_group.members.begin(),
cand_group.members.end());
if (level == Partitioner::Level::Inline) {
for (const auto &stg : cand_group.members) {
child_group.inlined.insert(stg.func.name());
}
} else {
for (const auto &in : cand_group.inlined) {
child_group.inlined.insert(in);
}
}
}
child_group.tile_sizes = eval.tile_sizes;
// Update group costs.
// We could just reuse the analysis from 'eval' since it was computed
// by assuming the merge had happened.
group_costs[child] = eval.analysis;
}
Partitioner::GroupConfig Partitioner::evaluate_choice(const GroupingChoice &choice,
Partitioner::Level level) {
// Create a group that reflects the grouping choice and evaluate the cost
// of the group.
const Function &prod_f = get_element(dep_analysis.env, choice.prod);
int num_prod_stages = prod_f.updates().size() + 1;
vector<Group> prod_groups;
for (int s = 0; s < num_prod_stages; s++) {
FStage prod_s(prod_f, s);
prod_groups.push_back(get_element(groups, prod_s));
}
Group cons = get_element(groups, choice.cons);
Group group = cons;
for (const auto &prod_g : prod_groups) {
group = merge_groups(prod_g, group);
}
GroupAnalysis group_analysis;
map<string, Expr> best_tile_config;
if (level == Partitioner::Level::Inline) {
// Set the tile sizes to one along all dimensions of the consumer group
map<string, Expr> tile_sizes;
const Function &cons_f = cons.output.func;
const vector<Dim> &dims = get_stage_dims(cons_f, cons.output.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
tile_sizes[dims[d].var] = 1;
}
group.tile_sizes = tile_sizes;
for (const auto &prod_g : prod_groups) {
for (const FStage &s : prod_g.members) {
group.inlined.insert(s.func.name());
}
}
for (const string &f : cons.inlined) {
group.inlined.insert(f);
}
group_analysis = analyze_group(group, false);
best_tile_config = tile_sizes;
} else {
pair<map<string, Expr>, GroupAnalysis> config = find_best_tile_config(group);
best_tile_config = config.first;
group_analysis = config.second;
}
return GroupConfig(best_tile_config, group_analysis);
}
Expr Partitioner::estimate_benefit(const GroupAnalysis &old_grouping,
const GroupAnalysis &new_grouping,
bool no_redundant_work,
bool ensure_parallelism) {
// TODO: Instead of having a hard parallelism constraint, it may be better
// to consider other metric, such as arith_cost/parallelism
if (ensure_parallelism &&
(!new_grouping.parallelism.defined() ||
!can_prove(new_grouping.parallelism >= arch_params.parallelism))) {
return Expr();
}
if (!old_grouping.cost.defined() || !new_grouping.cost.defined()) {
return Expr();
}
Expr arith_benefit = old_grouping.cost.arith - new_grouping.cost.arith;
if (no_redundant_work && !can_prove(arith_benefit >= 0)) {
return Expr();
}
Expr mem_benefit = old_grouping.cost.memory - new_grouping.cost.memory;
return simplify(mem_benefit + arith_benefit);
}
Expr Partitioner::estimate_benefit(
const vector<pair<GroupingChoice, GroupConfig>> &new_grouping,
bool no_redundant_work, bool ensure_parallelism) {
set<FStage> old_groups;
GroupAnalysis new_group_analysis(Cost(0, 0), Int(64).max());
for (const auto &g : new_grouping) {
const Function &prod_f = get_element(dep_analysis.env, g.first.prod);
int num_prod_stages = prod_f.updates().size() + 1;
for (int s = 0; s < num_prod_stages; s++) {
FStage prod_s(prod_f, s);
old_groups.insert(prod_s);
}
old_groups.insert(g.first.cons);
GroupAnalysis analysisg = g.second.analysis;
if (analysisg.defined()) {
new_group_analysis.cost.arith += analysisg.cost.arith;
new_group_analysis.cost.memory += analysisg.cost.memory;
new_group_analysis.parallelism = min(new_group_analysis.parallelism,
analysisg.parallelism);
} else {
new_group_analysis.cost = Cost();
new_group_analysis.parallelism = Expr();
break;
}
}
new_group_analysis.simplify();
GroupAnalysis old_group_analysis(Cost(0, 0), Int(64).max());
for (const auto &g : old_groups) {
const auto &iter = group_costs.find(g);
internal_assert(iter != group_costs.end());
GroupAnalysis analysisg = iter->second;
if (analysisg.defined()) {
old_group_analysis.cost.arith += analysisg.cost.arith;
old_group_analysis.cost.memory += analysisg.cost.memory;
old_group_analysis.parallelism = min(old_group_analysis.parallelism,
analysisg.parallelism);
} else {
old_group_analysis.cost = Cost();
old_group_analysis.parallelism = Expr();
break;
}
}
old_group_analysis.simplify();
return estimate_benefit(old_group_analysis, new_group_analysis,
no_redundant_work, ensure_parallelism);
}
map<string, Expr> Partitioner::bounds_to_estimates(const DimBounds &bounds) {
map<string, Expr> estimates;
for (const auto &bound : bounds) {
estimates.emplace(bound.first, get_extent(bound.second));
}
return estimates;
}
map<FStage, map<string, Box>> Partitioner::group_storage_bounds() {
map<FStage, map<string, Box>> group_storage_bounds;
for (const pair<const FStage, Group> &gpair : groups) {
const Group &g = gpair.second;
DimBounds bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
set<string> prods;
for (const FStage &s : g.members) {
prods.insert(s.func.name());
}
map<string, Box> reg_alloc =
dep_analysis.regions_required(g.output.func, g.output.stage_num,
bounds, prods, false, &costs.input_estimates);
map<string, Box> group_alloc;
for (const FStage &s : g.members) {
const auto &iter = reg_alloc.find(s.func.name());
if ((iter != reg_alloc.end()) && (s.func.name() != g.output.func.name())) {
group_alloc[s.func.name()] = iter->second;
}
}
group_storage_bounds[gpair.first] = group_alloc;
}
return group_storage_bounds;
}
map<FStage, map<FStage, DimBounds>> Partitioner::group_loop_bounds() {
map<FStage, map<FStage, DimBounds>> group_bounds;
for (const pair<const FStage, Group> &gpair : groups) {
Group g = gpair.second;
map<FStage, DimBounds> mem_bounds;
DimBounds bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
set<string> prods;
for (const FStage &s : g.members) {
prods.insert(s.func.name());
}
map<string, Box> reg_computed =
dep_analysis.regions_required(g.output.func, g.output.stage_num,
bounds, prods, true, &costs.input_estimates);
for (const FStage &s : g.members) {
const auto &iter = reg_computed.find(s.func.name());
if (iter != reg_computed.end()) {
map<string, Expr> tile_sizes;
const vector<string> &args = s.func.args();
for (size_t arg = 0; arg < args.size(); arg++) {
tile_sizes[args[arg]] = get_extent(iter->second[arg]);
}
mem_bounds[s] = get_bounds_from_tile_sizes(s, tile_sizes);
}
}
group_bounds[gpair.first] = mem_bounds;
}
return group_bounds;
}
// We need to get the base name of the dimension for scheduling (i.e. it
// can't have any dots). For example, in split case, if "x" is the starting
// dimension name, after split(x, x0, xi, ...), we will end up with something
// like "x.x0" and "x.xi". If we want to later schedule "x.x0", we need to
// pass "x0" instead of "x.x0".
string get_base_name(string name) {
size_t dot_pos = name.rfind('.');
if (dot_pos != string::npos) {
return name.substr(dot_pos + 1);
}
return name;
}
// Return true if any of the values or args in 'def' refers to any of
// the inputs or outputs, with access function which depends on 'var'.
bool access_inputs_or_outputs(Definition def, VarOrRVar var,
const map<string, Type> &inputs,
const vector<Function> &outputs) {
FindAllCalls find;
def.accept(&find);
for (size_t i = 0; i < find.call_args.size(); ++i) {
const string &func = find.call_args[i].first;
const vector<Expr> &args = find.call_args[i].second;
if (inputs.find(func) == inputs.end()) {
// Check if 'func' is an output
bool is_output =
std::find_if(outputs.begin(), outputs.end(),
[&func](const Function &f) { return (f.name() == func);})
!= outputs.end();
if (!is_output) {
// 'func' is neither an input or an output
continue;
}
}
// Check if any of the accesses to 'func' depends on 'var'
for (const auto &arg : args) {
if (expr_uses_var(arg, var.name())) {
return true;
}
}
}
return false;
}
pair<VarOrRVar, VarOrRVar> Partitioner::split_dim(
const Group &g, Stage f_handle, int stage_num, Definition def,
bool is_group_output, VarOrRVar v, const Expr &factor, string in_suffix,
string out_suffix, map<string, Expr> &estimates, AutoSchedule &sched) {
// Create new variables for the split dimensions
string arg_name = v.name();
string inner_name = arg_name + in_suffix;
string outer_name = arg_name + out_suffix;
VarOrRVar inner(inner_name, v.is_rvar), outer(outer_name, v.is_rvar);
{
const auto &iter = sched.internal_vars.find(inner.name());
if (iter == sched.internal_vars.end()) {
sched.internal_vars.emplace(inner.name(), inner);
} else {
internal_assert(iter->second.is_rvar == inner.is_rvar);
}
}
{
const auto &iter = sched.internal_vars.find(outer.name());
if (iter == sched.internal_vars.end()) {
sched.internal_vars.emplace(outer.name(), outer);
} else {
internal_assert(iter->second.is_rvar == outer.is_rvar);
}
}
// The default tail strategy is good enough for most use cases (see docs on
// TailStrategy::Auto). However, the default of pure vars in update definitions
// is RoundUp, which may introduces an out-of-bound error if it is an access
// to inputs or outputs.
//
// We could have just used GuardWithIf when splitting pure vars in update
// definition to ensure no out-of-bounds error. However, this is only
// necessary, if the update definition involves accesses to inputs or outputs.
// For other accesses, we could potentially use a more aggressive tail strategy
// such as RoundUp or ShiftInwards. Note that if we use RoundUp or ShiftInwards,
// any nested loops (generated by compute_at) will be affected as well. However,
// since in the current auto-scheduler model, we always compute_at at the group
// output, if the update definition is not the group output, we do not need to
// care for the nested loops. If it is the update definition of the group output
// however, we'd better make sure that no other member of the groups accesses
// the inputs or outputs.
TailStrategy strategy = TailStrategy::Auto;
if ((stage_num > 0) && !v.is_rvar) {
if (!is_group_output) {
if (access_inputs_or_outputs(def, v, costs.inputs, outputs)) {
strategy = TailStrategy::GuardWithIf;
}
} else {
bool any_access_inputs_outputs = false;
for (const FStage &mem : g.members) {
if (mem.func.name() == f_handle.name()) {
continue;
}
Definition mem_def = get_stage_definition(mem.func, mem.stage_num);
if (access_inputs_or_outputs(mem_def, v, costs.inputs, outputs)) {
any_access_inputs_outputs = true;
break;
}
}
if (any_access_inputs_outputs) {
strategy = TailStrategy::GuardWithIf;
}
}
}
f_handle.split(v, outer, inner, factor, strategy);
std::ostringstream oss;
oss << "split(" << arg_name << ", " << outer_name << ", " << inner_name << ", " << factor;
switch (strategy) {
case TailStrategy::RoundUp:
oss << ", TailStrategy::RoundUp)";
break;
case TailStrategy::GuardWithIf:
oss << ", TailStrategy::GuardWithIf)";
break;
case TailStrategy::ShiftInwards:
oss << ", TailStrategy::ShiftInwards)";
break;
case TailStrategy::Auto:
oss << ")";
break;
default:
internal_assert(false);
}
sched.push_schedule(f_handle.name(), stage_num, oss.str(),
{arg_name, outer_name, inner_name});
const Expr &est = get_element(estimates, arg_name);
internal_assert(est.defined());
estimates[inner_name] = factor;
estimates[outer_name] = simplify((est + factor - 1) / factor);
estimates.erase(arg_name);
return make_pair(inner, outer);
}
void Partitioner::vectorize_stage(const Group &g, Stage f_handle, int stage_num,
Definition def, Function func, bool is_group_output,
const Target &t, set<string> &rvars,
map<string, Expr> &estimates, AutoSchedule &sched) {
vector<Dim> &dims = def.schedule().dims();
int vec_dim_index = -1;
// Set the vector length as the maximum of the natural vector size of all
// values produced by the function.
int vec_len = 0;
for (const auto &type : func.output_types()) {
vec_len = std::max(vec_len, t.natural_vector_size(type));
}
for (int d = 0; d < (int) dims.size() - 1; d++) {
string dim_name = get_base_name(dims[d].var);
bool can_vectorize = true;
if (rvars.find(dim_name) != rvars.end()) {
can_vectorize = can_parallelize_rvar(dim_name, func.name(), def);
}
const auto &iter = estimates.find(dim_name);
if ((iter != estimates.end()) && iter->second.defined()) {
if (can_vectorize && can_prove(iter->second >= vec_len)) {
vec_dim_index = d;
break;
}
}
}
if (vec_dim_index >= 0) {
string vec_dim_name = get_base_name(dims[vec_dim_index].var);
bool is_rvar = (rvars.find(vec_dim_name) != rvars.end());
internal_assert(is_rvar == dims[vec_dim_index].is_rvar());
VarOrRVar vec_var(vec_dim_name, is_rvar);
pair<VarOrRVar, VarOrRVar> split_vars =
split_dim(g, f_handle, stage_num, def, is_group_output, vec_var, vec_len,
"_vi", "_vo", estimates, sched);
f_handle.vectorize(split_vars.first);
sched.push_schedule(f_handle.name(), stage_num,
"vectorize(" + split_vars.first.name() + ")",
{split_vars.first.name()});
if (is_rvar) {
rvars.erase(vec_dim_name);
rvars.insert(split_vars.first.name());
rvars.insert(split_vars.second.name());
}
// TODO: Reorder vector dim to innermost if it is the innermost
// storage dimension of the func.
//
// TODO: Check if the warning is necessary.
if (vec_dim_index > 0) {
user_warning << "Outer dim vectorization of var \"" << vec_dim_name
<< "\" in function \"" << f_handle.name() << "\"\n";
}
}
}
// Return true if the vars/rvars in 'ordering' are in the same order as the
// dim list.
inline bool operator==(const vector<Dim> &dims, const vector<VarOrRVar> &ordering) {
if (dims.size() != ordering.size() + 1) { // The dim list also contains '__outermost'
return false;
}
for (size_t i = 0; i < ordering.size(); ++i) {
if (dims[i].var != ordering[i].name()) {
return false;
}
}
return true;
}
// Return true if the vars/rvars in 'ordering' are not in the same order as the
// dim list.
inline bool operator!=(const vector<Dim> &dims, const vector<VarOrRVar> &ordering) {
return !(dims == ordering);
}
void Partitioner::reorder_dims(Stage f_handle, int stage_num, Definition def,
map<string, Expr> strides, AutoSchedule &sched) {
vector<Dim> &dims = def.schedule().dims();
internal_assert(dims.size() > 1);
vector<pair<string, int>> order;
for (int d = 0; d < (int)dims.size() - 1; d++) {
internal_assert(strides.find(dims[d].var) != strides.end());
}
// Iterate until all the dimensions have been assigned an order
while (strides.size() > 0) {
// Find the pure dimension (can be vars or rvars) with the smallest stride
bool found_pure_dim = false;
Expr min_pure_stride = Int(64).max();
string min_pure_var;
int min_pure_index = -1;
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var_name = get_base_name(dims[d].var);
const auto &iter = strides.find(var_name);
if ((iter != strides.end()) && dims[d].is_pure()) {
const Expr &dim_stride = iter->second;
internal_assert(dim_stride.defined());
if (can_prove(dim_stride < min_pure_stride)) {
min_pure_stride = dim_stride;
min_pure_var = var_name;
min_pure_index = d;
}
found_pure_dim = true;
}
}
if (found_pure_dim && min_pure_var.empty()) {
// Since none of the pure strides can be proven as the minimum, we
// should break here otherwise it may cause infinite loop.
return;
}
// Check if the stride of the pure dimension is smaller than
// the first impure dimension that has not yet been assigned
// an order
Expr min_impure_stride = Int(64).max();
string min_impure_var;
int min_impure_index = -1;
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var_name = get_base_name(dims[d].var);
const auto &iter = strides.find(var_name);
if ((iter != strides.end()) && !dims[d].is_pure()) {
const Expr &dim_stride = iter->second;
internal_assert(dim_stride.defined());
if (can_prove(dim_stride < min_impure_stride)) {
min_impure_stride = dim_stride;
min_impure_var = var_name;
min_impure_index = d;
// Impure dimensions cannot be reordered relative to
// each other. Stop after encountering the first impure
// dimension.
break;
}
}
}
if (min_pure_var.empty() && min_impure_var.empty()) {
// Since none of the pure and impure strides can be proven as the
// minimum, we should break here otherwise it may cause infinite loop.
return;
}
pair<string, int> curr_min_var;
if (!min_impure_var.empty() && can_prove(min_impure_stride < min_pure_stride)) {
curr_min_var.first = min_impure_var;
curr_min_var.second = min_impure_index;
internal_assert(dims[min_impure_index].is_rvar());
} else {
curr_min_var.first = min_pure_var;
curr_min_var.second = min_pure_index;
}
order.push_back(curr_min_var);
strides.erase(curr_min_var.first);
}
vector<VarOrRVar> ordering;
for (const auto &o : order) {
VarOrRVar o_var(o.first, dims[o.second].is_rvar());
ordering.push_back(o_var);
}
internal_assert(!ordering.empty());
set<string> var_list = {ordering[0].name()};
string var_order = ordering[0].name();
for (size_t o = 1; o < ordering.size(); o++) {
var_order += ", " + ordering[o].name();
var_list.insert(ordering[o].name());
}
if (dims != ordering) {
f_handle.reorder(ordering);
sched.push_schedule(f_handle.name(), stage_num, "reorder(" + var_order + ")", var_list);
}
}
// Visitor to find all the variables the depend on a variable.
class FindVarsUsingVar : public IRVisitor {
using IRVisitor::visit;
void visit(const Let *let) {
if (expr_uses_vars(let->value, vars)) {
vars.push(let->name);
}
let->value.accept(this);
let->body.accept(this);
}
public :
Scope<> vars;
FindVarsUsingVar(string var) {
vars.push(var);
}
};
void Partitioner::generate_group_cpu_schedule(
const Group &g, const Target &t,
const map<FStage, DimBounds> &group_loop_bounds,
const map<string, Box> &group_storage_bounds,
const set<string> &inlines,
AutoSchedule &sched) {
string out_f_name = g.output.func.name();
Function g_out = g.output.func;
debug(3) << "\n================\n";
debug(3) << "Scheduling group:\n";
debug(3) << "================\n";
debug(3) << g;
if (g.output.func.has_extern_definition()) {
internal_assert(g.members.size() == 1);
Func(g_out).compute_root();
sched.push_schedule(g_out.name(), g.output.stage_num, "compute_root()", {});
return;
}
// Get the estimates for stage bounds
DimBounds stg_bounds = get_bounds(g.output);
map<string, Expr> stg_estimates = bounds_to_estimates(stg_bounds);
Stage f_handle = Stage(Func(g_out));
// Get a function handle for scheduling the stage
if (g.output.stage_num > 0) {
int stage_num = g.output.stage_num;
f_handle = Func(g_out).update(stage_num - 1);
} else {
Func(g_out).compute_root();
sched.push_schedule(f_handle.name(), g.output.stage_num, "compute_root()", {});
}
// Realize tiling and update the dimension estimates
vector<VarOrRVar> outer_dims;
vector<VarOrRVar> inner_dims;
// Get the definition corresponding to the stage
Definition def = get_stage_definition(g_out, g.output.stage_num);
// 'dims' will get modified since we are going to apply the schedules
// (e.g. tiling, reordering, etc.)
vector<Dim> &dims = def.schedule().dims();
// Keep track of the rvars
set<string> rvars;
for (int d = 0; d < (int)dims.size() - 1; d++) {
if (dims[d].is_rvar()) {
rvars.insert(get_base_name(dims[d].var));
}
}
// Reorder the dimensions for better spatial locality (i.e. smallest stride
// is innermost). If we only have one dimension (excluding __outermost),
// there is nothing to reorder.
if (dims.size() > 2) {
map<string, Expr> strides =
analyze_spatial_locality(g.output, group_storage_bounds, inlines);
if (!strides.empty()) {
reorder_dims(f_handle, g.output.stage_num, def, strides, sched);
}
}
vector<string> dim_vars(dims.size() - 1);
for (int d = 0; d < (int)dims.size() - 1; d++) {
dim_vars[d] = get_base_name(dims[d].var);
}
// Apply tiling to output of the group
for (const auto &var : dim_vars) {
bool is_rvar = (rvars.find(var) != rvars.end());
VarOrRVar v(var, is_rvar);
const auto &iter = g.tile_sizes.find(var);
if ((iter != g.tile_sizes.end()) &&
get_element(stg_estimates, var).defined() &&
can_prove(get_element(stg_estimates, var) > iter->second)) {
const Expr &tile_size = iter->second;
if (can_prove(tile_size == 1)) {
outer_dims.push_back(v);
} else {
pair<VarOrRVar, VarOrRVar> tile_vars =
split_dim(g, f_handle, g.output.stage_num, def, true, v,
tile_size, "_i", "_o", stg_estimates, sched);
inner_dims.push_back(tile_vars.first);
outer_dims.push_back(tile_vars.second);
if (is_rvar) {
rvars.erase(var);
rvars.insert(tile_vars.first.name());
rvars.insert(tile_vars.second.name());
}
}
} else {
inner_dims.push_back(v);
}
}
// Reorder the tile dimensions
if (!outer_dims.empty()) {
vector<VarOrRVar> ordering;
for (const auto &v : inner_dims) {
ordering.push_back(v);
}
for (const auto &v : outer_dims) {
ordering.push_back(v);
}
set<string> var_list;
string var_order = ordering[0].name();
for (size_t o = 1; o < ordering.size(); o++) {
var_order += ", " + ordering[o].name();
var_list.insert(ordering[o].name());
}
if (dims != ordering) {
f_handle.reorder(ordering);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"reorder(" + var_order + ")", var_list);
}
}
vectorize_stage(g, f_handle, g.output.stage_num, def, g_out, true, t,
rvars, stg_estimates, sched);
// Parallelize definition
Expr def_par = 1;
// TODO: Investigate if it is better to pull one large dimension and
// parallelize over it or to generate nested parallelism.
//
// Go from the outer to the innermost loop until sufficient parallelism
// is achieved. Stop the search once we find a vectorized dimension since
// it doesn't make any sense to have a parallelized inner loop within a
// vectorized outer loop.
bool nested_parallelism = true;
if (nested_parallelism) {
int dim_start = dims.size() - 2;
string seq_var = "";
for (int d = dim_start; d >= 0; d--) {
if (dims[d].for_type == ForType::Vectorized) {
break;
}
string var = get_base_name(dims[d].var);
bool is_rvar = (rvars.find(var) != rvars.end());
internal_assert(is_rvar == dims[d].is_rvar());
VarOrRVar v(var, is_rvar);
if (is_rvar && !can_parallelize_rvar(var, g_out.name(), def)) {
if (seq_var == "") {
seq_var = var;
}
continue;
}
if (can_prove(def_par >= arch_params.parallelism)) {
// Enough parallelism to saturate target machine
break;
}
const auto &iter = stg_estimates.find(var);
if ((iter != stg_estimates.end()) && iter->second.defined()) {
if (seq_var != "") {
VarOrRVar seq(seq_var, (rvars.find(seq_var) != rvars.end()));
f_handle.reorder(seq, v);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"reorder(" + seq_var + ", " + var + ")",
{seq_var, var});
}
f_handle.parallel(v);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"parallel(" + var + ")", {var});
def_par = simplify(def_par * iter->second);
} else {
break;
}
}
}
if (can_prove(def_par < arch_params.parallelism)) {
user_warning << "Insufficient parallelism for " << f_handle.name() << '\n';
}
// Find the level at which group members will be computed.
int tile_inner_index = dims.size() - outer_dims.size() - 1;
VarOrRVar tile_inner_var("", false);
if (!outer_dims.empty()) {
string var_name = get_base_name(dims[tile_inner_index].var);
bool is_rvar = (rvars.find(var_name) != rvars.end());
tile_inner_var = VarOrRVar(var_name, is_rvar);
}
for (const FStage &mem : g.members) {
// Skip member stages that have been inlined or stage that is the
// output stage of the group
if ((g.inlined.find(mem.func.name()) != g.inlined.end()) ||
(mem.func.name() == g_out.name())) {
continue;
}
// Get the definition corresponding to the stage
Definition mem_def = get_stage_definition(mem.func, mem.stage_num);
// Get the estimates for the dimensions of the member stage
map<string, Expr> mem_estimates =
bounds_to_estimates(get_element(group_loop_bounds, mem));
set<string> mem_rvars;
vector<Dim> &mem_dims = mem_def.schedule().dims();
for (int d = 0; d < (int)mem_dims.size() - 1; d++) {
if (mem_dims[d].is_rvar()) {
mem_rvars.insert(get_base_name(mem_dims[d].var));
}
}
// Get a function handle for scheduling the stage
Stage mem_handle = Stage(Func(mem.func));
if (mem.stage_num > 0) {
mem_handle = Func(mem.func).update(mem.stage_num - 1);
} else {
if (!outer_dims.empty()) {
if (tile_inner_var.is_rvar) {
Func(mem.func).compute_at(Func(g_out), tile_inner_var.rvar);
} else {
Func(mem.func).compute_at(Func(g_out), tile_inner_var.var);
}
string sanitized_g_out = get_sanitized_name(g_out.name());
sched.push_schedule(mem_handle.name(), mem.stage_num,
"compute_at(" + sanitized_g_out + ", " + tile_inner_var.name() + ")",
{sanitized_g_out, tile_inner_var.name()});
} else {
user_warning << "Degenerate tiling. No dimensions are tiled" << '\n';
user_warning << "Computing \"" << mem.func.name() << "\" at root" << '\n';
Func(mem.func).compute_root();
sched.push_schedule(mem_handle.name(), mem.stage_num, "compute_root()", {});
}
}
// Reorder the dimensions for better spatial locality. If we only have
// one dimension (excluding __outermost), there is nothing to reorder.
if (dims.size() > 2) {
map<string, Expr> mem_strides =
analyze_spatial_locality(mem, group_storage_bounds, inlines);
if (!mem_strides.empty()) {
reorder_dims(mem_handle, mem.stage_num, mem_def, mem_strides, sched);
}
}
vectorize_stage(g, mem_handle, mem.stage_num, mem_def, mem.func, false,
t, mem_rvars, mem_estimates, sched);
}
}
void Partitioner::generate_cpu_schedule(const Target &t, AutoSchedule &sched) {
// Grab the group bounds early as they rely on the dimensions of the group
// outputs which will be altered by modifying schedules.
map<FStage, map<FStage, DimBounds>> loop_bounds = group_loop_bounds();
map<FStage, map<string, Box>> storage_bounds = group_storage_bounds();
set<string> inlines;
// Mark all functions that are inlined.
for (const pair<FStage, Group> &g : groups) {
for (const string &inline_func : g.second.inlined) {
inlines.insert(inline_func);
}
}
// TODO: Inlining functions with update definitions has different
// behavior than pure functions. They may need to be computed above
// the innermost vector loop to avoid complications with varying
// extents across different vector lanes.
//
// Since the default schedule is compute inline, we don't need to
// explicitly call compute_inline() on the function.
// Realize schedule for each group in the pipeline.
for (const auto &g : groups) {
generate_group_cpu_schedule(g.second, t, get_element(loop_bounds, g.first),
get_element(storage_bounds, g.first), inlines, sched);
}
}
Expr Partitioner::find_max_access_stride(const Scope<> &vars,
const string &func_acc,
const vector<Expr> &acc_exprs,
const Box &buffer_bounds) {
size_t num_storage_dims = 0;
Expr bytes_per_ele = make_zero(Int(64));
// Get the number of dimensions of the allocated storage and the
// number of bytes required to store a single value of func_acc.
const auto &iter = dep_analysis.env.find(func_acc);
if (iter != dep_analysis.env.end()) {
const Function &f = iter->second;
for (const auto &e : f.values()) {
bytes_per_ele += e.type().bytes();
}
num_storage_dims = f.schedule().storage_dims().size();
} else {
bytes_per_ele = get_element(costs.inputs, func_acc).bytes();
num_storage_dims = buffer_bounds.size();
}
Expr curr_stride = bytes_per_ele;
Expr stride = make_zero(Int(64));
internal_assert(num_storage_dims <= acc_exprs.size());
for (size_t sdim = 0; sdim < num_storage_dims; sdim++) {
// Check if the access expression depends on any of the loop variables
// in 'vars'. Expressions that do not involve the variable have stride 0.
if (expr_uses_vars(acc_exprs[sdim], vars)) {
stride = max(stride, curr_stride);
}
const Interval &dim_range = buffer_bounds[sdim];
Expr dim_extent = get_extent(dim_range);
if (!dim_extent.defined()) {
return Expr();
}
curr_stride *= dim_extent;
}
return simplify(stride);
}
map<string, Expr>
Partitioner::analyze_spatial_locality(const FStage &stg,
const map<string, Box> &allocation_bounds,
const set<string> &inlines) {
internal_assert(!stg.func.has_extern_definition());
// Handle inlining. When a function is inlined into another, the stride of
// the accesses should be computed on the expression post inlining.
// For example:
// f(x, y) = ...;
// g(x, y) = f(y, x); // transpose
// h(x, y) = g(y, x); // transpose
//
// If both g and f are inlined into h, then the resulting expression for h
// will look like:
// h(x, y) = f(x, y);
//
// Computing the stride of a loop over x in the function h will be incorrect
// if inlining is not taken into account.
// Get all the allocations accessed in the definition corresponding to 'stg'.
FindAllCalls find;
Definition def = get_stage_definition(stg.func, stg.stage_num);
// Perform inlining on the all the values and the args in the stage.
for (auto &val : def.values()) {
val = perform_inline(val, dep_analysis.env, inlines);
}
for (auto &arg : def.args()) {
arg = perform_inline(arg, dep_analysis.env, inlines);
}
def.accept(&find);
// Arguments on the left hand side might themselves involve accesses
// to allocations and thus need to be accounted for when computing the
// strides along each dimension.
vector<pair<string, vector<Expr>>> &call_args = find.call_args;
// Account for the spatial locality of the store. Add the access on the
// left hand side to call_args.
call_args.push_back(make_pair(stg.func.name(), def.args()));
// Map for holding the strides across each dimension
map<string, Expr> var_strides;
const vector<Dim> &dims = def.schedule().dims();
for (int d = 0; d < (int)dims.size() - 1; d++) {
// Get all the variables involving the dimension in the definition.
FindVarsUsingVar dep_vars(dims[d].var);
def.accept(&dep_vars);
// Accumulate the stride of each access to a loop dimension.
Expr total_stride = 0;
for (const pair<string, vector<Expr>> &call : call_args) {
Box call_alloc_reg;
const auto &iter = allocation_bounds.find(call.first);
if (iter != allocation_bounds.end()) {
call_alloc_reg = iter->second;
} else {
call_alloc_reg = get_element(pipeline_bounds, call.first);
}
Expr current_stride = find_max_access_stride(dep_vars.vars, call.first,
call.second, call_alloc_reg);
if (!current_stride.defined()) {
return map<string, Expr>();
}
total_stride += current_stride;
}
var_strides.emplace(dims[d].var, simplify(total_stride));
}
return var_strides;
}
// Verify that function 'f' does not have partially specified schedules/bounds.
// The current auto scheduler cannots handle such cases.
void validate_no_partial_schedules(const Function &f) {
if (f.has_extern_definition()) {
return;
}
// Verify no compute_root or bounds are specified
user_assert(f.schedule().compute_level().is_inlined())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it is scheduled to be computed at root\n";
user_assert(f.schedule().bounds().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has partially specified bounds\n";
int num_stages = f.updates().size() + 1;
for (int stage = 0; stage < num_stages; ++stage) {
const Definition &def = get_stage_definition(f, stage);
const StageSchedule &schedule = def.schedule();
// Verify no splits are specified
user_assert(schedule.splits().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has partially specified schedules at stage " << stage << "\n";
// Verify that none of the dimensions are scheduled to be parallelized or
// vectorized, or unrolled.
for (const auto &d : schedule.dims()) {
user_assert(d.for_type == ForType::Serial)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since stage " << stage << " is not serial at dim " << d.var << "\n";
}
if (stage == 0) {
// Since we can only specialize on a Func, we only need to check for no
// specializations for the initial stage.
user_assert(def.specializations().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has specializations\n";
// Verify that there is no loop reordering on the initial definition
// (i.e. the Vars in the dim list should be in the same order as
// the args in the LHS of the definition).
internal_assert(schedule.dims().size() - 1 == def.args().size());
for (size_t i = 0; i < def.args().size(); ++i) {
const Variable *arg = def.args()[i].as<Variable>();
internal_assert(arg);
user_assert(arg->name == schedule.dims()[i].var)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << arg->name << "\" at stage " << stage
<< " has been reordered\n";
}
} else {
// Verify that there is no loop reordering on the update definition
// (i.e. the Vars in the dim list should be in the same order as
// the args in the LHS of the definition, the RVars in the dim list
// should be in the same order as the RVars in the rvar list, and
// all RVars should come before all Vars).
const vector<Dim> &dims = schedule.dims();
const vector<ReductionVariable> &rvars = schedule.rvars();
const vector<Expr> &args = f.definition().args();
internal_assert(dims.size() - 1 >= rvars.size());
for (size_t i = 0; i < rvars.size(); ++i) {
const Dim &d = dims[i];
user_assert(d.is_rvar() && (d.var == rvars[i].var))
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
}
internal_assert(dims.size() - rvars.size() - 1 <= args.size());
int last_index = -1;
for (int i = rvars.size(); i < (int)dims.size() - 1; ++i) {
const Dim &d = dims[i];
user_assert(!d.is_rvar())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
const auto &iter =
std::find_if(args.begin(), args.end(),
[&d](const Expr &arg) {
const Variable *v = arg.as<Variable>();
return (d.var == v->name);
});
internal_assert(iter != args.end());
int current_index = iter - args.begin();
user_assert(current_index > last_index)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
last_index = current_index;
}
}
}
}
// Determine if a Func (order[index]) is only consumed by another single Func
// in element-wise manner. If it is, return the name of the consumer Func;
// otherwise, return an empty string.
string is_func_called_element_wise(const vector<string> &order, size_t index,
const map<string, Function> &env) {
Function f1 = env.at(order[index]);
if (f1.has_extern_definition() || !f1.can_be_inlined()) {
return "";
}
internal_assert(index < order.size());
string caller = "";
for (size_t i = index + 1; i < order.size(); ++i) {
Function f2 = env.at(order[i]);
if (f2.has_extern_definition()) {
continue;
}
int num_stages = f2.updates().size() + 1;
for (int s = 0; s < num_stages; ++s) {
Definition def = get_stage_definition(f2, s);
FindAllCalls find;
def.accept(&find);
if (find.funcs_called.count(f1.name())) {
if (caller.empty()) {
caller = f2.name();
} else {
// Found another caller of 'f1'
return "";
}
}
for (const auto &iter : find.call_args) {
if (iter.first != f1.name()) {
continue;
}
if (def.args().size() != iter.second.size()) {
// It's not an element-wise access
return "";
}
for (size_t j = 0; j < iter.second.size(); ++j) {
if (!equal(def.args()[j], iter.second[j])) {
// It's not an element-wise access
return "";
}
}
}
}
}
return caller;
}
// Return true if 'f' is used by some extern Func.
bool used_by_extern_func(const map<string, Function> &env, const Function &f) {
for (const auto &iter : env) {
for (const ExternFuncArgument &arg : iter.second.extern_arguments()) {
if (arg.is_func()) {
if (Function(arg.func).name() == f.name()) {
return true;
}
}
}
}
return false;
}
// If the bounds of a Func are undefined, then we should just inline the Func
// as long as it is legal to inline or used by some extern Func.
set<string> get_unbounded_functions(const map<string, Box> &pipeline_bounds,
const map<string, Function> &env) {
set<string> unbounded;
for (const auto &iter : env) {
if (!pipeline_bounds.count(iter.first)) {
debug(5) << "...Skip checking function \"" << iter.first
<< "\" since it does not have pipeline bounds\n";
continue;
}
const Function &f = iter.second;
if (!f.can_be_inlined() || used_by_extern_func(env, f)) {
continue;
}
const Box &bound = get_element(pipeline_bounds, iter.first);
if (is_box_unbounded(bound)) {
unbounded.insert(iter.first);
}
}
return unbounded;
}
bool inline_unbounded(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env,
const set<string> &unbounded) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
Function f1 = env.at(order[i]);
if (!unbounded.count(f1.name())) {
continue;
}
inlined = true;
debug(4) << "Function \"" << order[i] << "\" is unbounded\n";
for (int j = i + 1; j < (int)order.size(); ++j) {
internal_assert(order[i] != order[j]);
Function f2 = env.at(order[j]);
debug(5) << "Inline unbounded function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\"\n";
inline_function(f2, f1);
}
}
return inlined;
}
} // anonymous namespace
// Check if all the pipeline outputs have estimates specified
// on each of their dimensions; otherwise, throw an assertion.
void check_estimates_on_outputs(const vector<Function> &outputs) {
for (const auto &out : outputs) {
const vector<Bound> &estimates = out.schedule().estimates();
// Check if the estimate for each dimension of the output is available
// and is an integer. If there are duplicates for the estimate of a
// dimension, we only check the last defined estimate (which min and
// extent values are defined) since it is the one that would be
// eventually used.
Bound est;
for (const auto &arg : out.args()) {
bool found = false;
for (int i = (int)estimates.size() - 1; i >= 0; --i) {
if ((estimates[i].var == arg) && estimates[i].min.defined() &&
estimates[i].extent.defined()) {
found = true;
est = estimates[i];
break;
}
}
user_assert(found && est.min.type().is_int() && est.extent.type().is_int())
<< "Please provide a valid estimate for dimension "
<< est.var << " of output \"" << out.name() << "\"\n";
}
}
}
// If the cost of computing a Func is about the same as calling the Func,
// inline the Func. Return true of any of the Funcs is inlined.
bool inline_all_trivial_functions(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
bool is_output = false;
for (const Function &f : outputs) {
if (order[i] == f.name()) {
is_output = true;
break;
}
}
if (is_output) {
// Should not inline output Func
debug(5) << "Skip inlining " << order[i] << " since it is an output\n";
continue;
}
Function f1 = env.at(order[i]);
if (is_func_trivial_to_inline(f1)) {
inlined = true;
debug(4) << "Function \"" << order[i] << "\" is trivial to inline\n";
for (int j = i + 1; j < (int)order.size() - (int)outputs.size(); ++j) {
internal_assert(order[i] != order[j]);
Function f2 = env.at(order[j]);
if (f2.has_extern_definition() && !f1.is_wrapper()) {
debug(5) << "Skip inlining of function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\", because "
<< "non-wrapper functions cannot be inlined inside "
<< "extern functions.\n";
} else {
debug(5) << "Inline trivial function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\"\n";
inline_function(f2, f1);
}
}
}
}
return inlined;
}
// Inline a Func if its values are only consumed by another single Func in
// element-wise manner.
bool inline_all_element_wise_functions(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
bool is_output = false;
for (const Function &f : outputs) {
if (order[i] == f.name()) {
is_output = true;
break;
}
}
if (is_output) {
// Should not inline output Func
debug(5) << "Skip inlining " << order[i] << " since it is an output\n";
continue;
}
string caller = is_func_called_element_wise(order, i, env);
if (!caller.empty()) {
inlined = true;
debug(4) << "Inline function \"" << order[i] << "\" since it is called only by "
<< caller << " in element-wise manner\n";
internal_assert(order[i] != caller);
inline_function(env.at(caller), get_element(env, order[i]));
}
}
return inlined;
}
// Generate schedules for all functions in the pipeline required to compute the
// outputs. This applies the schedules and returns a string representation of
// the schedules. The target architecture is specified by 'target'.
string generate_schedules(const vector<Function> &outputs, const Target &target,
const MachineParams &arch_params) {
// Make an environment map which is used throughout the auto scheduling process.
map<string, Function> env;
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
// Finalize all the LoopLevels
for (auto &iter : env) {
iter.second.lock_loop_levels();
}
// Compute the topological order, before any trivial inlining (i.e. before
// we remove any functions from 'env'). We need the full topological
// order to pass to get_func() when generating the string representation
// of the schedule.
debug(2) << "Computing topological order...\n";
vector<string> top_order = topological_order(outputs, env);
// Validate that none of the functions in the pipeline have partial schedules.
debug(2) << "Validating no partial schedules...\n";
for (const auto &iter : env) {
validate_no_partial_schedules(iter.second);
}
// The auto scheduling algorithm requires estimates on the outputs of the
// pipeline to get quantitative estimates of costs for computing functions
// in the pipeline.
debug(2) << "Checking estimates on outputs...\n";
check_estimates_on_outputs(outputs);
// Run a pre-pass that inline all trivial Funcs (i.e. if the cost of
// computing a Func is about the same as calling that Func, we should
// just inline it).
debug(2) << "Inlining all trivial functions...\n";
if (inline_all_trivial_functions(outputs, top_order, env)) {
// If any of the Funcs is inlined, we need to recompute 'env', since some
// of the Funcs are no longer used and need to be removed from 'env'.
//
// Instead of recomputing 'env', we could also remove the inlined Func
// within inline_all_trivial_functions(); however, it is a bit tricky
// to do when dealing with inlined tuple. Consider the following case:
// f(x, y) = x + y;
// g(x, y) = {x, f(x, y)};
// h(x, y) = g(x, y)[0];
// When 'g' is inlined in 'h', no one uses 'f' anymore and it can
// be removed from 'env'. However, to know this, we need to trace
// all the function calls within the pipeline. Thus, we might as well
// recompute the 'env' from scratch.
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
}
// Compute the realization order of the functions within the pipeline.
vector<string> order = realization_order(outputs, env).first;
// Run a pre-pass that inline all Funcs which values are accessed by
// another single Func in element-wise manner. We need to do this
// repeatedly since some inlining decisions may enable further inlining
// that previously not possible. Consider the following case:
// f1(x) = x;
// f2(x) = f1(x) + 2;
// f3(x) = f1(x) * 2;
// f4(x) = f2(x) + f3(x);
// f5(x) = f4(x) + 3;
// In the first iteration, we cannot inline 'f1' since it is used by two
// functions: 'f2' and 'f3'. If 'f2' and 'f4' get inlined and 'f3' is only
// used by 'f4', then 'f1' can now also be inlined.
debug(2) << "Inlining all element-wise functions...\n";
while (inline_all_element_wise_functions(outputs, order, env)) {
// We need to recompute 'env' for the same reason as with
// inline_all_trivial_functions
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
order = realization_order(outputs, env).first;
}
// Compute the bounds of function values which are used for dependence analysis.
debug(2) << "Computing function value bounds...\n";
FuncValueBounds func_val_bounds = compute_function_value_bounds(order, env);
// Initialize the cost model.
// Compute the expression costs for each function in the pipeline.
debug(2) << "Initializing region costs...\n";
RegionCosts costs(env);
if (debug::debug_level() >= 3) {
costs.disp_func_costs();
}
debug(2) << "Initializing dependence analysis...\n";
DependenceAnalysis dep_analysis(env, order, func_val_bounds);
// Compute bounds of all functions in the pipeline given estimates on
// outputs. Also report functions which bounds could not be inferred.
debug(2) << "Computing pipeline bounds...\n";
map<string, Box> pipeline_bounds =
get_pipeline_bounds(dep_analysis, outputs, &costs.input_estimates);
// Determine all unbounded functions that are not extern Func or
// used by some extern Funcs.
debug(2) << "Determining all unbounded functions...\n";
set<string> unbounded = get_unbounded_functions(pipeline_bounds, env);
if (!unbounded.empty()) {
// If some functions are unbounded, we should inline those directly.
// Also, we need to recompute 'env' and re-initialize 'costs' and
// 'dep_analysis'
debug(2) << "Inlining all unbounded functions...\n";
internal_assert(inline_unbounded(outputs, order, env, unbounded));
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
order = realization_order(outputs, env).first;
debug(2) << "Re-computing function value bounds...\n";
func_val_bounds = compute_function_value_bounds(order, env);
debug(2) << "Re-initializing region costs...\n";
RegionCosts costs(env);
debug(2) << "Re-initializing dependence analysis...\n";
dep_analysis = DependenceAnalysis(env, order, func_val_bounds);
debug(2) << "Re-computing pipeline bounds...\n";
pipeline_bounds = get_pipeline_bounds(dep_analysis, outputs, &costs.input_estimates);
}
debug(2) << "Initializing partitioner...\n";
Partitioner part(pipeline_bounds, arch_params, outputs, dep_analysis, costs);
// Compute and display reuse
/* TODO: Use the reuse estimates to reorder loops
for (const auto &f : env) {
FindAllCalls find;
f.second.accept(&find);
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
FStage curr_s(f.second, s);
map<string, Expr> reuse = part.evaluate_reuse(curr_s, find.funcs_called);
debug(0) << curr_s << '\n';
for (const auto &dir : reuse) {
debug(0) << dir.first << " " << dir.second << ',';
}
debug(0) << '\n';
}
}*/
// Display the current pipeline graph.
// TODO: Output the graph in dot format.
if (debug::debug_level() >= 3) {
part.disp_pipeline_graph();
part.disp_pipeline_bounds();
}
debug(2) << "Partitioner initializing groups...\n";
part.initialize_groups();
if (debug::debug_level() >= 3) {
part.disp_pipeline_costs();
}
// /////////////
// Remove the following two stages?
debug(2) << "Partitioner computing inline group...\n";
part.group(Partitioner::Level::Inline);
if (debug::debug_level() >= 3) {
part.disp_grouping();
}
debug(2) << "Partitioner computing fast-mem group...\n";
part.grouping_cache.clear();
part.group(Partitioner::Level::FastMem);
if (debug::debug_level() >= 3) {
part.disp_pipeline_costs();
part.disp_grouping();
part.disp_pipeline_graph();
}
debug(2) << "Initializing AutoSchedule...\n";
AutoSchedule sched(env, top_order);
debug(2) << "Generating CPU schedule...\n";
part.generate_cpu_schedule(target, sched);
std::ostringstream oss;
oss << "// Target: " << target.to_string() << "\n";
oss << "// MachineParams: " << arch_params.to_string() << "\n";
oss << "\n";
oss << sched;
string sched_string = oss.str();
debug(3) << "\n\n*******************************\nSchedule:\n"
<< "*******************************\n" << sched_string << "\n\n";
// TODO: Unify both inlining and grouping for fast mem
// TODO: GPU scheduling
// TODO: Hierarchical tiling
return sched_string;
}
} // namespace Internal
MachineParams MachineParams::generic() {
return MachineParams(16, 16 * 1024 * 1024, 40);
}
std::string MachineParams::to_string() const {
internal_assert(parallelism.type().is_int() &&
last_level_cache_size.type().is_int() &&
balance.type().is_int());
std::ostringstream o;
o << parallelism << "," << last_level_cache_size << "," << balance;
return o.str();
}
MachineParams::MachineParams(const std::string &s) {
std::vector<std::string> v = Internal::split_string(s, ",");
user_assert(v.size() == 3) << "Unable to parse MachineParams: " << s;
parallelism = Internal::string_to_int(v[0]);
last_level_cache_size = Internal::string_to_int(v[1]);
balance = Internal::string_to_int(v[2]);
}
} // namespace Halide
| 41.363916 | 113 | 0.57346 | jrk |
b4591336770e08f26e4915a40cc12213d44f78d9 | 3,184 | cc | C++ | chrome/chrome_cleaner/zip_archiver/target/sandbox_setup.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 14,668 | 2015-01-01T01:57:10.000Z | 2022-03-31T23:33:32.000Z | chrome/chrome_cleaner/zip_archiver/target/sandbox_setup.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 86 | 2015-10-21T13:02:42.000Z | 2022-03-14T07:50:50.000Z | chrome/chrome_cleaner/zip_archiver/target/sandbox_setup.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 5,941 | 2015-01-02T11:32:21.000Z | 2022-03-31T16:35:46.000Z | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/chrome_cleaner/zip_archiver/target/sandbox_setup.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/memory/scoped_refptr.h"
#include "base/run_loop.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_executor.h"
#include "chrome/chrome_cleaner/constants/chrome_cleaner_switches.h"
#include "chrome/chrome_cleaner/ipc/mojo_sandbox_hooks.h"
#include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
#include "chrome/chrome_cleaner/os/early_exit.h"
#include "chrome/chrome_cleaner/zip_archiver/target/zip_archiver_impl.h"
namespace chrome_cleaner {
namespace {
class ZipArchiverSandboxTargetHooks : public MojoSandboxTargetHooks {
public:
explicit ZipArchiverSandboxTargetHooks(MojoTaskRunner* mojo_task_runner);
~ZipArchiverSandboxTargetHooks() override;
// Sandbox hooks
ResultCode TargetDroppedPrivileges(
const base::CommandLine& command_line) override;
private:
void CreateZipArchiverImpl(
mojo::PendingReceiver<mojom::ZipArchiver> receiver);
MojoTaskRunner* mojo_task_runner_;
base::SingleThreadTaskExecutor main_thread_task_executor_;
std::unique_ptr<ZipArchiverImpl, base::OnTaskRunnerDeleter>
zip_archiver_impl_;
};
ZipArchiverSandboxTargetHooks::ZipArchiverSandboxTargetHooks(
MojoTaskRunner* mojo_task_runner)
: mojo_task_runner_(mojo_task_runner),
zip_archiver_impl_(nullptr,
base::OnTaskRunnerDeleter(mojo_task_runner_)) {}
ZipArchiverSandboxTargetHooks::~ZipArchiverSandboxTargetHooks() = default;
ResultCode ZipArchiverSandboxTargetHooks::TargetDroppedPrivileges(
const base::CommandLine& command_line) {
mojo::PendingReceiver<mojom::ZipArchiver> receiver(
ExtractSandboxMessagePipe(command_line));
// This loop will run forever. Once the communication channel with the broker
// process is broken, mojo error handler will abort this process.
base::RunLoop run_loop;
mojo_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&ZipArchiverSandboxTargetHooks::CreateZipArchiverImpl,
base::Unretained(this), std::move(receiver)));
run_loop.Run();
return RESULT_CODE_SUCCESS;
}
void ZipArchiverSandboxTargetHooks::CreateZipArchiverImpl(
mojo::PendingReceiver<mojom::ZipArchiver> receiver) {
// Replace the null pointer by the actual |ZipArchiverImpl|.
// Manually use |new| here because |make_unique| doesn't work with
// custom deleter.
zip_archiver_impl_.reset(
new ZipArchiverImpl(std::move(receiver), base::BindOnce(&EarlyExit, 1)));
}
} // namespace
ResultCode RunZipArchiverSandboxTarget(
const base::CommandLine& command_line,
sandbox::TargetServices* target_services) {
DCHECK(target_services);
scoped_refptr<MojoTaskRunner> mojo_task_runner = MojoTaskRunner::Create();
ZipArchiverSandboxTargetHooks target_hooks(mojo_task_runner.get());
return RunSandboxTarget(command_line, target_services, &target_hooks);
}
} // namespace chrome_cleaner
| 34.236559 | 79 | 0.780151 | zealoussnow |
b45b35f0359a6a9d27c553b0c79426030e1966c2 | 9,840 | hpp | C++ | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2018 - 2019 HITSIC
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @brief 陀螺仪驱动，适用于mpu6050,mpu9250,icm20602
* @author xiao qq1761690868
* @doc drv_imu_invensense.md
* @version v1.0
* @date 2020-10-16
*/
#ifndef UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP
#define UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP
#include "hitsic_common.h"
#if (defined(HITSIC_USE_DRV_IMU_INV) && (HITSIC_USE_DRV_IMU_INV > 0U))
namespace inv {
enum class icm20602_RegMap :uint8_t
{
XG_OFFS_TC_H = 0x4, // READ/ WRITE
XG_OFFS_TC_L = 0x5, // READ/ WRITE
YG_OFFS_TC_H = 0x7, // READ/ WRITE
YG_OFFS_TC_L = 0x8, // READ/ WRITE
ZG_OFFS_TC_H = 0x0A, // READ/ WRITE
ZG_OFFS_TC_L = 0x0B, // READ/ WRITE
SELF_TEST_X_ACCEL = 0x0D, // READ/ WRITE
SELF_TEST_Y_ACCEL = 0x0E, // READ/ WRITE
SELF_TEST_Z_ACCEL = 0x0F, // READ/ WRITE
XG_OFFS_USRH = 0x13, // READ/ WRITE
XG_OFFS_USRL = 0x14, // READ/ WRITE
YG_OFFS_USRH = 0x15, // READ/ WRITE
YG_OFFS_USRL = 0x16, // READ/ WRITE
ZG_OFFS_USRH = 0x17, // READ/ WRITE
ZG_OFFS_USRL = 0x18, // READ/ WRITE
SMPLRT_DIV = 0x19, // READ/ WRITE
CONFIG = 0x1A, // READ/ WRITE default value:0x80
GYRO_CONFIG = 0x1B, // READ/ WRITE
ACCEL_CONFIG = 0x1C, // READ/ WRITE
ACCEL_CONFIG2 = 0x1D, // READ/ WRITE
LP_MODE_CFG = 0x1E, // READ/ WRITE
ACCEL_WOM_X_THR = 0x20, // READ/ WRITE
ACCEL_WOM_Y_THR = 0x21, // READ/ WRITE
ACCEL_WOM_Z_THR = 0x22, // READ/ WRITE
FIFO_EN = 0x23, // READ/ WRITE
FSYNC_INT = 0x36, // READ to CLEAR
INT_PIN_CFG = 0x37, // READ/ WRITE
INT_ENABLE = 0x38, // READ/ WRITE
FIFO_WM_INT_STATUS = 0x39, // READ to CLEAR
INT_STATUS = 0x3A, // READ to CLEAR
ACCEL_XOUT_H = 0x3B, // READ
ACCEL_XOUT_L = 0x3C, // READ
ACCEL_YOUT_H = 0x3D, // READ
ACCEL_YOUT_L = 0x3E, // READ
ACCEL_ZOUT_H = 0x3F, // READ
ACCEL_ZOUT_L = 0x40, // READ
TEMP_OUT_H = 0x41, // READ
TEMP_OUT_L = 0x42, // READ
GYRO_XOUT_H = 0x43, // READ
GYRO_XOUT_L = 0x44, // READ
GYRO_YOUT_H = 0x45, // READ
GYRO_YOUT_L = 0x46, // READ
GYRO_ZOUT_H = 0x47, // READ
GYRO_ZOUT_L = 0x48, // READ
SELF_TEST_X_GYRO = 0x50, // READ/ WRITE
SELF_TEST_Y_GYRO = 0x51, // READ/ WRITE
SELF_TEST_Z_GYRO = 0x52, // READ/ WRITE
FIFO_WM_TH1 = 0x60, // READ/ WRITE
FIFO_WM_TH2 = 0x61, // READ/ WRITE
SIGNAL_PATH_RESET = 0x68, // READ/ WRITE
ACCEL_INTEL_CTRL = 0x69, // READ/ WRITE
USER_CTRL = 0x6A, // READ/ WRITE
PWR_MGMT_1 = 0x6B, // READ/ WRITE default value:0x41
PWR_MGMT_2 = 0x6C, // READ/ WRITE
I2C_IF = 0x70, // READ/ WRITE
FIFO_COUNTH = 0x72, // READ
FIFO_COUNTL = 0x73, // READ
FIFO_R_W = 0x74, // READ/ WRITE
WHO_AM_I = 0x75, // READ default value:0x12
XA_OFFSET_H = 0x77, // READ/ WRITE
XA_OFFSET_L = 0x78, // READ/ WRITE
YA_OFFSET_H = 0x7A, // READ/ WRITE
YA_OFFSET_L = 0x7B, // READ/ WRITE
ZA_OFFSET_H = 0x7D, // READ/ WRITE
ZA_OFFSET_L = 0x7E, // READ/ WRITE
};
enum class mpu6050_RegMap :uint8_t
{
SELF_TEST_X = 0x0D, //R/W
SELF_TEST_Y = 0x0E, //R/W
SELF_TEST_Z = 0x0F, //R/W
SELF_TEST_A = 0x10, //R/W
SMPLRT_DIV = 0x19, //R/W
CONFIG = 0x1A, //R/W
GYRO_CONFIG = 0x1B, //R/W
ACCEL_CONFIG = 0x1C, //R/W
FIFO_EN = 0x23, //R/W
I2C_MST_CTRL = 0x24, //R/W
I2C_SLV0_ADDR = 0x25, //R/W
I2C_SLV0_REG = 0x26, //R/W
I2C_SLV0_CTRL = 0x27, //R/W
I2C_SLV1_ADDR = 0x28, //R/W
I2C_SLV1_REG = 0x29, //R/W
I2C_SLV1_CTRL = 0x2A, //R/W
I2C_SLV2_ADDR = 0x2B, //R/W
I2C_SLV2_REG = 0x2C, //R/W
I2C_SLV2_CTRL = 0x2D, //R/W
I2C_SLV3_ADDR = 0x2E, //R/W
I2C_SLV3_REG = 0x2F, //R/W
I2C_SLV3_CTRL = 0x30, //R/W
I2C_SLV4_ADDR = 0x31, //R/W
I2C_SLV4_REG = 0x32, //R/W
I2C_SLV4_DO = 0x33, //R/W
I2C_SLV4_CTRL = 0x34, //R/W
I2C_SLV4_DI = 0x35, //R
I2C_MST_STATUS = 0x36, //R
INT_PIN_CFG = 0x37, //R/W
INT_ENABLE = 0x38, //R/W
INT_STATUS = 0x3A, //R
ACCEL_XOUT_H = 0x3B, //R
ACCEL_XOUT_L = 0x3C, //R
ACCEL_YOUT_H = 0x3D, //R
ACCEL_YOUT_L = 0x3E, //R
ACCEL_ZOUT_H = 0x3F, //R
ACCEL_ZOUT_L = 0x40, //R
TEMP_OUT_H = 0x41, //R
TEMP_OUT_L = 0x42, //R
GYRO_XOUT_H = 0x43, //R
GYRO_XOUT_L = 0x44, //R
GYRO_YOUT_H = 0x45, //R
GYRO_YOUT_L = 0x46, //R
GYRO_ZOUT_H = 0x47, //R
GYRO_ZOUT_L = 0x48, //R
EXT_SENS_DATA_00 = 0x49, //R
EXT_SENS_DATA_01 = 0x4A, //R
EXT_SENS_DATA_02 = 0x4B, //R
EXT_SENS_DATA_03 = 0x4C, //R
EXT_SENS_DATA_04 = 0x4D, //R
EXT_SENS_DATA_05 = 0x4E, //R
EXT_SENS_DATA_06 = 0x4F, //R
EXT_SENS_DATA_07 = 0x50, //R
EXT_SENS_DATA_08 = 0x51, //R
EXT_SENS_DATA_09 = 0x52, //R
EXT_SENS_DATA_10 = 0x53, //R
EXT_SENS_DATA_11 = 0x54, //R
EXT_SENS_DATA_12 = 0x55, //R
EXT_SENS_DATA_13 = 0x56, //R
EXT_SENS_DATA_14 = 0x57, //R
EXT_SENS_DATA_15 = 0x58, //R
EXT_SENS_DATA_16 = 0x59, //R
EXT_SENS_DATA_17 = 0x5A, //R
EXT_SENS_DATA_18 = 0x5B, //R
EXT_SENS_DATA_19 = 0x5C, //R
EXT_SENS_DATA_20 = 0x5D, //R
EXT_SENS_DATA_21 = 0x5E, //R
EXT_SENS_DATA_22 = 0x5F, //R
EXT_SENS_DATA_23 = 0x60, //R
I2C_SLV0_DO = 0x63, //R/W
I2C_SLV1_DO = 0x64, //R/W
I2C_SLV2_DO = 0x65, //R/W
I2C_SLV3_DO = 0x66, //R/W
I2C_MST_DELAY_CTRL = 0x67, //R/W
SIGNAL_PATH_RESET = 0x68, //R/W
USER_CTRL = 0x6A, //R/W
PWR_MGMT_1 = 0x6B, //R/W
PWR_MGMT_2 = 0x6C, //R/W
FIFO_COUNTH = 0x72, //R/W
FIFO_COUNTL = 0x73, //R/W
FIFO_R_W = 0x74, //R/W
WHO_AM_I = 0x75, //R
};
enum class mpu9250_RegMap :uint8_t
{
SELF_TEST_X_GYRO = 0x0,//R/W
SELF_TEST_Y_GYRO = 0x1,//R/W
SELF_TEST_Z_GYRO = 0x2,//R/W
SELF_TEST_X_ACCEL = 0x0D,//R/W
SELF_TEST_Y_ACCEL = 0x0E,//R/W
SELF_TEST_Z_ACCEL = 0x0F,//R/W
XG_OFFSET_H = 0x13,//R/W
XG_OFFSET_L = 0x14,//R/W
YG_OFFSET_H = 0x15,//R/W
YG_OFFSET_L = 0x16,//R/W
ZG_OFFSET_H = 0x17,//R/W
ZG_OFFSET_L = 0x18,//R/W
SMPLRT_DIV = 0x19,//R/W
CONFIG = 0x1A,//R/W
GYRO_CONFIG = 0x1B,//R/W
ACCEL_CONFIG = 0x1C,//R/W
ACCEL_CONFIG2 = 0x1D,//R/W
LP_ACCEL_ODR = 0x1E,//R/W
WOM_THR = 0x1F,//R/W
FIFO_EN = 0x23,//R/W
I2C_MST_CTRL = 0x24,//R/W
I2C_SLV0_ADDR = 0x25,//R/W
I2C_SLV0_REG = 0x26,//R/W
I2C_SLV0_CTRL = 0x27,//R/W
I2C_SLV1_ADDR = 0x28,//R/W
I2C_SLV1_REG = 0x29,//R/W
I2C_SLV1_CTRL = 0x2A,//R/W
I2C_SLV2_ADDR = 0x2B,//R/W
I2C_SLV2_REG = 0x2C,//R/W
I2C_SLV2_CTRL = 0x2D,//R/W
I2C_SLV3_ADDR = 0x2E,//R/W
I2C_SLV3_REG = 0x2F,//R/W
I2C_SLV3_CTRL = 0x30,//R/W
I2C_SLV4_ADDR = 0x31,//R/W
I2C_SLV4_REG = 0x32,//R/W
I2C_SLV4_DO = 0x33,//R/W
I2C_SLV4_CTRL = 0x34,//R/W
I2C_SLV4_DI = 0x35,//R
I2C_MST_STATUS = 0x36,//R
INT_PIN_CFG = 0x37,//R/W
INT_ENABLE = 0x38,//R/W
INT_STATUS = 0x3A,//R
ACCEL_XOUT_H = 0x3B,//R
ACCEL_XOUT_L = 0x3C,//R
ACCEL_YOUT_H = 0x3D,//R
ACCEL_YOUT_L = 0x3E,//R
ACCEL_ZOUT_H = 0x3F,//R
ACCEL_ZOUT_L = 0x40,//R
TEMP_OUT_H = 0x41,//R
TEMP_OUT_L = 0x42,//R
GYRO_XOUT_H = 0x43,//R
GYRO_XOUT_L = 0x44,//R
GYRO_YOUT_H = 0x45,//R
GYRO_YOUT_L = 0x46,//R
GYRO_ZOUT_H = 0x47,//R
GYRO_ZOUT_L = 0x48,//R
EXT_SENS_DATA_00 = 0x49,//R
EXT_SENS_DATA_01 = 0x4A,//R
EXT_SENS_DATA_02 = 0x4B,//R
EXT_SENS_DATA_03 = 0x4C,//R
EXT_SENS_DATA_04 = 0x4D,//R
EXT_SENS_DATA_05 = 0x4E,//R
EXT_SENS_DATA_06 = 0x4F,//R
EXT_SENS_DATA_07 = 0x50,//R
EXT_SENS_DATA_08 = 0x51,//R
EXT_SENS_DATA_09 = 0x52,//R
EXT_SENS_DATA_10 = 0x53,//R
EXT_SENS_DATA_11 = 0x54,//R
EXT_SENS_DATA_12 = 0x55,//R
EXT_SENS_DATA_13 = 0x56,//R
EXT_SENS_DATA_14 = 0x57,//R
EXT_SENS_DATA_15 = 0x58,//R
EXT_SENS_DATA_16 = 0x59,//R
EXT_SENS_DATA_17 = 0x5A,//R
EXT_SENS_DATA_18 = 0x5B,//R
EXT_SENS_DATA_19 = 0x5C,//R
EXT_SENS_DATA_20 = 0x5D,//R
EXT_SENS_DATA_21 = 0x5E,//R
EXT_SENS_DATA_22 = 0x5F,//R
EXT_SENS_DATA_23 = 0x60,//R
I2C_SLV0_DO = 0x63,//R/W
I2C_SLV1_DO = 0x64,//R/W
I2C_SLV2_DO = 0x65,//R/W
I2C_SLV3_DO = 0x66,//R/W
I2C_MST_DELAY_CTRL = 0x67,//R/W
SIGNAL_PATH_RESET = 0x68,//R/W
MOT_DETECT_CTRL = 0x69,//R/W
USER_CTRL = 0x6A,//R/W
PWR_MGMT_1 = 0x6B,//R/W
PWR_MGMT_2 = 0x6C,//R/W
FIFO_COUNTH = 0x72,//R/W
FIFO_COUNTL = 0x73,//R/W
FIFO_R_W = 0x74,//R/W
WHO_AM_I = 0x75,//R
XA_OFFSET_H = 0x77,//R/W
XA_OFFSET_L = 0x78,//R/W
YA_OFFSET_H = 0x7A,//R/W
YA_OFFSET_L = 0x7B,//R/W
ZA_OFFSET_H = 0x7D,//R/W
ZA_OFFSET_L = 0x7E,//R/W
};
enum class ak8963_RegMap : uint8_t {
//Magnetometer register maps
WIA = 0x00,
INFO = 0x01,
ST1 = 0x02,
XOUT_L = 0x03,
XOUT_H = 0x04,
YOUT_L = 0x05,
YOUT_H = 0x06,
ZOUT_L = 0x07,
ZOUT_H = 0x08,
ST2 = 0x09,
CNTL = 0x0A,
CNTL2 = 0x0B,
RSV = 0x0B, //DO NOT ACCESS <MPU9250_AK8963_CNTL2>
ASTC = 0x0C,
TS1 = 0x0D, //DO NOT ACCESS
TS2 = 0x0E, //DO NOT ACCESS
I2CDIS = 0x0F,
ASAX = 0x10,
ASAY = 0x11,
ASAZ = 0x12,
};
}
#endif // ! HITSIC_USE_DRV_IMU_INV
#endif //UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP | 30.846395 | 75 | 0.617378 | JerrySkywalker |
b45b664660b3cd0a2319cf5c7c4a09eb52d88aae | 751 | hpp | C++ | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | 23 | 2015-05-28T06:51:30.000Z | 2021-10-11T07:40:05.000Z | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | null | null | null | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | 18 | 2015-07-25T16:49:35.000Z | 2021-11-18T15:59:48.000Z | /**
Copyright (c) 2014-2015, Sandia Corporation
All rights reserved.
This file is part of fast-matmul and is under the BSD 2-Clause License,
which can be found in the LICENSE file in the root directory, or at
http://opensource.org/licenses/BSD-2-Clause.
*/
#ifndef _COMMON_HPP_
#define _COMMON_HPP_
#define _DFS_PAR_ 1
#define _BFS_PAR_ 2
#define _HYBRID_PAR_ 3
#include "MemoryManager.hpp"
#include "linalg.hpp"
#ifdef _PARALLEL_
# include "omp.h"
#endif
#include "par_util.hpp"
#include "options.hpp"
#include "timing.hpp"
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T>& vec) {
for (int i = 0; i < vec.size(); ++i) {
os << vec[i] << " ";
}
os << std::endl;
}
#endif // _COMMON_HPP_
| 19.763158 | 75 | 0.683089 | gballard |
b45c896100fb8f4a59174db2debfd666428b5223 | 4,068 | cpp | C++ | code/Gui/BibleBookWindow.cpp | jpike/BibleProgram | 4d7dcb792dcf630759037fd854873e2bcd778aa2 | [
"Unlicense"
] | null | null | null | code/Gui/BibleBookWindow.cpp | jpike/BibleProgram | 4d7dcb792dcf630759037fd854873e2bcd778aa2 | [
"Unlicense"
] | null | null | null | code/Gui/BibleBookWindow.cpp | jpike/BibleProgram | 4d7dcb792dcf630759037fd854873e2bcd778aa2 | [
"Unlicense"
] | null | null | null | #include <ThirdParty/imgui/imgui.h>
#include "Gui/BibleBookWindow.h"
namespace GUI
{
/// Updates and renders a single frame of the window, if it's open.
/// @return The verse range for any selected chapter; null if no chapter was selected.
std::optional<BIBLE_DATA::BibleVerseRange> BibleBookWindow::UpdateAndRender()
{
// DON'T RENDER ANYTHING IF THE WINDOW ISN'T OPEN.
if (!Open)
{
return std::nullopt;
}
// RENDER THE WINDOW AND GET ANY SELECTED CHAPTER.
std::optional<BIBLE_DATA::BibleVerseRange> selected_verse_range;
// Window positioning/sizing is only done upon the first use to allow preserving a user's manual changes.
// The window is positioned to basically be in the top-left corner of the window after the main menu bar.
ImVec2 current_drawing_cursor_position = ImGui::GetCursorPos();
ImGui::SetNextWindowPos(current_drawing_cursor_position, ImGuiCond_FirstUseEver);
// The width is set to be wide enough for all book titles to be displayed.
constexpr float MAX_BOOK_TITLE_WIDTH_IN_PIXELS = 200.0f;
ImGuiIO& io = ImGui::GetIO();
float available_vertical_screen_space_in_pixels = io.DisplaySize.y - current_drawing_cursor_position.y;
ImVec2 window_size_in_pixels(MAX_BOOK_TITLE_WIDTH_IN_PIXELS, available_vertical_screen_space_in_pixels);
ImGui::SetNextWindowSize(window_size_in_pixels, ImGuiCond_FirstUseEver);
if (ImGui::Begin("Books & Chapters", &Open))
{
// RENDER EACH BOOK.
for (const auto& id_and_book : BIBLE_DATA::Bible::BOOKS_BY_ID)
{
// RENDER THE CURRENT BOOK WITH A COLLAPSING TREE NODE.
std::string book_name = BIBLE_DATA::BibleBook::FullName(id_and_book.first);
if (ImGui::TreeNodeEx(book_name.c_str(), ImGuiTreeNodeFlags_CollapsingHeader))
{
// RENDER A SELECTABLE ITEM FOR EACH CHAPTER.
const BIBLE_DATA::BibleBook& book = id_and_book.second;
std::size_t chapter_count = book.VerseCountsByChapter.size();
for (std::size_t chapter_index = 0; chapter_index < chapter_count; ++chapter_index)
{
// RENDER A SELECTABLE FOR THE CHAPTER.
unsigned int chapter_number = static_cast<unsigned int>(chapter_index + 1);
std::string chapter_text = "Chapter " + std::to_string(chapter_number);
std::string chapter_id = "##" + book_name + chapter_text;
std::string chapter_text_and_id = chapter_text + chapter_id;
if (ImGui::Selectable(chapter_text_and_id.c_str()))
{
// TRACK THE SELECTED CHAPTER.
unsigned int chapter_verse_count = book.VerseCountsByChapter[chapter_index];
selected_verse_range = BIBLE_DATA::BibleVerseRange
{
.StartingVerse = BIBLE_DATA::BibleVerseId
{
.Book = id_and_book.first,
.ChapterNumber = chapter_number,
// All chapters begin at verse 1.
.VerseNumber = 1
},
.EndingVerse = BIBLE_DATA::BibleVerseId
{
.Book = id_and_book.first,
.ChapterNumber = chapter_number,
.VerseNumber = chapter_verse_count
},
};
}
}
}
}
}
ImGui::End();
// RETURN ANY SELECTED CHAPTER.
return selected_verse_range;
}
}
| 52.153846 | 113 | 0.547689 | jpike |
b45db9ab5dd1c1e096f4fef50396bb0c72308b7b | 716 | cpp | C++ | src/Entry.cpp | nathanmentley/EssexEngineConfigDaemon | cf68b32c40b610914ae1c9dc3fa2f46b6d0171aa | [
"BSD-2-Clause"
] | null | null | null | src/Entry.cpp | nathanmentley/EssexEngineConfigDaemon | cf68b32c40b610914ae1c9dc3fa2f46b6d0171aa | [
"BSD-2-Clause"
] | null | null | null | src/Entry.cpp | nathanmentley/EssexEngineConfigDaemon | cf68b32c40b610914ae1c9dc3fa2f46b6d0171aa | [
"BSD-2-Clause"
] | null | null | null | /*
* Essex Engine
*
* Copyright (C) 2018 Nathan Mentley - All Rights Reserved
* You may use, distribute and modify this code under the
* terms of the BSD license.
*
* You should have received a copy of the BSD license with
* this file. If not, please visit: https://github.com/nathanmentley/EssexEngine
*/
#include <EssexEngineConfigDaemon/ConfigDaemon.h>
using EssexEngine::Context;
using EssexEngine::WeakPointer;
using EssexEngine::Daemons::Config::ConfigDaemon;
extern "C" {
void* daemon_init(WeakPointer<Context> context) {
ConfigDaemon* daemon = new ConfigDaemon(context);
context->RegisterDaemon<ConfigDaemon>(
daemon
);
return daemon;
}
}
| 23.866667 | 80 | 0.695531 | nathanmentley |
b45ea979df345cf23b7c7ea1ed0cd6a130dd70c5 | 7,239 | hpp | C++ | include/lapack/lahqr_schur22.hpp | thijssteel/tlapack | 0749324fdecfc80c089d58d8d43500b66a20df70 | [
"BSD-3-Clause"
] | null | null | null | include/lapack/lahqr_schur22.hpp | thijssteel/tlapack | 0749324fdecfc80c089d58d8d43500b66a20df70 | [
"BSD-3-Clause"
] | null | null | null | include/lapack/lahqr_schur22.hpp | thijssteel/tlapack | 0749324fdecfc80c089d58d8d43500b66a20df70 | [
"BSD-3-Clause"
] | null | null | null | /// @file lahqr_schur22.hpp
/// @author Thijs Steel, KU Leuven, Belgium
/// Adapted from @see https://github.com/Reference-LAPACK/lapack/tree/master/SRC/dlanv2.f
//
// Copyright (c) 2013-2022, University of Colorado Denver. All rights reserved.
//
// This file is part of <T>LAPACK.
// <T>LAPACK is free software: you can redistribute it and/or modify it under
// the terms of the BSD 3-Clause license. See the accompanying LICENSE file.
#ifndef __LAHQR_SCHUR22_HH__
#define __LAHQR_SCHUR22_HH__
#include <complex>
#include <cmath>
#include "lapack/utils.hpp"
#include "lapack/types.hpp"
namespace lapack
{
/** Computes the Schur factorization of a 2x2 matrix A
*
* A = [a b] = [cs -sn] [aa bb] [ cs sn]
* [c d] [sn cs] [cc dd] [-sn cs]
*
* This routine is designed for real matrices.
* If the template T is complex, it returns with error
* and does nothing. (This is so we don't need c++17's static if
* but still keep the code somewhat clean).
*
* @return 0 if the template T is real
* @return -1 if the template T is complex
*
* @param[in,out] a scalar, A(0,0).
* @param[in,out] b scalar, A(0,1).
* @param[in,out] c scalar, A(1,0).
* @param[in,out] d scalar, A(1,1).
* On entry, the elements of the matrix A.
* On exit, the elements of the Schur factor (aa, bb, cc and dd).
* @param[out] s1 complex scalar.
* First eigenvalue of the matrix.
* @param[out] s2 complex scalar.
* Second eigenvalue of the matrix.
* @param[out] cs scalar.
* Cosine factor of the rotation
* @param[out] sn scalar.
* Sine factor of the rotation
*
* @ingroup geev
*/
template <
typename T,
enable_if_t<!is_complex<T>::value, bool> = true>
int lahqr_schur22(T &a, T &b, T &c, T &d, std::complex<T> &s1, std::complex<T> &s2, T &cs, T &sn)
{
using blas::abs;
using std::log;
using std::max;
using std::min;
using std::pow;
using std::copysign;
const T zero(0);
const T half(0.5);
const T one(1);
const T two(2);
const T multpl(4);
const T eps = blas::uroundoff<T>();
const T safmin = blas::safe_min<T>();
const T safmn2 = pow(two, (int)(log(safmin / eps) / log(two)) / two);
const T safmx2 = one / safmn2;
if (c == zero)
{
// c is zero, the matrix is already in Schur form.
cs = one;
sn = zero;
}
else if (b == zero)
{
// b is zero, swapping rows and columns results in Schur form.
cs = zero;
sn = one;
auto temp = d;
d = a;
a = temp;
b = -c;
c = zero;
}
else if ((a - d) == zero and copysign(one,b) != copysign(one,c))
{
cs = one;
sn = zero;
}
else
{
auto temp = a - d;
auto p = half * temp;
auto bcmax = max(abs(b), abs(c));
auto bcmin = min(abs(b), abs(c)) * copysign(one,b) * copysign(one,c);
auto scale = max(abs(p), bcmax);
auto z = (p / scale) * p + (bcmax / scale) * bcmin;
// if z is positive, we should have real eigenvalues
// however, is z is very small, but positive, we postpone the decision
if (z >= multpl * eps)
{
// Real eigenvalues.
// Compute a and d.
z = p + copysign(one,p) * sqrt(scale) * sqrt(z);
a = d + z;
d = d - (bcmax / z) * bcmin;
// Compute b and the rotation matrix
auto tau = lapy2(c, z);
cs = z / tau;
sn = c / tau;
b = b - c;
c = zero;
}
else
{
// Complex eigenvalues, or real (almost) equal eigenvalues.
// Make diagonal elements equal.
auto sigma = b + c;
for (int count = 0; count < 20; ++count)
{
scale = max(abs(temp), abs(sigma));
if (scale >= safmx2)
{
sigma = sigma * safmn2;
temp = temp * safmn2;
continue;
}
if (scale <= safmn2)
{
sigma = sigma * safmx2;
temp = temp * safmx2;
continue;
}
break;
}
p = half * temp;
auto tau = lapy2(sigma, temp);
cs = sqrt(half * (one + abs(sigma) / tau));
sn = -(p / (tau * cs)) * copysign(one,sigma);
//
// Compute [aa bb] = [a b][cs -sn]
// [cc dd] = [c d][sn cs]
//
auto aa = a * cs + b * sn;
auto bb = -a * sn + b * cs;
auto cc = c * cs + d * sn;
auto dd = -c * sn + d * cs;
//
// Compute [a b] = [ cs sn][aa bb]
// [c d] = [-sn cs][cc dd]
//
a = aa * cs + cc * sn;
b = bb * cs + dd * sn;
c = -aa * sn + cc * cs;
d = -bb * sn + dd * cs;
temp = half * (a + d);
a = temp;
d = temp;
if (c != zero)
{
if (b != zero)
{
if (copysign(one,b) == copysign(one,c))
{
// Real eigenvalues: reduce to upper triangular form
auto sab = sqrt(abs(b));
auto sac = sqrt(abs(c));
p = abs(c) * copysign(one,sab * sac);
tau = one / sqrt(abs(b + c));
a = temp + p;
d = temp - p;
b = b - c;
c = zero;
auto cs1 = sab * tau;
auto sn1 = sac * tau;
temp = cs * cs1 - sn * sn1;
sn = cs * sn1 + sn * cs1;
cs = temp;
}
}
}
}
}
// Store eigenvalues in s1 and s2
if (c != zero)
{
auto temp = sqrt(abs(b)) * sqrt(abs(c));
s1 = std::complex<T>(a, temp);
s2 = std::complex<T>(d, -temp);
}
else
{
s1 = a;
s2 = d;
}
return 0;
}
template <
typename T,
enable_if_t<is_complex<T>::value, bool> = true>
int lahqr_schur22(T &a, T &b, T &c, T &d, T &s1, T &s2, real_type<T> &cs, T &sn)
{
return -1;
}
} // lapack
#endif // __LAHQR_SCHUR22_HH__
| 32.461883 | 101 | 0.407377 | thijssteel |
b45f0016f7e0a1abeecc609efcacdbc8583a2e51 | 14,504 | cpp | C++ | src/Core/ECEditorModule/AssetsWindow.cpp | Adminotech/tundra | 8270097dbf79c3ec1935cf66c7979eeef9c24c0e | [
"Apache-2.0"
] | null | null | null | src/Core/ECEditorModule/AssetsWindow.cpp | Adminotech/tundra | 8270097dbf79c3ec1935cf66c7979eeef9c24c0e | [
"Apache-2.0"
] | null | null | null | src/Core/ECEditorModule/AssetsWindow.cpp | Adminotech/tundra | 8270097dbf79c3ec1935cf66c7979eeef9c24c0e | [
"Apache-2.0"
] | null | null | null | /**
For conditions of distribution and use, see copyright notice in LICENSE
@file AssetsWindow.cpp
@brief The main UI for managing asset storages and assets. */
#include "StableHeaders.h"
#include "DebugOperatorNew.h"
#include "AssetsWindow.h"
#include "AssetTreeWidget.h"
#include "TreeWidgetUtils.h"
#include "SceneTreeWidgetItems.h"
#include "Framework.h"
#include "AssetAPI.h"
#include "IAsset.h"
#include "IAssetBundle.h"
#include "IAssetStorage.h"
#include "UiAPI.h"
#include "Profiler.h"
#include "MemoryLeakCheck.h"
namespace
{
bool HasSameRefAsPredecessors(QTreeWidgetItem *item)
{
QTreeWidgetItem *parent = 0, *child = item;
while((parent = child->parent()) != 0)
{
if (parent->text(0).compare(child->text(0), Qt::CaseInsensitive) == 0)
return true;
child = parent;
}
return false;
}
}
AssetsWindow::AssetsWindow(Framework *fw, QWidget *parent) :
QWidget(parent),
framework(fw),
noStorageItem(0)
{
Initialize();
PopulateTreeWidget();
}
AssetsWindow::AssetsWindow(const QString &assetType_, Framework *fw, QWidget *parent) :
QWidget(parent),
framework(fw),
noStorageItem(0),
assetType(assetType_)
{
Initialize();
PopulateTreeWidget();
// Asset picking layout
QSpacerItem *spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
QPushButton *cancelButton = new QPushButton(tr("Cancel"), this);
QPushButton *pickButton = new QPushButton(tr("Pick"), this);
QHBoxLayout *hlayout2= new QHBoxLayout;
hlayout2->insertSpacerItem(-1, spacer);
hlayout2->addWidget(pickButton);
hlayout2->addWidget(cancelButton);
static_cast<QVBoxLayout *>(layout())->addLayout(hlayout2);
connect(treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), SLOT(ChangeSelectedAsset(QTreeWidgetItem *)));
connect(pickButton, SIGNAL(clicked()), SLOT(PickAssetAndClose()));
connect(cancelButton, SIGNAL(clicked()), SLOT(Cancel()));
}
AssetsWindow::~AssetsWindow()
{
// Disable ResizeToContents, Qt goes sometimes into eternal loop after
// ~AssetsWindow() if we have lots (hundreds or thousands) of items.
treeWidget->blockSignals(true);
treeWidget->header()->setResizeMode(QHeaderView::Interactive);
QTreeWidgetItemIterator it(treeWidget);
while(*it)
{
QTreeWidgetItem *item = *it;
SAFE_DELETE(item);
++it;
}
}
void AssetsWindow::PopulateTreeWidget()
{
PROFILE(AssetsWindow_PopulateTreeWidget)
treeWidget->clear();
alreadyAdded.clear();
// Create "No provider" for assets without storage.
SAFE_DELETE(noStorageItem);
noStorageItem = new QTreeWidgetItem();
noStorageItem->setText(0, tr("No Storage"));
// Iterate storages
CreateStorageItem(framework->Asset()->DefaultAssetStorage());
foreach(const AssetStoragePtr &storage, framework->Asset()->AssetStorages())
CreateStorageItem(storage);
// Iterate asset bundles
std::pair<QString, AssetBundlePtr> bundlePair;
foreach(bundlePair, framework->Asset()->AssetBundles())
AddBundle(bundlePair.second);
// Iterate assets
std::pair<QString, AssetPtr> pair;
foreach(pair, framework->Asset()->Assets())
AddAsset(pair.second);
// Add the no provider last and hide if no children.
treeWidget->addTopLevelItem(noStorageItem);
noStorageItem->setHidden(noStorageItem->childCount() == 0);
}
void AssetsWindow::AddAsset(const AssetPtr &asset)
{
PROFILE(AssetsWindow_AddAsset)
if (alreadyAdded.find(asset) != alreadyAdded.end())
return;
if (!assetType.isEmpty() && assetType != asset->Type())
return;
AssetItem *item = CreateAssetItem(asset);
if (!item)
return;
AddChildren(asset, item);
connect(asset.get(), SIGNAL(Loaded(AssetPtr)), SLOT(UpdateAssetItem(AssetPtr)), Qt::UniqueConnection);
connect(asset.get(), SIGNAL(Unloaded(IAsset *)), SLOT(UpdateAssetItem(IAsset *)), Qt::UniqueConnection);
connect(asset.get(), SIGNAL(PropertyStatusChanged(IAsset *)), SLOT(UpdateAssetItem(IAsset *)), Qt::UniqueConnection);
noStorageItem->setHidden(noStorageItem->childCount() == 0);
// If we have an ongoing search, make sure that the new item is compared too.
QString searchFilter = searchField->text().trimmed();
if (!searchFilter.isEmpty())
TreeWidgetSearch(treeWidget, 0, searchFilter);
}
void AssetsWindow::AddBundle(const AssetBundlePtr &bundle)
{
CreateBundleItem(bundle);
}
void AssetsWindow::RemoveAsset(AssetPtr asset)
{
QTreeWidgetItemIterator it(treeWidget);
while(*it)
{
AssetItem *item = dynamic_cast<AssetItem *>(*it);
if (item && item->Asset() && item->Asset() == asset)
{
QTreeWidgetItem *parent = item->parent();
parent->removeChild(item);
SAFE_DELETE(item);
alreadyAdded.erase(asset);
addedItemNames.erase(asset->Name());
}
++it;
}
}
void AssetsWindow::Search(const QString &filter)
{
TreeWidgetSearch(treeWidget, 0, filter);
}
void AssetsWindow::UpdateAssetItem(IAsset *asset)
{
QTreeWidgetItemIterator it(treeWidget);
while(*it)
{
AssetItem *item = dynamic_cast<AssetItem *>(*it);
if (item && item->Asset().get() == asset)
{
item->SetText(asset);
break;
}
++it;
}
}
void AssetsWindow::Initialize()
{
setWindowTitle(tr("Assets"));
// Append asset type if we're viewing only assets of specific type.
if (!assetType.isEmpty())
setWindowTitle(windowTitle() + ": " + assetType);
resize(450, 450);
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setContentsMargins(5, 5, 5, 5);
setLayout(layout);
// Create child widgets
treeWidget = new AssetTreeWidget(framework, this);
treeWidget->setHeaderHidden(true);
searchField = new QLineEdit(this);
searchField->setPlaceholderText(tr("Search..."));
expandAndCollapseButton = new QPushButton(tr("Expand All"), this);
QHBoxLayout *hlayout= new QHBoxLayout;
hlayout->addWidget(searchField);
hlayout->addWidget(expandAndCollapseButton);
layout->addLayout(hlayout);
layout->addWidget(treeWidget);
connect(searchField, SIGNAL(textEdited(const QString &)), SLOT(Search(const QString &)));
connect(expandAndCollapseButton, SIGNAL(clicked()), SLOT(ExpandOrCollapseAll()));
connect(framework->Asset(), SIGNAL(AssetCreated(AssetPtr)), SLOT(AddAsset(AssetPtr)));
connect(framework->Asset(), SIGNAL(AssetAboutToBeRemoved(AssetPtr)), SLOT(RemoveAsset(AssetPtr)));
connect(treeWidget, SIGNAL(itemCollapsed(QTreeWidgetItem*)), SLOT(CheckTreeExpandStatus(QTreeWidgetItem*)));
connect(treeWidget, SIGNAL(itemExpanded(QTreeWidgetItem*)), SLOT(CheckTreeExpandStatus(QTreeWidgetItem*)));
connect(treeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), SLOT(OnItemDoubleClicked(QTreeWidgetItem*, int)));
}
void AssetsWindow::closeEvent(QCloseEvent *e)
{
emit AboutToClose(this);
QWidget::closeEvent(e);
}
void AssetsWindow::AddChildren(const AssetPtr &asset, QTreeWidgetItem *parent)
{
PROFILE(AssetsWindow_AddChildren)
foreach(const AssetReference &ref, asset->FindReferences())
{
AssetPtr asset = framework->Asset()->GetAsset(ref.ref);
if (asset && alreadyAdded.find(asset) == alreadyAdded.end())
{
AssetItem *item = new AssetItem(asset, parent);
parent->addChild(item);
alreadyAdded.insert(asset);
// Check for recursive dependencies.
if (HasSameRefAsPredecessors(item))
item->setText(0, tr("Recursive dependency to ") + asset->Name());
else
AddChildren(asset, item);
}
}
}
void AssetsWindow::ExpandOrCollapseAll()
{
treeWidget->blockSignals(true);
bool treeExpanded = TreeWidgetExpandOrCollapseAll(treeWidget);
treeWidget->blockSignals(false);
expandAndCollapseButton->setText(treeExpanded ? tr("Collapse All") : tr("Expand All"));
}
void AssetsWindow::CheckTreeExpandStatus(QTreeWidgetItem * /*item*/)
{
expandAndCollapseButton->setText(TreeWidgetIsAnyExpanded(treeWidget) ? tr("Collapse All") : tr("Expand All"));
}
void AssetsWindow::OnItemDoubleClicked(QTreeWidgetItem *item, int /*column*/)
{
AssetItem* assItem = dynamic_cast<AssetItem*>(item);
if (!assItem || !assItem->Asset())
return;
QMenu dummyMenu;
QList<QObject*> targets;
targets.push_back(assItem->Asset().get());
framework->Ui()->EmitContextMenuAboutToOpen(&dummyMenu, targets);
foreach(QAction *action, dummyMenu.actions())
if (action->text() == "Open")
{
action->activate(QAction::ActionEvent());
break;
}
}
void AssetsWindow::ChangeSelectedAsset(QTreeWidgetItem *current)
{
// Note: clause if <=1 cause for some reason when activating item for the first time
// treeWidget->selectedItems().size() returns 0, even though we should have 1.
if (treeWidget->selectedItems().size() <= 1 && current)
{
AssetItem *item = dynamic_cast<AssetItem *>(current);
if (item && item->Asset())
emit SelectedAssetChanged(item->Asset());
}
}
void AssetsWindow::PickAssetAndClose()
{
if (treeWidget->selectedItems().size() == 1)
{
AssetItem *item = dynamic_cast<AssetItem *>(treeWidget->currentItem());
if (item && item->Asset())
emit AssetPicked(item->Asset());
}
close();
}
void AssetsWindow::Cancel()
{
emit PickCanceled();
close();
}
AssetStorageItem *AssetsWindow::CreateStorageItem(const AssetStoragePtr &storage)
{
for (int i=0; i<treeWidget->topLevelItemCount(); ++i)
{
AssetStorageItem *existing = dynamic_cast<AssetStorageItem*>(treeWidget->topLevelItem(i));
if (existing && storage == existing->Storage())
return 0;
}
AssetStorageItem *item = new AssetStorageItem(storage);
treeWidget->addTopLevelItem(item);
if (storage == framework->Asset()->DefaultAssetStorage())
{
QFont font = item->font(0);
font.setBold(true);
item->setFont(0, font);
}
return item;
}
AssetBundleItem *AssetsWindow::CreateBundleItem(const AssetBundlePtr &bundle)
{
if (addedItemNames.find(bundle->Name()) != addedItemNames.end())
return 0;
// for (int i=0; i<treeWidget->topLevelItemCount(); ++i)
// if (FindBundleItemRecursive(treeWidget->topLevelItem(i), bundle))
// return 0;
addedItemNames.insert(bundle->Name());
QTreeWidgetItem *p = FindParentItem(bundle);
AssetBundleItem *item = new AssetBundleItem(bundle, p);
p->addChild(item);
return item;
}
AssetItem *AssetsWindow::CreateAssetItem(const AssetPtr &asset)
{
if (addedItemNames.find(asset->Name()) != addedItemNames.end())
return 0;
// for (int i=0; i<treeWidget->topLevelItemCount(); ++i)
// if (FindAssetItemRecursive(treeWidget->topLevelItem(i), asset))
// return 0;
addedItemNames.insert(asset->Name());
QTreeWidgetItem *p = FindParentItem(asset);
AssetItem *item = new AssetItem(asset, p);
p->addChild(item);
return item;
}
AssetBundleItem *AssetsWindow::FindBundleItemRecursive(QTreeWidgetItem *parent, const AssetBundlePtr &bundle)
{
PROFILE(AssetsWindow_FindBundleItemRecursive_bundle)
if (!parent || parent->childCount() == 0)
return 0;
AssetBundleItem *result = 0;
for (int i=0; i<parent->childCount(); ++i)
{
AssetBundleItem *existing = dynamic_cast<AssetBundleItem*>(parent->child(i));
if (existing && existing->AssetBundle() == bundle)
result = existing;
else
result = FindBundleItemRecursive(parent->child(i), bundle);
if (result)
break;
}
return result;
}
AssetBundleItem *AssetsWindow::FindBundleItemRecursive(QTreeWidgetItem *parent, const QString &subAssetRef)
{
PROFILE(AssetsWindow_FindBundleItemRecursive_subAssetRef)
if (!parent || parent->childCount() == 0)
return 0;
AssetBundleItem *result = 0;
for (int i=0; i<parent->childCount(); ++i)
{
AssetBundleItem *existing = dynamic_cast<AssetBundleItem*>(parent->child(i));
if (existing && existing->Contains(subAssetRef))
result = existing;
else
result = FindBundleItemRecursive(parent->child(i), subAssetRef);
if (result)
break;
}
return result;
}
AssetItem *AssetsWindow::FindAssetItemRecursive(QTreeWidgetItem *parent, const AssetPtr &asset)
{
PROFILE(AssetsWindow_FindAssetItemRecursive)
if (!parent || parent->childCount() == 0)
return 0;
AssetItem *result = 0;
for (int i=0; i<parent->childCount(); ++i)
{
AssetItem *existing = dynamic_cast<AssetItem*>(parent->child(i));
if (existing && existing->Asset() == asset)
result = existing;
else
result = FindAssetItemRecursive(parent->child(i), asset);
if (result)
break;
}
return result;
}
template <typename T>
QTreeWidgetItem *AssetsWindow::FindParentItem(const T &item)
{
PROFILE(AssetsWindow_FindParentItem)
QString subAssetPart;
AssetAPI::ParseAssetRef(item->Name(), 0, 0, 0, 0, 0, 0, 0, &subAssetPart);
for (int i=0; i<treeWidget->topLevelItemCount(); ++i)
{
AssetStorageItem *existingStorage = dynamic_cast<AssetStorageItem*>(treeWidget->topLevelItem(i));
if (existingStorage && existingStorage->Storage() == item->AssetStorage())
{
// If this is a sub asset to a bundle, find the bundle item from this storage.
if (!subAssetPart.isEmpty())
{
AssetBundleItem *existingBundle = FindBundleItemRecursive(existingStorage, item->Name());
if (existingBundle)
return existingBundle;
}
return existingStorage;
}
}
// If this is a sub asset to a bundle, try to find the bundle also from no storage item.
if (!subAssetPart.isEmpty())
{
AssetBundleItem *existingBundle = FindBundleItemRecursive(noStorageItem, item->Name());
if (existingBundle)
return existingBundle;
}
return noStorageItem;
}
| 31.462039 | 136 | 0.659887 | Adminotech |
b45f1ae2574f22d0eefff0fe653705ce7635a675 | 53 | cpp | C++ | testdata/codes/minidetailtest/a.cpp | Judge-Girl/Code-Quality-Inspection | 6d0d455fb1c47eba17157a99db5e09fbc61484b8 | [
"Apache-2.0"
] | 1 | 2021-04-22T08:29:03.000Z | 2021-04-22T08:29:03.000Z | testdata/codes/minidetailtest/a.cpp | Judge-Girl/Code-Quality-Inspection | 6d0d455fb1c47eba17157a99db5e09fbc61484b8 | [
"Apache-2.0"
] | 12 | 2020-11-20T10:05:15.000Z | 2021-01-19T11:10:59.000Z | testdata/codes/minidetailtest/a.cpp | Judge-Girl/Code-Quality-Inspection | 6d0d455fb1c47eba17157a99db5e09fbc61484b8 | [
"Apache-2.0"
] | null | null | null | int global;
int main() {
int i, j, k, l, m, n;
} | 10.6 | 25 | 0.471698 | Judge-Girl |
b461cbe8e184a4af4d67f04a595b31ffa8958310 | 943 | cpp | C++ | src/shogun/features/streaming/StreamingFeatures.cpp | cloner1984/shogun | 901c04b2c6550918acf0594ef8afeb5dcd840a7d | [
"BSD-3-Clause"
] | 2 | 2021-08-12T18:11:06.000Z | 2021-11-17T10:56:49.000Z | src/shogun/features/streaming/StreamingFeatures.cpp | cloner1984/shogun | 901c04b2c6550918acf0594ef8afeb5dcd840a7d | [
"BSD-3-Clause"
] | null | null | null | src/shogun/features/streaming/StreamingFeatures.cpp | cloner1984/shogun | 901c04b2c6550918acf0594ef8afeb5dcd840a7d | [
"BSD-3-Clause"
] | null | null | null | /*
* This software is distributed under BSD 3-clause license (see LICENSE file).
*
* Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn, Viktor Gal
*/
#include <shogun/features/streaming/StreamingFeatures.h>
#include <shogun/features/streaming/StreamingDenseFeatures.h>
#include <shogun/features/DenseFeatures.h>
using namespace shogun;
CStreamingFeatures::CStreamingFeatures() : CFeatures()
{
working_file=NULL;
}
CStreamingFeatures::~CStreamingFeatures()
{
SG_DEBUG("entering CStreamingFeatures::~CStreamingFeatures()\n")
SG_UNREF(working_file);
SG_DEBUG("leaving CStreamingFeatures::~CStreamingFeatures()\n")
}
void CStreamingFeatures::set_read_functions()
{
set_vector_reader();
set_vector_and_label_reader();
}
bool CStreamingFeatures::get_has_labels()
{
return has_labels;
}
bool CStreamingFeatures::is_seekable()
{
return seekable;
}
void CStreamingFeatures::reset_stream()
{
SG_NOTIMPLEMENTED
return;
}
| 20.955556 | 78 | 0.78473 | cloner1984 |
b461e27023e41ba199fabe3b2ccc5d55a67cc931 | 8,443 | cc | C++ | src/ge/common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.cc | TommyLike/graphengine | da2c616522cc078c2573eca8422ff70fda229efb | [
"Apache-2.0"
] | 1 | 2020-07-18T17:49:20.000Z | 2020-07-18T17:49:20.000Z | src/ge/common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.cc | zengchen1024/graphengine | 0c33e9d12562953ca4bd6c03cb77da2c2da74acd | [
"Apache-2.0"
] | null | null | null | src/ge/common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.cc | zengchen1024/graphengine | 0c33e9d12562953ca4bd6c03cb77da2c2da74acd | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.h"
#include <securec.h>
#include <memory>
#include "common/formats/utils/formats_definitions.h"
#include "common/formats/utils/formats_trans_utils.h"
#include "framework/common/debug/ge_log.h"
#include "graph/utils/type_utils.h"
namespace ge {
namespace formats {
namespace {
bool CheckDataTypeSupported(const DataType &data_type) { return GetSizeByDataType(data_type) > 0; }
Status TransShapeNhwcToNc1hwc0(const std::vector<int64_t> &src_shape, DataType data_type,
std::vector<int64_t> &dst_shape) {
int64_t c0 = GetCubeSizeByDataType(data_type);
if (c0 <= 0) {
GELOGE(PARAM_INVALID, "Failed to get cube size, the data type is invalid");
return PARAM_INVALID;
}
dst_shape.clear();
dst_shape.push_back(src_shape.at(kNhwcN));
dst_shape.push_back((src_shape.at(kNhwcC) - 1) / c0 + 1);
dst_shape.push_back(src_shape.at(kNhwcH));
dst_shape.push_back(src_shape.at(kNhwcW));
dst_shape.push_back(c0);
if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
}
return SUCCESS;
}
Status CheckArgsForNhwcToNc1hwc0(const TransArgs &args) {
if (args.src_format != FORMAT_NHWC || args.dst_format != FORMAT_NC1HWC0) {
GELOGE(UNSUPPORTED, "Does not support trans format from %s to %s",
TypeUtils::FormatToSerialString(args.src_format).c_str(),
TypeUtils::FormatToSerialString(args.dst_format).c_str());
return UNSUPPORTED;
}
if (!CheckDataTypeSupported(args.src_data_type)) {
GELOGE(UNSUPPORTED, "Failed to trans shape from NHWC to NC1HWC0, invalid data type %s",
TypeUtils::DataTypeToSerialString(args.src_data_type).c_str());
return UNSUPPORTED;
}
if (!CheckShapeValid(args.src_shape, kNhwcDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(args.src_shape).c_str());
return PARAM_INVALID;
}
if (!CheckShapeValid(args.dst_shape, kNc1hwc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(args.dst_shape).c_str());
return PARAM_INVALID;
}
std::vector<int64_t> expect_dst_shape;
auto ret = TransShapeNhwcToNc1hwc0(args.src_shape, args.src_data_type, expect_dst_shape);
if (ret != SUCCESS) {
return ret;
}
if (args.dst_shape != expect_dst_shape) {
GELOGE(PARAM_INVALID,
"Failed to trans format, the src and dst shape are not compatible. src shape %s, dst shape %s, "
"expect dst shape %s",
ShapeToString(args.src_shape).c_str(), ShapeToString(args.dst_shape).c_str(),
ShapeToString(expect_dst_shape).c_str());
return PARAM_INVALID;
}
return SUCCESS;
}
Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const int size, const int64_t total_size) {
std::shared_ptr<uint8_t> dst(new (std::nothrow) uint8_t[total_size], std::default_delete<uint8_t[]>());
if (dst == nullptr) {
GELOGE(OUT_OF_MEMORY, "Failed to trans format from %s to %s, can not alloc the memory for dst buf %ld, shape %s",
TypeUtils::FormatToSerialString(args.src_format).c_str(),
TypeUtils::FormatToSerialString(args.dst_format).c_str(), total_size, ShapeToString(args.dst_shape).c_str());
return OUT_OF_MEMORY;
}
auto n = args.src_shape.at(kNhwcN);
auto h = args.src_shape.at(kNhwcH);
auto w = args.src_shape.at(kNhwcW);
auto c = args.src_shape.at(kNhwcC);
auto c1 = args.dst_shape.at(kNc1hwc0C1);
auto c0 = args.dst_shape.at(kNc1hwc0C0);
int64_t wc = w * c;
int64_t hwc = h * wc;
int64_t wc0 = w * c0;
int64_t hwc0 = h * wc0;
int64_t c1hwc0 = c1 * hwc0;
for (int64_t n_idx = 0; n_idx < n; n_idx++) {
int64_t n_head_addr = n_idx * c1hwc0;
for (int64_t c1_idx = 0; c1_idx < c1; c1_idx++) {
int64_t c1_head_addr = n_head_addr + c1_idx * hwc0;
for (int64_t h_idx = 0; h_idx < h; h_idx++) {
int64_t h_head_addr = c1_head_addr + h_idx * wc0;
for (int64_t w_idx = 0; w_idx < w; w_idx++) {
int64_t w_head_addr = h_head_addr + w_idx * c0;
for (int64_t c0_idx = 0; c0_idx < c0; c0_idx++) {
int64_t dst_idx = c0_idx + w_head_addr;
int64_t dst_offset = dst_idx * size;
auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
? total_size - dst_offset
: static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
int64_t c_idx = c0_idx + c1_idx * c0;
int64_t src_idx = n_idx * hwc + h_idx * wc + w_idx * c + c_idx;
auto src_offset = src_idx * size;
if (c_idx < c) {
auto ret = memcpy_s(dst.get() + dst_offset, protected_size, args.data + src_offset, size);
if (ret != EOK) {
GELOGE(INTERNAL_ERROR,
"Failed to copy data from NHWC[%ld, %ld, %ld, %ld] offset %ld to "
"NC1HWC0[%ld, %ld, %ld, %ld, %ld] offset %ld err-code %d",
n_idx, h_idx, w_idx, c_idx, src_offset, n_idx, c1_idx, h_idx, w_idx, c0_idx, dst_offset, ret);
return INTERNAL_ERROR;
}
} else {
auto ret = memset_s(dst.get() + dst_offset, protected_size, 0, size);
if (ret != EOK) {
GELOGE(INTERNAL_ERROR,
"Failed to set 0 to NC1HWC0[%ld, %ld, %ld, %ld, %ld] offset %ld base err-code %d", n_idx, c1_idx,
h_idx, w_idx, c0_idx, dst_offset, ret);
return INTERNAL_ERROR;
}
}
}
}
}
}
}
result.data = dst;
result.length = static_cast<size_t>(total_size);
return SUCCESS;
}
} // namespace
Status FormatTransferNhwcNc1hwc0::TransFormat(const TransArgs &args, TransResult &result) {
if (CheckArgsForNhwcToNc1hwc0(args) != SUCCESS) {
return PARAM_INVALID;
}
int size = GetSizeByDataType(args.src_data_type);
auto total_size = GetItemNumByShape(args.dst_shape) * size;
if (total_size <= 0) {
GELOGE(INTERNAL_ERROR, "Get %ld total size from dst shape %s, src shape %s", total_size,
ShapeToString(args.dst_shape).c_str(), ShapeToString(args.src_shape).c_str());
return PARAM_INVALID;
}
GELOGD("Begin to trans format from NHWC to NC1HWC0, src shape %s, data type %s, dst shape %s, memory size %ld",
ShapeToString(args.src_shape).c_str(), TypeUtils::DataTypeToSerialString(args.src_data_type).c_str(),
ShapeToString(args.dst_shape).c_str(), total_size);
if (GetDstDataAfterTrans(args, result, size, total_size) != SUCCESS) {
GELOGE(INTERNAL_ERROR, "Failed to get data after trans, src shape %s, data type %s, dst shape %s, memory size %ld",
ShapeToString(args.src_shape).c_str(), TypeUtils::DataTypeToSerialString(args.src_data_type).c_str(),
ShapeToString(args.dst_shape).c_str(), total_size);
return INTERNAL_ERROR;
}
return SUCCESS;
}
Status FormatTransferNhwcNc1hwc0::TransShape(Format src_format, const std::vector<int64_t> &src_shape,
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
if (src_format == FORMAT_NHWC && CheckDataTypeSupported(data_type)) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str());
return PARAM_INVALID;
}
return TransShapeNhwcToNc1hwc0(src_shape, data_type, dst_shape);
} else {
return UNSUPPORTED;
}
}
REGISTER_FORMAT_TRANSFER(FormatTransferNhwcNc1hwc0, FORMAT_NHWC, FORMAT_NC1HWC0)
} // namespace formats
} // namespace ge
| 43.076531 | 120 | 0.66493 | TommyLike |
b466b5105c035508d6e58ea615e09692ecd25835 | 6,478 | cc | C++ | src/ui/scenic/lib/display/tests/display_power_manager_unittest.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | 5 | 2022-01-10T20:22:17.000Z | 2022-01-21T20:14:17.000Z | src/ui/scenic/lib/display/tests/display_power_manager_unittest.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | null | null | null | src/ui/scenic/lib/display/tests/display_power_manager_unittest.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | null | null | null | // Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/ui/scenic/lib/display/display_power_manager.h"
#include <fuchsia/ui/display/internal/cpp/fidl.h>
#include <lib/async/default.h>
#include <lib/async/time.h>
#include <thread>
#include <unordered_set>
#include <gtest/gtest.h>
#include "src/lib/testing/loop_fixture/real_loop_fixture.h"
#include "src/ui/scenic/lib/display/display_manager.h"
#include "src/ui/scenic/lib/display/tests/mock_display_controller.h"
namespace scenic_impl {
namespace gfx {
namespace test {
namespace {
struct ChannelPair {
zx::channel server;
zx::channel client;
};
ChannelPair CreateChannelPair() {
ChannelPair c;
FX_CHECK(ZX_OK == zx::channel::create(0, &c.server, &c.client));
return c;
}
} // namespace
class DisplayPowerManagerMockTest : public gtest::RealLoopFixture {
public:
DisplayPowerManagerMockTest() {
display_manager_ = std::make_unique<display::DisplayManager>([] {});
display_power_manager_ = std::make_unique<display::DisplayPowerManager>(display_manager_.get());
}
display::DisplayManager* display_manager() { return display_manager_.get(); }
display::DisplayPowerManager* display_power_manager() { return display_power_manager_.get(); }
display::Display* display() { return display_manager()->default_display(); }
private:
std::unique_ptr<display::DisplayManager> display_manager_;
std::unique_ptr<display::DisplayPowerManager> display_power_manager_;
};
TEST_F(DisplayPowerManagerMockTest, Ok) {
const uint64_t kDisplayId = 0;
const uint32_t kDisplayWidth = 1024;
const uint32_t kDisplayHeight = 768;
auto controller_channel = CreateChannelPair();
auto device_channel = CreateChannelPair();
display_manager()->BindDefaultDisplayController(
fidl::InterfaceHandle<fuchsia::hardware::display::Controller>(
std::move(controller_channel.client)),
std::move(device_channel.client));
display_manager()->SetDefaultDisplayForTests(
std::make_shared<display::Display>(kDisplayId, kDisplayWidth, kDisplayHeight));
display::test::MockDisplayController mock_display_controller;
mock_display_controller.Bind(std::move(device_channel.server),
std::move(controller_channel.server), dispatcher());
mock_display_controller.set_set_display_power_result(ZX_OK);
RunLoopUntilIdle();
{
bool callback_executed = false;
std::thread set_display_power_thread([&callback_executed, this] {
display_power_manager()->SetDisplayPower(
/* power_on */ false,
[&callback_executed](
fuchsia::ui::display::internal::DisplayPower_SetDisplayPower_Result result) {
callback_executed = true;
EXPECT_TRUE(result.is_response());
});
});
RunLoopUntil([&callback_executed] { return callback_executed; });
set_display_power_thread.join();
EXPECT_FALSE(mock_display_controller.display_power_on());
}
{
bool callback_executed = false;
std::thread set_display_power_thread([&callback_executed, this] {
display_power_manager()->SetDisplayPower(
/* power_on */ true,
[&callback_executed](
fuchsia::ui::display::internal::DisplayPower_SetDisplayPower_Result result) {
callback_executed = true;
EXPECT_TRUE(result.is_response());
});
});
RunLoopUntil([&callback_executed] { return callback_executed; });
set_display_power_thread.join();
EXPECT_TRUE(mock_display_controller.display_power_on());
}
}
TEST_F(DisplayPowerManagerMockTest, NoDisplay) {
auto controller_channel = CreateChannelPair();
auto device_channel = CreateChannelPair();
display_manager()->BindDefaultDisplayController(
fidl::InterfaceHandle<fuchsia::hardware::display::Controller>(
std::move(controller_channel.client)),
std::move(device_channel.client));
display_manager()->SetDefaultDisplayForTests(nullptr);
display::test::MockDisplayController mock_display_controller;
mock_display_controller.Bind(std::move(device_channel.server),
std::move(controller_channel.server), dispatcher());
RunLoopUntilIdle();
{
bool callback_executed = false;
std::thread set_display_power_thread([&callback_executed, this] {
display_power_manager()->SetDisplayPower(
/* power_on */ false,
[&callback_executed](
fuchsia::ui::display::internal::DisplayPower_SetDisplayPower_Result result) {
callback_executed = true;
ASSERT_TRUE(result.is_err());
EXPECT_EQ(result.err(), ZX_ERR_NOT_FOUND);
});
});
RunLoopUntil([&callback_executed] { return callback_executed; });
set_display_power_thread.join();
}
}
TEST_F(DisplayPowerManagerMockTest, NotSupported) {
const uint64_t kDisplayId = 0;
const uint32_t kDisplayWidth = 1024;
const uint32_t kDisplayHeight = 768;
auto controller_channel = CreateChannelPair();
auto device_channel = CreateChannelPair();
display_manager()->BindDefaultDisplayController(
fidl::InterfaceHandle<fuchsia::hardware::display::Controller>(
std::move(controller_channel.client)),
std::move(device_channel.client));
display_manager()->SetDefaultDisplayForTests(
std::make_shared<display::Display>(kDisplayId, kDisplayWidth, kDisplayHeight));
display::test::MockDisplayController mock_display_controller;
mock_display_controller.Bind(std::move(device_channel.server),
std::move(controller_channel.server), dispatcher());
mock_display_controller.set_set_display_power_result(ZX_ERR_NOT_SUPPORTED);
RunLoopUntilIdle();
{
bool callback_executed = false;
std::thread set_display_power_thread([&callback_executed, this] {
display_power_manager()->SetDisplayPower(
/* power_on */ false,
[&callback_executed](
fuchsia::ui::display::internal::DisplayPower_SetDisplayPower_Result result) {
callback_executed = true;
EXPECT_TRUE(result.is_err());
EXPECT_EQ(result.err(), ZX_ERR_NOT_SUPPORTED);
});
});
RunLoopUntil([&callback_executed] { return callback_executed; });
set_display_power_thread.join();
}
}
} // namespace test
} // namespace gfx
} // namespace scenic_impl
| 33.739583 | 100 | 0.711948 | fabio-d |
b467e76d4bd78d5da611e2384129a0f221abf788 | 12,109 | cpp | C++ | import/abstractdelegate.cpp | PureTryOut/mycroft-gui | eb72bcfe1a748cd3e6de3c0ea72a317db695c129 | [
"Apache-2.0"
] | null | null | null | import/abstractdelegate.cpp | PureTryOut/mycroft-gui | eb72bcfe1a748cd3e6de3c0ea72a317db695c129 | [
"Apache-2.0"
] | null | null | null | import/abstractdelegate.cpp | PureTryOut/mycroft-gui | eb72bcfe1a748cd3e6de3c0ea72a317db695c129 | [
"Apache-2.0"
] | 1 | 2020-05-20T21:28:04.000Z | 2020-05-20T21:28:04.000Z | /*
* Copyright 2018 by Marco Martin <mart@kde.org>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "abstractdelegate.h"
#include "mycroftcontroller.h"
#include <QQmlEngine>
#include <QQmlContext>
DelegateLoader::DelegateLoader(AbstractSkillView *parent)
: QObject(parent),
m_view(parent)
{}
DelegateLoader::~DelegateLoader()
{
if (m_delegate) {
m_delegate->deleteLater();
}
}
void DelegateLoader::init(const QString skillId, const QUrl &delegateUrl)
{
if (!m_skillId.isEmpty()) {
qWarning() << "Init already called";
}
m_skillId = skillId;
m_delegateUrl = delegateUrl;
QQmlEngine *engine = qmlEngine(m_view);
//This class should be *ALWAYS* created from QML
Q_ASSERT(engine);
m_component = new QQmlComponent(engine, delegateUrl, m_view);
switch(m_component->status()) {
case QQmlComponent::Error:
qWarning() << "ERROR Loading QML file" << delegateUrl;
for (auto err : m_component->errors()) {
qWarning() << err.toString();
}
break;
case QQmlComponent::Ready:
createObject();
break;
case QQmlComponent::Loading:
connect(m_component, &QQmlComponent::statusChanged, this, &DelegateLoader::createObject);
break;
default:
break;
}
}
void DelegateLoader::createObject()
{
QQmlContext *context = QQmlEngine::contextForObject(m_view);
//This class should be *ALWAYS* created from QML
Q_ASSERT(context);
QObject *guiObject = m_component->beginCreate(context);
m_delegate = qobject_cast<AbstractDelegate *>(guiObject);
if (m_component->isError()) {
qWarning() << "ERROR Loading QML file" << m_delegateUrl;
for (auto err : m_component->errors()) {
qWarning() << err.toString();
}
return;
}
if (!m_delegate) {
qWarning()<<"ERROR: QML gui" << guiObject << "not a Mycroft.AbstractDelegate instance";
guiObject->deleteLater();
return;
}
connect(m_delegate, &QObject::destroyed, this, &QObject::deleteLater);
m_delegate->setSkillId(m_skillId);
m_delegate->setQmlUrl(m_delegateUrl);
m_delegate->setSkillView(m_view);
m_delegate->setSessionData(m_view->sessionDataForSkill(m_skillId));
m_component->completeCreate();
emit delegateCreated();
if (m_focus) {
m_delegate->forceActiveFocus((Qt::FocusReason)AbstractSkillView::ServerEventFocusReason);
}
};
AbstractDelegate *DelegateLoader::delegate()
{
return m_delegate;
}
void DelegateLoader::setFocus(bool focus)
{
m_focus = focus;
if (m_delegate && focus) {
m_delegate->forceActiveFocus((Qt::FocusReason)AbstractSkillView::ServerEventFocusReason);
} else if (m_delegate) {
m_delegate->setFocus(false);
}
}
//////////////////////////////////////////
AbstractDelegate::AbstractDelegate(QQuickItem *parent)
: QQuickItem(parent)
{
setFiltersChildMouseEvents(true);
setFlags(QQuickItem::ItemIsFocusScope);
setAcceptedMouseButtons(Qt::LeftButton);
}
AbstractDelegate::~AbstractDelegate()
{
}
void AbstractDelegate::triggerGuiEvent(const QString &eventName, const QVariantMap ¶meters)
{
if (!m_skillView) {
qWarning() << "No SkillView, this should never happen: orphan delegate?";
return;
}
if (eventName.startsWith(QStringLiteral("system."))) {
m_skillView->triggerEvent(QStringLiteral("system"), eventName, parameters);
} else {
m_skillView->triggerEvent(m_skillId, eventName, parameters);
}
}
void AbstractDelegate::syncChildItemsGeometry(const QSizeF &size)
{
if (m_contentItem) {
m_contentItem->setX(m_leftPadding);
m_contentItem->setY(m_topPadding);
if (m_contentItemAutoWidth && m_contentItemAutoHeight) {
m_contentItem->setSize(QSizeF(size.width() - m_leftPadding - m_rightPadding,
size.height() - m_topPadding - m_bottomPadding));
} else if (m_contentItemAutoWidth) {
m_contentItem->setWidth(size.width() - m_leftPadding - m_rightPadding);
} else if (m_contentItemAutoHeight) {
m_contentItem->setHeight(size.height() - m_topPadding - m_bottomPadding);
}
}
if (m_backgroundItem) {
m_backgroundItem->setX(0);
m_backgroundItem->setY(0);
m_backgroundItem->setSize(size);
}
}
void AbstractDelegate::contentData_append(QQmlListProperty<QObject> *prop, QObject *object)
{
AbstractDelegate *delegate = static_cast<AbstractDelegate *>(prop->object);
if (!delegate) {
return;
}
// QQuickItem *item = qobject_cast<QQuickItem *>(object);
delegate->m_contentData.append(object);
}
int AbstractDelegate::contentData_count(QQmlListProperty<QObject> *prop)
{
AbstractDelegate *delegate = static_cast<AbstractDelegate *>(prop->object);
if (!delegate) {
return 0;
}
return delegate->m_contentData.count();
}
QObject *AbstractDelegate::contentData_at(QQmlListProperty<QObject> *prop, int index)
{
AbstractDelegate *delegate = static_cast<AbstractDelegate *>(prop->object);
if (!delegate) {
return nullptr;
}
if (index < 0 || index >= delegate->m_contentData.count()) {
return nullptr;
}
return delegate->m_contentData.value(index);
}
void AbstractDelegate::contentData_clear(QQmlListProperty<QObject> *prop)
{
AbstractDelegate *delegate = static_cast<AbstractDelegate *>(prop->object);
if (!delegate) {
return;
}
return delegate->m_contentData.clear();
}
QQmlListProperty<QObject> AbstractDelegate::contentData()
{
return QQmlListProperty<QObject>(this, nullptr,
contentData_append,
contentData_count,
contentData_at,
contentData_clear);
}
void AbstractDelegate::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
syncChildItemsGeometry(newGeometry.size());
QQuickItem::geometryChanged(newGeometry, oldGeometry);
emit contentWidthChanged();
emit contentHeightChanged();
}
void AbstractDelegate::componentComplete()
{
if (!m_contentItem) {
//qWarning()<<"Creting default contentItem";
m_contentItem = new QQuickItem(this);
}
QQuickItem *item;
for (auto *o : m_contentData) {
item = qobject_cast<QQuickItem *>(o);
if (item) {
item->setParentItem(m_contentItem);
} else {
o->setParent(this);
}
}
QQuickItem::componentComplete();
}
bool AbstractDelegate::childMouseEventFilter(QQuickItem *item, QEvent *event)
{
if (event->type() == QEvent::MouseButtonPress) {
forceActiveFocus(Qt::MouseFocusReason);
triggerGuiEvent(QStringLiteral("system.gui.user.interaction"), QVariantMap());
}
return QQuickItem::childMouseEventFilter(item, event);
}
void AbstractDelegate::mousePressEvent(QMouseEvent *event)
{
forceActiveFocus(Qt::MouseFocusReason);
triggerGuiEvent(QStringLiteral("system.gui.user.interaction"), QVariantMap());
}
void AbstractDelegate::focusInEvent(QFocusEvent *event)
{
//if the focus came from the server, don't ask the server again
if (event->reason() == (Qt::FocusReason)AbstractSkillView::ServerEventFocusReason) {
return;
}
if (!parentItem()) {
return;
}
QQmlContext *context = QQmlEngine::contextForObject(parentItem());
if (!context) {
return;
}
int index = context->contextProperty(QStringLiteral("index")).toInt();
if (index >= 0) {
triggerGuiEvent(QStringLiteral("page_gained_focus"), QVariantMap({{QStringLiteral("number"), index}}));
}
}
QQuickItem *AbstractDelegate::contentItem() const
{
return m_contentItem;
}
void AbstractDelegate::setContentItem(QQuickItem *item)
{
if (m_contentItem == item) {
return;
}
m_contentItem = item;
item->setParentItem(this);
m_contentItem->setX(m_leftPadding);
m_contentItem->setY(m_topPadding);
if (m_contentItemAutoWidth && m_contentItemAutoHeight) {
m_contentItem->setSize(QSizeF(width() - m_leftPadding - m_rightPadding,
height() - m_topPadding - m_bottomPadding));
} else if (m_contentItemAutoWidth) {
m_contentItem->setWidth(width() - m_leftPadding - m_rightPadding);
} else if (m_contentItemAutoHeight) {
m_contentItem->setHeight(height() - m_topPadding - m_bottomPadding);
}
emit contentItemChanged();
}
QQuickItem *AbstractDelegate::background() const
{
return m_backgroundItem;
}
void AbstractDelegate::setBackground(QQuickItem *item)
{
if (m_backgroundItem == item) {
return;
}
m_backgroundItem = item;
m_backgroundItem->setParentItem(this);
m_backgroundItem->setX(0);
m_backgroundItem->setY(0);
m_backgroundItem->setSize(size());
emit backgroundChanged();
}
int AbstractDelegate::leftPadding() const
{
return m_leftPadding;
}
void AbstractDelegate::setLeftPadding(int padding)
{
if (m_leftPadding == padding) {
return;
}
m_leftPadding = padding;
syncChildItemsGeometry(size());
emit leftPaddingChanged();
emit contentWidthChanged();
}
int AbstractDelegate::topPadding() const
{
return m_topPadding;
}
void AbstractDelegate::setTopPadding(int padding)
{
if (m_topPadding == padding) {
return;
}
m_topPadding = padding;
syncChildItemsGeometry(size());
emit topPaddingChanged();
emit contentHeightChanged();
}
int AbstractDelegate::rightPadding() const
{
return m_rightPadding;
}
void AbstractDelegate::setRightPadding(int padding)
{
if (m_rightPadding == padding) {
return;
}
m_rightPadding = padding;
syncChildItemsGeometry(size());
emit rightPaddingChanged();
emit contentWidthChanged();
}
int AbstractDelegate::bottomPadding() const
{
return m_bottomPadding;
}
void AbstractDelegate::setBottomPadding(int padding)
{
if (m_bottomPadding == padding) {
return;
}
m_bottomPadding = padding;
syncChildItemsGeometry(size());
emit bottomPaddingChanged();
emit contentHeightChanged();
}
int AbstractDelegate::contentWidth() const
{
return width() - m_leftPadding - m_rightPadding;
}
int AbstractDelegate::contentHeight() const
{
return height() - m_topPadding - m_bottomPadding;
}
void AbstractDelegate::setSkillView(AbstractSkillView *view)
{
//possible to call only once, by the skillview, setting itself upon instantiation
Q_ASSERT(!m_skillView);
m_skillView = view;
}
AbstractSkillView *AbstractDelegate::skillView() const
{
return m_skillView;
}
void AbstractDelegate::setSessionData(SessionDataMap *data)
{
//possible to call only once, by the skillview upon instantiation
Q_ASSERT(!m_data);
m_data = data;
}
SessionDataMap *AbstractDelegate::sessionData() const
{
return m_data;
}
void AbstractDelegate::setQmlUrl(const QUrl &url)
{
//possible to call only once, by the skillview upon instantiation
Q_ASSERT(m_qmlUrl.isEmpty());
m_qmlUrl = url;
}
QUrl AbstractDelegate::qmlUrl() const
{
return m_qmlUrl;
}
void AbstractDelegate::setSkillId(const QString &skillId)
{
//possible to call only once, by the skillview upon instantiation
Q_ASSERT(m_skillId.isEmpty());
m_skillId = skillId;
}
QString AbstractDelegate::skillId() const
{
return m_skillId;
}
#include "moc_abstractdelegate.cpp"
| 25.70913 | 111 | 0.676356 | PureTryOut |
b4685bae8a114ad6720f7274071ade2c4f529a85 | 1,652 | cpp | C++ | ACM/Assignment6/C.cpp | AixMoon/LearnigRepo | ee98fb352735e2b4f97304847b6c0311bc30195e | [
"MIT"
] | 11 | 2020-05-02T20:06:07.000Z | 2021-06-24T10:01:29.000Z | ACM/Assignment6/C.cpp | AixMoon/LearnigRepo | ee98fb352735e2b4f97304847b6c0311bc30195e | [
"MIT"
] | null | null | null | ACM/Assignment6/C.cpp | AixMoon/LearnigRepo | ee98fb352735e2b4f97304847b6c0311bc30195e | [
"MIT"
] | 6 | 2020-06-04T04:29:28.000Z | 2020-11-15T08:15:01.000Z | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#define MAX_L 1005
#define INF 0xffffff
#define LL long long
using namespace std;
int G[MAX_L][MAX_L];
int dis[MAX_L][MAX_L];
LL t, s, d, n = 0;
int start[MAX_L];
int dest[MAX_L];
void init() {
// 未清 0
// start.clear();
// dest.clear();
fill(G[0], G[0] + MAX_L * MAX_L, INF);
fill(dis[0], dis[0] + MAX_L * MAX_L, INF);
for (int i = 0; i < MAX_L; i++) {
G[i][i] = 0;
dis[i][i] = 0;
}
}
void floyd() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
if (G[k][i] == INF) {
continue;
}
for (int j = 0; j < n; j++) {
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
}
}
}
}
int main() {
while (~scanf("%lld %lld %lld", &t, &s, &d)) {
init();
for (int i = 0; i < t; i++) {
LL a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (c < G[a][b]) {
G[a][b] = G[b][a] = dis[a][b] = dis[b][a] = c;
}
n = max(n, max(a, b));
}
LL temp;
for (int i = 0; i < s;i++){
cin >> temp;
start[i] = temp - 1;
}
for (int i = 0; i < d; i++) {
cin >> temp;
dest[i] = temp - 1;
}
// while (s--) {
// cin >> temp;
// start.push_back(temp - 1);
// }
// while (d--) {
// cin >> temp;
// dest.push_back(temp - 1);
// }
floyd();
int mint = INF;
for (int i = 0; i < s;i++){
for (int j = 0; j < d;j++){
mint = min(mint, dis[start[i]][dest[j]]);
}
}
// for (auto i : start) {
// for (auto j : dest) {
// mint = min(mint, dis[i][j]);
// }
// }
cout << mint << endl;
}
return 0;
} | 18.355556 | 54 | 0.455811 | AixMoon |
b4687d91823aa5b12ebedf17d2b4e1ba1f8e3719 | 363 | cpp | C++ | March Lunchtime 2021 Division 3/Dinner by Candlelight.cpp | Yashdew/DSA | d211d3b53acd28879233e55b77745b60ff44410f | [
"MIT"
] | 4 | 2021-04-13T11:04:45.000Z | 2021-12-06T16:32:28.000Z | March Lunchtime 2021 Division 3/Dinner by Candlelight.cpp | Yashdew/DSA | d211d3b53acd28879233e55b77745b60ff44410f | [
"MIT"
] | null | null | null | March Lunchtime 2021 Division 3/Dinner by Candlelight.cpp | Yashdew/DSA | d211d3b53acd28879233e55b77745b60ff44410f | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
int main()
{
int testCases;
cin >> testCases;
while (testCases--)
{
long long int A,Y,X;
cin>>A>>Y>>X;
if( Y>A )
{
cout<<X*A +1<<endl;
}
else if(Y<=A)
{
cout<<X*Y <<endl;
}
}
return 0;
}
| 13.444444 | 31 | 0.380165 | Yashdew |
b46a12b3489a9f0045f59d392b977b4437fc612b | 1,636 | hpp | C++ | src/parser_nodes/and_parser_node.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | src/parser_nodes/and_parser_node.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | src/parser_nodes/and_parser_node.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | //
// Copyright (c) 2020 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: MIT
//
#ifndef NEDERROCK_SRC_AND_PARSER_NODE_HPP
#define NEDERROCK_SRC_AND_PARSER_NODE_HPP
#include "and_parser_node_pre.hpp"
#include "separator_parser_node_pre.hpp"
#include "equality_check_parser_node_pre.hpp"
#include "token_stream.hpp"
#include "scope_state.hpp"
#include <memory>
#include <istream>
#include <string>
#include <variant>
class And_Parser_Node {
public:
struct Choice_1 {
void dump(std::wostream& output) const;
void generate_cpp(Scope_State_Ptr state) const;
void collect_variables(Scope_State_Ptr state) const;
Equality_Check_Parser_Node_Ptr m_equality;
Separator_Parser_Node_Ptr m_separator_1;
std::wstring m_keyword;
Separator_Parser_Node_Ptr m_separator_2;
And_Parser_Node_Ptr m_and;
};
struct Choice_2 {
void dump(std::wostream& output) const;
void generate_cpp(Scope_State_Ptr state) const;
void collect_variables(Scope_State_Ptr state) const;
Equality_Check_Parser_Node_Ptr m_equality;
};
public:
And_Parser_Node(Choice_1&& choice);
And_Parser_Node(Choice_2&& choice);
static And_Parser_Node_Ptr parse_choice_1(Token_Stream& input);
static And_Parser_Node_Ptr parse_choice_2(Token_Stream& input);
static And_Parser_Node_Ptr parse(Token_Stream& input);
void dump(std::wostream& output) const;
void generate_cpp(Scope_State_Ptr state) const;
void collect_variables(Scope_State_Ptr state) const;
private:
std::variant<Choice_1, Choice_2> m_choice;
};
#endif // NEDERROCK_SRC_AND_PARSER_NODE_HPP
| 28.206897 | 65 | 0.762225 | lowlander |
b46b55e634ed4e6190b191941e67e4dc7bb06c37 | 5,496 | cpp | C++ | NewEditBox.cpp | yohshee/magenta | 6efec67106b2769dd7c6dde5f63343fc0ecd5f3a | [
"MIT"
] | null | null | null | NewEditBox.cpp | yohshee/magenta | 6efec67106b2769dd7c6dde5f63343fc0ecd5f3a | [
"MIT"
] | null | null | null | NewEditBox.cpp | yohshee/magenta | 6efec67106b2769dd7c6dde5f63343fc0ecd5f3a | [
"MIT"
] | null | null | null | // NewEditBox.cpp : implementation file
//
#include "stdafx.h"
#include "Magenta.h"
#include "Constants.h"
#include "Person.h"
#include "NewEditBox.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CNewEditBox
CNewEditBox::CNewEditBox()
{
// Basic initialization...
m_iSelStart = 0;
m_iSelLength = 0;
}
CNewEditBox::~CNewEditBox()
{
}
BEGIN_MESSAGE_MAP(CNewEditBox, CEdit)
//{{AFX_MSG_MAP(CNewEditBox)
ON_WM_KEYUP()
ON_WM_KEYDOWN()
ON_WM_CHAR()
ON_MESSAGE(WM_UNINITMENUPOPUP, OnUninitPopup)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
// Processes an autocomplete request.
void CNewEditBox::ProcessAutoComplete()
{
int i;
INT_PTR iCount = 0;
int iMatches = 0;
int iStart, iEnd, iMiddle;
CString szText;
CString szName, szItem, szTemp;
CPoint ptCursor;
GetSel(iStart, iMiddle); // Get the position of the cursor (considered to be iMiddle)
GetWindowText(szText); // Also grab ahold of the text in the window.
// Prepare the menu
if(m_mnuAuto.GetSafeHmenu() != NULL)
m_mnuAuto.DestroyMenu();
if(!m_mnuAuto.CreatePopupMenu()) {
AfxMessageBox(_T("Unable to generate menu for Tab Complete!"), MB_ICONSTOP | MB_OK);
return;
}
// Look for the start of the string.
if(iMiddle > 0)
iStart = FindRev(szText, " ", iMiddle - 1);
else
iStart = FindRev(szText, " ", 0);
if(iStart == -1)
iStart = 0;
iEnd = szText.Find(_T(" "), iMiddle + 1);
if(iEnd == -1)
iEnd = szText.GetLength();
SetSel(iStart, iEnd); // Cosmetic reasons.
szName = szText.Mid(iStart, iEnd - iStart); // Because MFC won't give us the selected text..><
if(szName.GetLength() > 0) {
//iCount = m_plstRegulars->GetCount();
iCount = m_pcolUsers->GetSize();
iMatches = 0;
m_pcsUsers->Lock();
//szName.MakeUpper();
for(i = 0; i < iCount; i++) {
szItem = ((CPerson*)m_pcolUsers->GetAt(i))->szName;
//m_plstRegulars->GetText(i, szItem);
szTemp = szItem;
//szTemp.MakeUpper();
if(szTemp.Left(szName.GetLength()).CompareNoCase(szName) == 0) {
// We matched. Add one, and add it to the list.
iMatches++;
if(iMatches <= MATCH_LIMIT) {
//m_plstOutput->AddString(szItem);
m_mnuAuto.AppendMenu(MF_STRING, ID_AUTO_BASE + iMatches, szItem);
}
}
}
m_pcsUsers->Unlock();
if(iMatches > 1) {
// Lock the text in the message textbox and let them choose a completion.
SetReadOnly(TRUE);
// Cache selection info
m_iSelStart = iStart;
m_iSelLength = iEnd - iStart;
// Get the insertion point position and popup the menu right where it is.
ptCursor = GetCaretPos();
ClientToScreen(&ptCursor);
m_mnuAuto.TrackPopupMenu(TPM_CENTERALIGN | TPM_LEFTBUTTON,
ptCursor.x, ptCursor.y, this);
}
else if(iMatches == 1) {
// Merely paste in the last item.
m_mnuAuto.GetMenuString(0, szItem, MF_BYPOSITION);
m_mnuAuto.DestroyMenu();
ReplaceSel(szItem);
}
// Fix the selection start.
GetWindowText(szText);
SetSel(szText.GetLength(), szText.GetLength());
}
}
// Searches for a substring starting at the end of a string.
int CNewEditBox::FindRev(CString szString, CString szFind, int iStart)
{
int iRet = -1;
int iPos, iLen;
// Reverse the strings...
szString.MakeReverse();
szFind.MakeReverse();
iLen = szString.GetLength();
iPos = szString.Find(szFind, iLen - iStart - 1);
if(iPos != -1)
iRet = szString.GetLength() - iPos - szFind.GetLength() + 1;
return iRet;
}
/////////////////////////////////////////////////////////////////////////////
// CNewEditBox message handlers
void CNewEditBox::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch(nChar) {
case VK_ESCAPE:
if(!m_bHadMenu) {
// We want to clear it.
SetWindowText(_T(""));
}
else {
m_bHadMenu = FALSE; // This flag only makes sense for this case, so far.
}
break;
case VK_TAB:
ProcessAutoComplete();
break;
default:
// Nothing to do...
break;
}
// Call default
CEdit::OnKeyUp(nChar, nRepCnt, nFlags);
}
void CNewEditBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// Doggone tabs! Don't process unless I say so!
if(nChar != VK_TAB)
CEdit::OnKeyDown(nChar, nRepCnt, nFlags);
}
void CNewEditBox::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// Another attempt to keep tabs from processing...
if(nChar != VK_TAB)
CEdit::OnChar(nChar, nRepCnt, nFlags);
}
BOOL CNewEditBox::OnCommand(WPARAM wParam, LPARAM lParam)
{
int iID;
CString szItem;
CString szMessage;
iID = LOWORD(wParam); // Get the command ID. (which should be from the menu)
if(iID & ID_AUTO_BASE) {
// It's one of our popups, all right...
m_mnuAuto.GetMenuString(iID, szItem, MF_BYCOMMAND);
ASSERT(szItem.GetLength() > 0);
SetSel(m_iSelStart, m_iSelLength + m_iSelStart);
ReplaceSel(szItem);
SetReadOnly(FALSE);
m_mnuAuto.DestroyMenu();
}
return CEdit::OnCommand(wParam, lParam);
}
LRESULT CNewEditBox::OnUninitPopup(WPARAM wParam, LPARAM lParam)
{
// Hm, let's see....we can try to do this this way. o.o
// Unfortunately, now my program doesn't work on Win95, but
// who uses Win95 anymore, anyway?
if((HMENU)wParam == m_mnuAuto.GetSafeHmenu()) {
SetReadOnly(FALSE);
m_bHadMenu = TRUE;
}
return 0;
}
| 25.327189 | 96 | 0.637737 | yohshee |
b46f40112fb85b203e5177c158eb66bad8276fca | 23,551 | hh | C++ | inc/lacze_do_gnuplota.hh | KPO-2020-2021/zad5_3-jmeko1214 | 6c59e182b409c39e02c5a0e37d3e983ed1b3e0ba | [
"Unlicense"
] | null | null | null | inc/lacze_do_gnuplota.hh | KPO-2020-2021/zad5_3-jmeko1214 | 6c59e182b409c39e02c5a0e37d3e983ed1b3e0ba | [
"Unlicense"
] | null | null | null | inc/lacze_do_gnuplota.hh | KPO-2020-2021/zad5_3-jmeko1214 | 6c59e182b409c39e02c5a0e37d3e983ed1b3e0ba | [
"Unlicense"
] | null | null | null | #pragma once
#include <string>
#include <list>
#include <vector>
/*!
* \file lacze_do_gnuplota.hh
*
* Plik zawiera definicję klasy realizującej interfejs
* komunikacyjny do programu gnuplot.
*/
/*!
* \brief Moduł narzędzi umożliwiających połącznie z GNUPlotem
*
* Niniejsza przestrzeń nazw stanowi moduł logiczny zawierający
* narzędzia umożliwiające realizację połączenia z programem \p gnuplot.
*/
namespace PzG {
/*!
* \brief Określa tryb rysowania realizowanego przez program \p gnuplot
*
* Typ wyliczeniowy określające dopuszczalne tryby rysowania
* realizowanego przez program \p gnuplot. Wybór trybu wiąże się
* ze zmianą sposobu interpretacji danych zawartych pliku. Jeśli
* np. wybrany zostanie tryb 2D, to zakłada się, że w każdej linii
* pliku z danymi znajdują się wartości współrzędnych \e x, \e y.
* Wartości typu:
* \li \p TR_2D - rysowanie w trybie 2D, co sprowadza się do
* rysowania wykresów funkcji jednej zmiennej.
* \li \p TR_3D - rysowanie w trybie 3D. Oznacza to możliwość
* rysowania wykresów funkcji dwóch zmiennych.
*
*/
enum TrybRysowania { TR_2D, TR_3D };
/*!
* \brief Sposób rysowania linii
*
* Określa sposób rysowania linii.
*/
enum RodzajRysowania { RR_Ciagly, RR_Punktowy };
/*!
* \brief Zestaw informacji dotyczący pliku i sposobu rysowania
*
* Klasa modeluje zestaw informacji dotyczący pliku i sposobu
* w jaki mają być wizualizowane zawarte w nim dane.
*/
class InfoPlikuDoRysowania {
public:
/*!
* Inicjalizuje obiekt.
* \param NazwaPliku - nazwa pliku, z którego pobierane będą dane,
* \param RodzRys - rodzaj rysowania linii,
* \param Szerokosc - szerokosc linii.
*/
InfoPlikuDoRysowania(const char* NazwaPliku, RodzajRysowania RodzRys, int Szerokosc)
{
_NazwaPliku = NazwaPliku;
_RodzRys = RodzRys;
_Szerokosc = Szerokosc;
}
/*!
* \brief Udostępia nazwę pliku do rysowania
*
* Udostępnia nazwę pliku z danymi do rysowania.
*/
const std::string WezNazwePliku() const { return _NazwaPliku; }
/*!
* \brief Zmienia nazwę pliku do rysowania
*
* Zmienia nazwę pliku z danymi do rysowania.
*/
void ZmienNazwePliku(const std::string& NazwaPliku) { _NazwaPliku = NazwaPliku; }
/*!
* \brief Udostępnia sposób rysowanej linii
*
* Udostępnia informację o sposóbie rysowania linii.
*/
RodzajRysowania WezRodzRys() const { return _RodzRys; }
/*!
* \brief Udostępnia informację o szerokości linii.
*
* Udostępnia informację o szerokości rysowanej linii.
*/
int WezSzerokosc() const { return _Szerokosc; }
private:
/*!
* \brief Nazwa pliku z danymi do rysowania
*
* Nazwa pliku z danymi do rysowania.
*/
std::string _NazwaPliku;
/*!
* \brief Szerokość użytego piórka
*
* Określa szerokość piórka, jakie ma być użyte
* do rysowania obiektów graficznych.
*/
int _Szerokosc;
/*!
* \brief Sposób rysowania danej linii
*
* Przechowuje informacje o sposobie rysowania linii.
*/
RodzajRysowania _RodzRys;
};
/*!
* \brief Klasa realizuje interfejs do programu GNUPlot.
*
* Klasa realizuje interfejs do programu GNUPlot. Pozwala ona na wskazanie
* zbioru punktów płaszczyzn umieszczonych w pliku lub plikach.
* Każdy taki zbiór może być następnie wizualizowany przez program
* gnuplot w postaci oddzielnych płaszczyzn z wycinaniem części zasłanianych.
*/
class LaczeDoGNUPlota {
protected:
/*!
* \brief Lista nazw plików z danymi dla \e gnuplota.
*
* Pole jest zarządcą listy nazw plików, z których są wczytywane
* dane dotyczące rysowania obrysu brył przez program \e gnuplot.
* Operacja ta wykonywana jest po wywołaniu polecenia.
* \link LaczeDoGNUPlota::Rysuj Rysuj\endlink.
*/
static std::list<InfoPlikuDoRysowania> _InfoPlikow;
/*!
* Pole przechowuje deskryptor do wejścia standardowego uruchomionego
* programu gnuplot.
*/
int _Wejscie_GNUPlota;
/*!
* Pole przechowuje deskryptor do weyjścia standardowego uruchomionego
* programu gnuplot.
*/
int _Wyjscie_GNUPlota;
/*!
* \brief Decyduje czy mają być wyświetlane komunikaty o błędach,
* czy też nie.
*
* Wartość tego pola decyduje o tym czy komunikaty o błędach będą
* wyświetlane na wyjście standardowe błędów (\b cerr), czy też nie.
* \li \p true - komunikaty będę wyświetlane,
* \li \p false - komunikaty nie będę wyświetlane.
*/
bool _WyswietlajKomunikatyOBledach;
/*!
* \brief Określa aktualny tryb rysowania
*
* Zawartość pola determinuje sposób rysowania, jaki zostanie
* wymuszony na programie \p gnuplot poprzez wysłanie do niego
* odpowiednich poleceń. Wspomniane wymuszenie jest realizowane
* poprzez wywołanie polecenia
* \link LaczeDoGNUPlota::Rysuj Rysuj()\endlink
*/
TrybRysowania _TrybRys;
/*!
* \brief Dolny zakres wyświetlanej skali skali dla osi \e OX.
*
* Określa dolny zakres wyświetlanej skali dla osi \e OX.
*/
float _Xmin;
/*!
* \brief Górny zakres wyświetlanej skali skali dla osi \e OX.
*
* Określa górny zakres wyświetlanej skali dla osi \e OX.
*/
float _Xmax;
/*!
* \brief Dolny zakres wyświetlanej skali skali dla osi \e OY.
*
* Określa dolny zakres wyświetlanej skali dla osi \e OY.
*/
float _Ymin;
/*!
* \brief Górny zakres wyświetlanej skali skali dla osi \e OY.
*
* Określa górny zakres wyświetlanej skali dla osi \e OY.
*/
float _Ymax;
/*!
* \brief Dolny zakres wyświetlanej skali skali dla osi \e OZ.
*
* Określa dolny zakres wyświetlanej skali dla osi \e OZ.
*/
float _Zmin;
/*!
* \brief Górny zakres wyświetlanej skali skali dla osi \e OZ.
*
* Określa górny zakres wyświetlanej skali dla osi \e OZ.
*/
float _Zmax;
/*!
* Wartość tego pola definiuje skalowanie rysunku wzdłuż osi
* \e OX (oś horyzontalna ekranu).
*/
float _Xskala;
/*!
* Wartość tego pola definiuje skalowanie rysunku wzdłuż osi
* \e OZ (oś wertykalna ekranu).
*/
float _Zskala;
/*!
* Wartość tego pola definiuje rotację rysunku (zmiane punktu patrzenia)
* względem osi \e OX.
*/
float _Xrotacja;
/*!
* Wartość tego pola definiuje rotację rysunku (zmiane punktu patrzenia)
* względem osi \e OZ.
*/
float _Zrotacja;
/*!
* \brief Czy oś OX ma być widoczna
*
* Przechowuje informację decydującą o tym czy oś OX będzie
* widoczna na rysunku (\p true), czy też nie (\p false).
*/
bool _PokazOs_OX;
/*!
* \brief Czy oś OY ma być widoczna
*
* Przechowuje informację decydującą o tym czy oś OY będzie
* widoczna na rysunku (\p true), czy też nie (\p false).
*/
bool _PokazOs_OY;
/*!
* \brief Czy oś OZ ma być widoczna
*
* Przechowuje informację decydującą o tym czy oś OZ będzie
* widoczna na rysunku (\p true), czy też nie (\p false).
*/
bool _PokazOs_OZ;
/*!
* \brief Tworzy listę parametrów umożliwiających rysowanie dodatkowych elementów
*
* Metoda ta przewidziana jest jako element rozszerzenia pozwalającego
* w klasach pochodnych powiększyć listę rysowanych elementów.
* \pre Parametr \e Polecenie powinien zawierać polecenie \e plot lub \e splot,
* do którego będzie możliwe dopisanie dalszego ciągu.
* \param Polecenie - polecenie rysowania, do którego mają być dopisane
* nazwy plików i odpowiednie parametry dla polecenia plot.
* \param Sep - zawiera znak separatora między poszczególnymi
* parametrami. Jeżeli parametry listy przeszkód
* są generowane jako pierwsze, to zmienna ta musi
* być wskaźnikiem do wskaźnika na łańcuch: " ".
*/
virtual bool DopiszPlikiDoPoleceniaRysowania( std::string &Polecenie, char const **Sep );
/*!
* \brief Tworzy polecenie ustawiające zakres dla danej współrzędnej.
*
* Tworzy polecenie dla programu \e gnuplot ustawiające zakres
* współrzędnych wybranej współrzędnej \e x, \e y lub \e z,
* dla której ma być tworzony dany rysunek.
* \param Os - zawiera znak określający współrzędną, dla której
* ma zostać wygenerowane polecenie ustawienia zakresu.
* \return łańcuch znaków polecenia ustawiającego żądany zakres
* dla wybranej współrzędnej.
*/
std::string ZapiszUstawienieZakresu(char Os) const;
/*!
* \brief Tworzy polecenie ustawiające punkt obserwacji.
*
* Tworzy polecenie dla programu \e gnuplot ustawiajające punkt obserwacji
* poprzez zadanie rotacji i skali dla poszczególnych osi.
*/
std::string ZapiszUstawienieRotacjiISkali() const;
/*!
* Przesyła na wejście programu \e gnuplot zadany ciąg znaków.
* \param Polecenie - komunikat przeznaczony do przeslania.
*
* \pre Musi być zainicjowane połączenie z programem gnuplot.
*
* \retval true - jesli przeslanie polecenia zakończyło się powodzeniem,
* \retval false - w przypadku przeciwnym.
*
*/
bool PrzeslijDoGNUPlota(const char *Polecenie);
/*!
* \brief Udostępnia informację czy mają być wyświetlane informacje o błędach.
*
* Udostępnia wartość pola
* \link LaczeDoGNUPlota::_WyswietlajKomunikatyOBledach
* _WyswietlajKomunikatyOBledach\endlink.
* Określa ono, czy mają być wyświetlane komunikaty o błędach na wyjście
* standardowe, czy też nie.
*/
bool CzyWyswietlacKomunikaty() const { return _WyswietlajKomunikatyOBledach;}
/*!
* \brief Uruchamia program \e gnuplot jako proces potomny.
*/
bool UtworzProcesPotomny();
/*!
* Wyświetla na wyjście "standard error" komunikat (przekazany jako
* parametr), o ile pole
* \link LaczeDoGNUPlota::_WyswietlajKomunikatyOBledach
* _WyswietlajKomunikatyOBledach\endlink ma wartość
* \p true. W przypadku przeciwnym komunikat nie jest wyświetlany.
*/
void KomunikatBledu(const char *Komunikat) const;
/*!
* \brief Tworzy preambułę poprzedzającą polecenie rysowania
*
* Tworzy zbiór poleceń, które ustawiają właściwy tryb rysowania
* oraz zakresy współrzędnych, jak też wszystkie inne parametry
* wynikające z przyjętego trybu rysowania.
*/
void BudujPreambulePoleceniaRysowania(std::string &Preambula) const;
/*!
* \brief Tworzy preambułę poprzedzającą polecenie rysowania w trybie 2D
*
* Tworzy zbiór poleceń, które ustawiają właściwy tryb rysowania
* oraz zakresy współrzędnych, jak też wszystkie inne parametry
* wynikające z trybu rysowania 2D.
*/
void BudujPreambule_2D(std::string &Preambula) const;
/*!
* \brief Tworzy preambułę poprzedzającą polecenie rysowania w trybie 3D
*
* Tworzy zbiór poleceń, które ustawiają właściwy tryb rysowania
* oraz zakresy współrzędnych, jak też wszystkie inne parametry
* wynikające z trybu rysowania 3D.
*/
void BudujPreambule_3D(std::string &Preambula) const;
public:
/*!
* \brief Umożliwia lub zabrania rysowania osi OX
*
* Umożliwia lub zabrania rysowania osi \e OX na rysunku wykresu.
* \param Pokaz - decyduje o tym czy oś \e OX będzie rysowana (\p true),
* czy też nie (\p false).
*/
void PokazOs_OX(bool Pokaz) { _PokazOs_OX = Pokaz; }
/*!
* \brief Czy oś OX ma być rysowana
*
* Udostępnia informację czy oś \e OX ma być rysowana,
* czy też nie.
* \retval true - gdy oś \e OX ma być rysowana,
* \retval false - w przypadku przeciwnym.
*/
bool PokazOs_OX() const { return _PokazOs_OX; }
/*!
* \brief Umożliwia lub zabrania rysowania osi OY
*
* Umożliwia lub zabrania rysowania osi \e OY na rysunku wykresu.
* \param Pokaz - decyduje o tym czy oś \e OY będzie rysowana (\p true),
* czy też nie (\p false).
*/
void PokazOs_OY(bool Pokaz) { _PokazOs_OY = Pokaz; }
/*!
* \brief Czy oś OY ma być rysowana
*
* Udostępnia informację czy oś \e OY ma być rysowana,
* czy też nie.
* \retval true - gdy oś \e OY ma być rysowana,
* \retval false - w przypadku przeciwnym.
*/
bool PokazOs_OY() const { return _PokazOs_OY; }
/*!
* \brief Umożliwia lub zabrania rysowania osi OZ
*
* Umożliwia lub zabrania rysowania osi \e OZ na rysunku wykresu.
* \param Pokaz - decyduje o tym czy oś \e OZ będzie rysowana (\p true),
* czy też nie (\p false).
*/
void PokazOs_OZ(bool Pokaz) { _PokazOs_OZ = Pokaz; }
/*!
* \brief Czy oś OZ ma być rysowana
*
* Udostępnia informację czy oś \e OZ ma być rysowana,
* czy też nie.
* \retval true - gdy oś \e OZ ma być rysowana,
* \retval false - w przypadku przeciwnym.
*/
bool PokazOs_OZ() const { return _PokazOs_OZ; }
/*!
* Udostępnia dolną wartość zakresu skali wzdłuż osi \e OX.
*/
float Xmin() const { return _Xmin; }
/*!
* Udostępnia górną wartość zakresu skali wzdłuż osi \e OX.
*/
float Xmax() const { return _Xmax; }
/*!
* Udostępnia dolną wartość zakresu skali wzdłuż osi \e OY.
*/
float Ymin() const { return _Ymin; }
/*!
* Udostępnia górną wartość zakresu skali wzdłuż osi \e OY.
*/
float Ymax() const { return _Ymax; }
/*!
* Udostępnia dolną wartość zakresu skali wzdłuż osi \e OZ.
*/
float Zmin() const { return _Zmin; }
/*!
* Udostępnia górną wartość zakresu skali wzdłuż osi \e OZ.
*/
float Zmax() const { return _Zmax; }
/*!
* \brief Zmienia tryb rysowania
*
* Zmienia tryb rysowania jaki zostanie wymuszony na programie
* \p gnuplot.
* \param Tryb - wartość parametru określa nowy tryb rysowania.
*/
void ZmienTrybRys(TrybRysowania Tryb) { _TrybRys = Tryb; }
/*!
* \brief Udostępnia aktualny tryb rysowania
*
* Udostępnia informację o aktualnym trybie rysowania.
*/
TrybRysowania WezTrybRys() const { return _TrybRys; }
/*!
* \brief Ustawia zakres osi \e OX
*
* Ustawia zakres osi \e OX. Ogranicza to obszar, który będzie
* zwizualizowany przez programa \e gnuplot.
* \param Xo - dolna granica obszaru rysowania dla osi \e OX.
* \param Xn - górna granica obszaru rysowania dla osi \e OX.
*/
void UstawZakresX(float Xo, float Xn) { _Xmin = Xo; _Xmax = Xn; }
/*!
* \brief Ustawia zakres osi \e OY
*
* Ustawia zakres osi \e OY. Ogranicza to obszar, który będzie
* zwizualizowany przez programa \e gnuplot.
* \param Yo - dolna granica obszaru rysowania dla osi \e OY.
* \param Yn - górna granica obszaru rysowania dla osi \e OY.
*/
void UstawZakresY(float Yo, float Yn) { _Ymin = Yo; _Ymax = Yn; }
/*!
* \brief Ustawia zakres osi \e OZ.
*
* Ustawia zakres osi \e OZ. Ogranicza to obszar, który będzie
* zwizualizowany przez programa \e gnuplot.
* \param Zo - dolna granica obszaru rysowania dla osi \e OZ.
* \param Zn - górna granica obszaru rysowania dla osi \e OZ.
*/
void UstawZakresZ(float Zo, float Zn) { _Zmin = Zo; _Zmax = Zn; }
/*!
* \brief Udostępnia skalę dla osi \e OX.
*
* Udostępnia skalę dla osi \e OX dla tworzonego rysunku.
*/
float SkalaX() const { return _Xskala; }
/*!
* \brief Udostępnia skalę dla osi \e OZ.
*
* Udostępnia skalę dla osi \e OZ dla tworzonego rysunku.
*/
float SkalaZ() const { return _Zskala; }
/*!
* \brief Zadaje skalę wzdłuż osi \e OZ.
*
* Zadaje skalę wzdłuż osi \e OX dla tworzonego rysunku.
* \param skala_x - skala wzdłuż osi \e OX.
*/
void UstawSkaleX( float skala_x ) { _Xskala = skala_x; }
/*!
* \brief Zadaje skalę wzdłuż osi \e OZ.
*
* Zadaje skalę wzdłuż osi \e OZ dla tworzonego rysunku.
* \param skala_z - skala wzdłuż osi \e OZ.
*/
void UstawSkaleZ( float skala_z ) { _Zskala = skala_z; }
/*!
* \brief Zadaje skalę wzdłuż osi \e OX i \e OZ.
*
* Zadaje skalę wzdłuż osi \e OX i \e OZ dla tworzonego rysunku.
* \param skala_x - skala wzdłuż osi \e OX.
* \param skala_z - skala wzdłuż osi \e OZ.
*/
void UstawSkaleXZ( float skala_x, float skala_z )
{ UstawSkaleX(skala_x); UstawSkaleZ(skala_z); }
/*!
* Udostępnia wartość kąta rotacji renderowanego rysunku wokół
* osi \e OX. Zwracana wartość wyrażona jest w stopiniach.
*/
float RotacjaX() const { return _Xrotacja; }
/*!
* Udostępnia wartość kąta rotacji renderowanego rysunku wokół
* osi \e OZ. Zwracana wartość wyrażona jest w stopiniach.
*/
float RotacjaZ() const { return _Zrotacja; }
/*!
* \brief Ustawia rotację wokół osi \e OX.
*
* Zadaje kąt rotacji wokół osi \e OX. Umożliwia to zmianę
* punktu obserwacji renderowanego rysunku.
* \param kat_x - wartość kąta rotacji. Jego wartość podawana
* jest w stopniach.
*/
void UstawRotacjeX( float kat_x ) { _Xrotacja = kat_x; }
/*!
* \brief Ustawia rotację wokół osi \e OZ.
*
* Zadaje kąt rotacji wokół osi \e OZ. Umożliwia to zmianę
* punktu obserwacji renderowanego rysunku.
* \param kat_z - wartość kąta rotacji. Jego wartość podawana
* jest w stopniach.
*/
void UstawRotacjeZ( float kat_z ) { _Zrotacja = kat_z; }
/*!
* \brief Ustawia rotację wokół osi \e OX i \e OZ.
*
* Zadaje jednocześnie kąt rotacji wokół osi \e OX i \e OZ.
* Umożliwia to zmianę
* punktu obserwacji renderowanego rysunku.
* \param kat_x - wartość kąta rotacji względem osi \e OX.
* Jego wartość podawana
* jest w stopniach.
* \param kat_z - wartość kąta rotacji względem osi \e OZ.
* Jego wartość podawana
* jest w stopniach.
*/
void UstawRotacjeXZ( float kat_x, float kat_z )
{ UstawRotacjeX(kat_x); UstawRotacjeZ(kat_z); }
/*!
* \brief Zezwala lub zabrania wyświetlania komunikatów.
*
* Metoda pozwala, albo też zabrania wyświetlania komunikatów o blędach.
* Jeżeli jakaś z operacji nie powiedzie się, to jako wynik zwracana
* jest wartość \p false. Oprócz tego metody takie moga wyświetlać
* komunikaty, które kierowane są na wyjście "standard error"
* Domyślnie przymuje się, że programista nie chce dodatkwego wyświetlania
* komunikatów.
*/
void WyswietlajKomunikatyBledow( bool Tryb = true );
/*!
* \brief Dodaje nazwę pliku.
*
* Powoduje dodanie do listy plików zawierajacych dane dla \e gnuplota,
* nowej nazwy pliku.
*
* \param[in] NazwaPliku - nazwa pliku z danymi dla gnuplota.
* \param[in] RodzRys - tryb rysowania danego zbioru punktow.
* Może być ciągły lub jako zbiór osobnych punktów.
* \param[in] Szerokosc - szerokość rysowanego obiektu. W przypadku
* punktów parametr ten jest połową szerokości
* kwadratu reprezentującego dany punkt.
*
* \retval true - jeżeli istnieje plik o nazwie udostępnionej poprzez
* parametr
* \e NazwaPliku oraz jest zezwolenie na jego czytanie.
* Nazwa pliku zostaje dodana do listy plików z danymi
* dla \e gnuplota.
* \retval false - Jeżeli nie istnieje plik o nazwie przekazanej poprzez
* parametr \e NazwaPliku.
* Nazwa pliku zostaje dodana do listy plików z danymi
* dla \e gnuplota.
*/
bool DodajNazwePliku( const char * NazwaPliku,
RodzajRysowania RodzRys = RR_Ciagly,
int Szerokosc = 1
);
/*!
* \brief Tworzy listę parametrów umożliwiających rysowanie brył z plików.
*/
bool DopiszRysowanieZPlikow( std::string &Polecenie, char const **Sep );
/*!
* \brief Informuje, czy połączenie z \e gnuplot'em jest zainicjalizowane.
*
* Informuje, czy połączenie z programem \e gnuplot jest zainicjowane.
* \retval true - jeśli tak,
* \retval false - w przypadku przeciwnym.
*/
bool CzyPolaczenieJestZainicjowane() const;
/*!
* Jeżeli lista plików nie jest pusta, to generuje sekwencje poleceń
* dla programu \e gnuplot mająca na celu narysowanie płaszczyzn na
* na podstawie danych zawartych w plikach z listy.
*
* \pre Lista plików nie powinna być pusta. Nazwy plików na niej
* można umieścić za pomoca metody
* \link LaczeDoGNUPlota::DodajNazwe DodajNazwe\endlink.
* Metoda nie wymaga wcześniejszego zainicjowania połączenia
* z \e gnuplotem.
* \retval true - gdy zostają poprawnie wysłane polecenia dla gnuplota.
* Nie oznacza to jednak, że proces rysowania zakończył
* się pomyślnie.
* \retval false - gdy połączenie z gnuplotem nie może zostać poprawnie
* zainicjalizowane lub gdy lista plików jest pusta.
*/
bool Rysuj();
/*!
* Działa analogicznie jak metoda
* \link LaczeDoGNUPlota::Rysuj Rysuj\endlink, z tą różnicą, że
* rysunek robota
* składowany jest w pliku o nazwie przekazanej przez parametr
* \e NazwaPliku.
* Rysunek jest zapisywany w formacie \e PNG.
*
* \post Lista plików nie powinna być pusta ponadto powinno być
* możliwe otwarcie do zapisu pliku o nazwie przekazanej przez
* parametr \e NazwaPliku, do której dołączane jest rozszerzenie
* .ps .
* Metoda nie wymaga wcześniejszego zainicjowania połączenia
* z programem \e gnuplot.
*
* \retval true - gdy zostają poprawnie wysłane polecenia dla
* \e gnuplota.
* Nie oznacza to jednak, że proces rysowania zakończył
* się pomyślnie.
* \retval false - gdy połączenie z gnuplotem nie może zostać poprawnie
* zainicjalizowane lub gdy lista plików jest pusta lub
* też gdy nie można otworzyć pliku do zapisu.
*/
bool RysujDoPliku(const char *NazwaPliku);
/*!
* \brief Inicjalizuje połączenie z programem \e gnuplot.
*
* Inicjalizuje połączenie z programem \e gnuplot. Realizowane jest to
* poprzez rozwidlenie procesu i uruchomienie jako procesu potomnego
* programu \e gnuplot. Komunikacja z programem \e gnuplot realizowana jest
* poprzez przejęcie jego wejścia i wyjścia standardowego.
*
* \retval true - gdy połączenie z programem \e 0gnuplot zostało poprawnie
* zainicjalizowane lub gdy już wcześniej było
* zainicjalizowane.
* \retval false - gdy proces inicjalizacji połączenia zakończył się
* niepowodzeniem.
*/
bool Inicjalizuj();
/*!
* \brief Usuwa ostatnią nazwę pliku.
*
* Usuwa ostatnią nazwę z listy nazw plików.
*/
void UsunOstatniaNazwe();
/*!
* \brief Kasuje zawartość listy nazw plików.
*
* Calkowicie kasuje zawartość listy nazw plików.
*/
void UsunWszystkieNazwyPlikow();
LaczeDoGNUPlota();
virtual ~LaczeDoGNUPlota();
};
inline
bool LaczeDoGNUPlota::DopiszPlikiDoPoleceniaRysowania( std::string &,
char const **
)
{ return true; }
}
| 33.886331 | 91 | 0.651183 | KPO-2020-2021 |
b4701dd7dd21c980ae7d082fd39d9b890b203e45 | 5,262 | cc | C++ | integrations/tensorflow/compiler/dialect/tf_tensorlist/conversion/convert_tf_to_tf_tensorlist.cc | silvrwolfboy/iree | 6d8b59ba8db9c54450ea29e6d9d37b18fd40d12a | [
"Apache-2.0"
] | null | null | null | integrations/tensorflow/compiler/dialect/tf_tensorlist/conversion/convert_tf_to_tf_tensorlist.cc | silvrwolfboy/iree | 6d8b59ba8db9c54450ea29e6d9d37b18fd40d12a | [
"Apache-2.0"
] | null | null | null | integrations/tensorflow/compiler/dialect/tf_tensorlist/conversion/convert_tf_to_tf_tensorlist.cc | silvrwolfboy/iree | 6d8b59ba8db9c54450ea29e6d9d37b18fd40d12a | [
"Apache-2.0"
] | 1 | 2020-03-06T06:22:26.000Z | 2020-03-06T06:22:26.000Z | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "integrations/tensorflow/compiler/dialect/tf_tensorlist/ir/tf_tensorlist_dialect.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
namespace mlir {
namespace tf_tensorlist {
#include "integrations/tensorflow/compiler/dialect/tf_tensorlist/conversion/convert_tf_to_tf_tensorlist.inc"
class ConvertTfToTfTensorList
: public OperationPass<ConvertTfToTfTensorList, FuncOp> {
public:
void runOnOperation() override;
};
bool isTfVariant(Type type) {
if (auto tensorType = type.dyn_cast<TensorType>()) {
return tensorType.getElementType().isa<TF::VariantType>();
}
return false;
}
void ConvertTfToTfTensorList::runOnOperation() {
auto func = getOperation();
// The conversion happens in 2 steps:
// 1. We blindly replace all tf ops operating on TensorList's with
// tf_tensorlist ops. No types change in this step (so the IR is transiently
// invalid).
// 2. We rewrite all the types to make the IR valid again.
//
// The reason we need to do the rewriting this way is that not all TF variant
// types actually represent a tensorlist. Only by looking at ops that we know
// produce tensorlists can we deduce which TF varaints are tensorlists.
//
// The MLIR type conversion infrastructure doesn't handle this situation well.
// It only knows how to handle blindly convert one type to another type.
OwningRewritePatternList patterns;
populateWithGenerated(&getContext(), &patterns);
ConversionTarget target(getContext());
target.addLegalDialect<TfTensorListDialect>();
target.addLegalDialect<TF::TensorFlowDialect>();
target.addLegalDialect<StandardOpsDialect>();
target.addIllegalOp<TF::TensorListReserveOp>();
target.addIllegalOp<TF::TensorListGetItemOp>();
target.addIllegalOp<TF::TensorListSetItemOp>();
target.addIllegalOp<TF::TensorListFromTensorOp>();
target.addIllegalOp<TF::TensorListStackOp>();
if (failed(applyPartialConversion(func, target, patterns))) {
func.emitError() << "unable to lower to tf_tensorlist dialect";
return signalPassFailure();
}
// The above conversions didn't do any type conversion since we don't
// want to blindly update all variant types to tensorlist. So here we do a
// targeted rewrite.
auto *tfTensorListDialect =
func.getContext()->getRegisteredDialect<TfTensorListDialect>();
auto tensorListType = TensorListType::get(func.getContext());
SmallVector<Value, 8> typeConversionWorklist;
func.walk([&](Operation *op) {
if (op->getDialect() != tfTensorListDialect) {
return;
}
for (auto result : op->getResults()) {
if (isTfVariant(result.getType())) {
result.setType(tensorListType);
typeConversionWorklist.push_back(result);
}
}
});
while (!typeConversionWorklist.empty()) {
Value v = typeConversionWorklist.pop_back_val();
for (OpOperand &use : v.getUses()) {
Operation *owner = use.getOwner();
// If the user is already in the tf_tensorlist dialect, then everything is
// ok.
if (owner->getDialect() == tfTensorListDialect) {
continue;
}
// If a user is just a terminator passing the value through a successor
// operand, propagate through the successor operand.
if (owner->isKnownTerminator()) {
if (auto arg =
owner->getSuccessorBlockArgument(use.getOperandNumber())) {
if (!arg->getType().isa<TensorListType>()) {
arg->setType(tensorListType);
typeConversionWorklist.push_back(*arg);
}
continue;
}
}
// !tf.variant can have various subtypes which we blindly turn into just
// !tf_tensorlist.list here. So elide all casts.
if (auto castOp = dyn_cast<TF::CastOp>(owner)) {
assert(v == castOp.x());
castOp.y().replaceAllUsesWith(castOp.x());
castOp.erase();
// The RAUW could have added more uses of `v`, so put it back on the
// worklist and process it again.
typeConversionWorklist.push_back(v);
break;
}
owner->emitError() << "unable to convert tensorlist op: "
<< owner->getName();
return signalPassFailure();
}
}
}
static PassRegistration<ConvertTfToTfTensorList> pass(
"convert-tf-to-tf_tensorlist", "Convert to more precise types");
std::unique_ptr<OpPassBase<FuncOp>> createConvertTfToTfTensorList() {
return std::make_unique<ConvertTfToTfTensorList>();
}
} // namespace tf_tensorlist
} // namespace mlir
| 37.856115 | 108 | 0.702204 | silvrwolfboy |
b4717b8d0a9e7a7820568a0ee2159fc863d9c59a | 6,959 | hh | C++ | examples/external/OpenMesh/include/OpenMesh/Core/IO/exporter/BaseExporter.hh | zhangxaochen/Opt | 7f1af802bfc84cc9ef1adb9facbe4957078f529a | [
"MIT"
] | 260 | 2017-03-02T19:57:51.000Z | 2022-01-21T03:52:03.000Z | examples/external/OpenMesh/include/OpenMesh/Core/IO/exporter/BaseExporter.hh | zhangxaochen/Opt | 7f1af802bfc84cc9ef1adb9facbe4957078f529a | [
"MIT"
] | 102 | 2017-03-03T00:42:56.000Z | 2022-03-30T14:15:20.000Z | examples/external/OpenMesh/include/OpenMesh/Core/IO/exporter/BaseExporter.hh | zhangxaochen/Opt | 7f1af802bfc84cc9ef1adb9facbe4957078f529a | [
"MIT"
] | 71 | 2017-03-02T20:22:33.000Z | 2022-01-02T03:49:04.000Z | /* ========================================================================= *
* *
* OpenMesh *
* Copyright (c) 2001-2015, RWTH-Aachen University *
* Department of Computer Graphics and Multimedia *
* All rights reserved. *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
*---------------------------------------------------------------------------*
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted provided that the following conditions *
* are met: *
* *
* 1. Redistributions of source code must retain the above copyright notice, *
* this list of conditions and the following disclaimer. *
* *
* 2. Redistributions in binary form must reproduce the above copyright *
* notice, this list of conditions and the following disclaimer in the *
* documentation and/or other materials provided with the distribution. *
* *
* 3. Neither the name of the copyright holder nor the names of its *
* contributors may be used to endorse or promote products derived from *
* this software without specific prior written permission. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
* *
* ========================================================================= */
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* *
\*===========================================================================*/
//=============================================================================
//
// Implements the baseclass for MeshWriter exporter modules
//
//=============================================================================
#ifndef __BASEEXPORTER_HH__
#define __BASEEXPORTER_HH__
//=== INCLUDES ================================================================
// STL
#include <vector>
// OpenMesh
#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Geometry/VectorT.hh>
#include <OpenMesh/Core/Mesh/BaseKernel.hh>
//=== NAMESPACES ==============================================================
namespace OpenMesh {
namespace IO {
//=== EXPORTER ================================================================
/**
Base class for exporter modules.
The exporter modules provide an interface between the writer modules and
the target data structure.
*/
class OPENMESHDLLEXPORT BaseExporter
{
public:
virtual ~BaseExporter() { }
// get vertex data
virtual Vec3f point(VertexHandle _vh) const = 0;
virtual Vec3f normal(VertexHandle _vh) const = 0;
virtual Vec3uc color(VertexHandle _vh) const = 0;
virtual Vec4uc colorA(VertexHandle _vh) const = 0;
virtual Vec3ui colori(VertexHandle _vh) const = 0;
virtual Vec4ui colorAi(VertexHandle _vh) const = 0;
virtual Vec3f colorf(VertexHandle _vh) const = 0;
virtual Vec4f colorAf(VertexHandle _vh) const = 0;
virtual Vec2f texcoord(VertexHandle _vh) const = 0;
// get face data
virtual unsigned int
get_vhandles(FaceHandle _fh,
std::vector<VertexHandle>& _vhandles) const=0;
virtual Vec3f normal(FaceHandle _fh) const = 0;
virtual Vec3uc color (FaceHandle _fh) const = 0;
virtual Vec4uc colorA(FaceHandle _fh) const = 0;
virtual Vec3ui colori(FaceHandle _fh) const = 0;
virtual Vec4ui colorAi(FaceHandle _fh) const = 0;
virtual Vec3f colorf(FaceHandle _fh) const = 0;
virtual Vec4f colorAf(FaceHandle _fh) const = 0;
// get edge data
virtual Vec3uc color(EdgeHandle _eh) const = 0;
virtual Vec4uc colorA(EdgeHandle _eh) const = 0;
virtual Vec3ui colori(EdgeHandle _eh) const = 0;
virtual Vec4ui colorAi(EdgeHandle _eh) const = 0;
virtual Vec3f colorf(EdgeHandle _eh) const = 0;
virtual Vec4f colorAf(EdgeHandle _eh) const = 0;
// get reference to base kernel
virtual const BaseKernel* kernel() { return 0; }
// query number of faces, vertices, normals, texcoords
virtual size_t n_vertices() const = 0;
virtual size_t n_faces() const = 0;
virtual size_t n_edges() const = 0;
// property information
virtual bool is_triangle_mesh() const { return false; }
virtual bool has_vertex_normals() const { return false; }
virtual bool has_vertex_colors() const { return false; }
virtual bool has_vertex_texcoords() const { return false; }
virtual bool has_edge_colors() const { return false; }
virtual bool has_face_normals() const { return false; }
virtual bool has_face_colors() const { return false; }
};
//=============================================================================
} // namespace IO
} // namespace OpenMesh
//=============================================================================
#endif
//=============================================================================
| 44.896774 | 79 | 0.470901 | zhangxaochen |
b472c958b2690811d723def0ab4a062b61ddae59 | 12,732 | cpp | C++ | src/stage/stage-base.cpp | tilnewman/heroespath-src | a7784e44d8b5724f305ef8b8671fed54e2e5fd69 | [
"BSL-1.0",
"Beerware"
] | 2 | 2019-02-28T00:28:08.000Z | 2019-10-20T14:39:48.000Z | src/stage/stage-base.cpp | tilnewman/heroespath-src | a7784e44d8b5724f305ef8b8671fed54e2e5fd69 | [
"BSL-1.0",
"Beerware"
] | null | null | null | src/stage/stage-base.cpp | tilnewman/heroespath-src | a7784e44d8b5724f305ef8b8671fed54e2e5fd69 | [
"BSL-1.0",
"Beerware"
] | null | null | null | // This is an open source non-commercial project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
// ----------------------------------------------------------------------------
// "THE BEER-WARE LICENSE" (Revision 42):
// <ztn@zurreal.com> wrote this file. As long as you retain this notice you
// can do whatever you want with this stuff. If we meet some day, and you think
// this stuff is worth it, you can buy me a beer in return. Ziesche Til Newman
// ----------------------------------------------------------------------------
//
// stage-base.cpp
//
#include "stage-base.hpp"
#include "game/game-controller.hpp"
#include "gui/box-entity-info.hpp"
#include "gui/box-entity.hpp"
#include "gui/display.hpp"
#include "gui/entity.hpp"
#include "gui/font-manager.hpp"
#include "gui/i-entity.hpp"
#include "gui/sound-manager.hpp"
#include "gui/text-info.hpp"
#include "gui/texture-cache.hpp"
#include "sfutil/distance.hpp"
#include <SFML/Graphics/RenderTarget.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <algorithm>
#include <exception>
#include <sstream>
namespace heroespath
{
namespace stage
{
const float StageBase::MOUSE_DRAG_MIN_DISTANCE_ { 3.0f };
StageBase::StageBase(
const std::string & NAME,
const gui::FontEnumVec_t & FONTS_TO_PRELOAD,
const gui::SfxEnumVec_t & SFX_TO_PRELOAD)
: STAGE_NAME_(std::string(NAME))
, stageRegion_(gui::Display::Instance()->FullScreenRect())
, entityPVec_()
, entityWithFocusPtrOpt_()
, hoverTextBoxUPtr_()
, hoverText_()
, isFading_(false)
, isMouseHeldDown_(false)
, isMouseHeldDownAndMoving_(false)
, mouseDownPosV_(0.0f, 0.0f)
{
StageBaseCommonSetupTasks(FONTS_TO_PRELOAD, SFX_TO_PRELOAD);
}
StageBase::StageBase(
const std::string & NAME,
const sf::FloatRect & REGION,
const gui::FontEnumVec_t & FONTS_TO_PRELOAD,
const gui::SfxEnumVec_t & SFX_TO_PRELOAD)
: STAGE_NAME_(std::string(NAME))
, stageRegion_(REGION)
, entityPVec_()
, entityWithFocusPtrOpt_()
, hoverTextBoxUPtr_()
, hoverText_()
, isFading_(false)
, isMouseHeldDown_(false)
, isMouseHeldDownAndMoving_(false)
, mouseDownPosV_(0.0f, 0.0f)
{
StageBaseCommonSetupTasks(FONTS_TO_PRELOAD, SFX_TO_PRELOAD);
}
void StageBase::StageBaseCommonSetupTasks(
const gui::FontEnumVec_t & FONTS_TO_PRELOAD, const gui::SfxEnumVec_t & SFX_TO_PRELOAD)
{
gui::FontManager::Instance()->Load(FONTS_TO_PRELOAD);
gui::SoundManager::Instance()->PreLoadSfx(SFX_TO_PRELOAD);
}
StageBase::~StageBase() = default;
game::Phase::Enum StageBase::GetPhase() const
{
return game::GameController::Instance()->GetPhase();
}
const std::string StageBase::MakeCallbackHandlerMessage(
const std::string & EVENT_DESCRIPTION, const std::string & ACTION_TAKEN) const
{
if (ACTION_TAKEN.empty())
{
return "";
}
else
{
return GetStageName() + " finished handling callback event " + EVENT_DESCRIPTION
+ " and " + ACTION_TAKEN + ".";
}
}
void StageBase::UpdateTime(const float ELAPSED_TIME_SECONDS)
{
for (auto & entityPtr : entityPVec_)
{
entityPtr->UpdateTime(ELAPSED_TIME_SECONDS);
}
}
void StageBase::UpdateMousePos(const sf::Vector2i & NEW_MOUSE_POS)
{
const sf::Vector2f NEW_MOUSE_POS_F(NEW_MOUSE_POS);
isMouseHeldDownAndMoving_
= (isMouseHeldDown_
&& (sfutil::Distance(mouseDownPosV_, NEW_MOUSE_POS_F) > MOUSE_DRAG_MIN_DISTANCE_));
for (auto & entityPtr : entityPVec_)
{
entityPtr->UpdateMousePos(NEW_MOUSE_POS_F);
}
}
void StageBase::UpdateMouseDown(const sf::Vector2f & MOUSE_POS_V)
{
isMouseHeldDown_ = true;
mouseDownPosV_ = MOUSE_POS_V;
for (auto & entityPtr : entityPVec_)
{
entityPtr->MouseDown(MOUSE_POS_V);
}
}
const gui::IEntityPtrOpt_t StageBase::UpdateMouseUp(const sf::Vector2f & MOUSE_POS_V)
{
isMouseHeldDown_ = false;
isMouseHeldDownAndMoving_ = false;
for (const auto & ENTITY_PTR : entityPVec_)
{
if ((ENTITY_PTR->MouseUp(MOUSE_POS_V)) && ENTITY_PTR->WillAcceptFocus())
{
return ENTITY_PTR;
}
}
return boost::none;
}
void StageBase::UpdateMouseWheel(const sf::Vector2f & MOUSE_POS_V, const float MOUSEWHEEL_DELTA)
{
for (auto & entityPtr : entityPVec_)
{
entityPtr->UpdateMouseWheel(MOUSE_POS_V, MOUSEWHEEL_DELTA);
}
}
bool StageBase::KeyPress(const sf::Event::KeyEvent & KE)
{
return (entityWithFocusPtrOpt_ && (entityWithFocusPtrOpt_.value()->KeyPress(KE)));
}
bool StageBase::KeyRelease(const sf::Event::KeyEvent & KE)
{
return (entityWithFocusPtrOpt_ && (entityWithFocusPtrOpt_.value()->KeyRelease(KE)));
}
void StageBase::RemoveFocus()
{
if (entityWithFocusPtrOpt_)
{
entityWithFocusPtrOpt_.value()->SetHasFocus(false);
entityWithFocusPtrOpt_ = boost::none;
}
}
void StageBase::SetFocus(const gui::IEntityPtr_t ENTITY_PTR)
{
const auto ORIG_ENTITY_WITH_FOCUS_NAME {
((entityWithFocusPtrOpt_) ? entityWithFocusPtrOpt_.value()->GetEntityName() : "(None)")
};
const auto WAS_FOUND { std::find(std::begin(entityPVec_), std::end(entityPVec_), ENTITY_PTR)
!= std::end(entityPVec_) };
if (WAS_FOUND)
{
RemoveFocus();
ENTITY_PTR->SetHasFocus(true);
entityWithFocusPtrOpt_ = ENTITY_PTR;
}
else
{
M_HP_LOG_ERR(
"stage::StageBase("
<< GetStageName() << ")::SetFocus(entity=" << ENTITY_PTR->GetEntityName()
<< ") Attempt to set focus with an IEntityPtr_t that was not in entityPVec_. "
"orig_entity_withfocus=\""
<< ORIG_ENTITY_WITH_FOCUS_NAME << "\"");
}
}
void StageBase::draw(sf::RenderTarget & target, sf::RenderStates states) const
{
for (auto & entityPtr : entityPVec_)
{
entityPtr->draw(target, states);
}
if (hoverTextBoxUPtr_)
{
target.draw(*hoverTextBoxUPtr_, states);
target.draw(hoverText_, states);
}
}
void StageBase::EntityAdd(const gui::IEntityPtr_t ENTITY_PTR, const bool WILL_INSERT_AT_FRONT)
{
const auto WAS_FOUND { std::find(std::begin(entityPVec_), std::end(entityPVec_), ENTITY_PTR)
!= std::end(entityPVec_) };
if (WAS_FOUND)
{
M_HP_LOG_WRN(
"Ignoring because this entity was already in the list. (entity_name=\""
<< ENTITY_PTR->GetEntityName() << "\")" << M_HP_VAR_STR(WILL_INSERT_AT_FRONT)
<< "(stage=" << GetStageName() << ")");
return;
}
if (WILL_INSERT_AT_FRONT)
{
entityPVec_.insert(std::begin(entityPVec_), ENTITY_PTR);
}
else
{
entityPVec_.emplace_back(ENTITY_PTR);
}
}
void StageBase::EntityRemove(const gui::IEntityPtr_t ENTITY_PTR)
{
const auto ORIG_NUM_ENTITYS { entityPVec_.size() };
entityPVec_.erase(
std::remove(entityPVec_.begin(), entityPVec_.end(), ENTITY_PTR), entityPVec_.end());
bool wasEntityFoundAndRemoved { (ORIG_NUM_ENTITYS != entityPVec_.size()) };
if (entityWithFocusPtrOpt_ == ENTITY_PTR)
{
RemoveFocus();
wasEntityFoundAndRemoved = true;
}
if (false == wasEntityFoundAndRemoved)
{
M_HP_LOG_WRN(
"Entity to remove named \"" << ENTITY_PTR->GetEntityName() << "\" was not found. "
<< "(stage=" << GetStageName() << ")");
}
}
void StageBase::SetMouseHover(const sf::Vector2f & MOUSE_POS_V, const bool IS_MOUSE_HOVERING)
{
if (IS_MOUSE_HOVERING)
{
std::string text("");
// check if focused entity is hovered first
if (entityWithFocusPtrOpt_
&& (entityWithFocusPtrOpt_.value()->GetEntityRegion().contains(MOUSE_POS_V)))
{
text = entityWithFocusPtrOpt_.value()->GetMouseHoverText();
}
// if focused entity is not hovered, then look for any entity the mouse is hovering over
if (text.empty())
{
for (const auto & NEXT_ENTITY_PTR : entityPVec_)
{
if (NEXT_ENTITY_PTR->GetEntityRegion().contains(MOUSE_POS_V))
{
text = NEXT_ENTITY_PTR->GetMouseHoverText();
if (text.empty() == false)
{
break;
}
}
}
}
if (text.empty())
{
if (hoverTextBoxUPtr_)
{
hoverTextBoxUPtr_.reset();
}
return;
}
const gui::TextInfo TEXT_INFO(
text,
gui::GuiFont::System,
gui::FontManager::Instance()->Size_Smallish(),
sf::Color(50, 50, 50),
gui::Justified::Left);
hoverText_.setup(TEXT_INFO);
sf::FloatRect region(
MOUSE_POS_V.x - 200.0f,
MOUSE_POS_V.y + 10.0f,
hoverText_.getGlobalBounds().width + 20.0f,
hoverText_.getGlobalBounds().height + 8.0f);
const auto SCREEN_WIDTH { gui::Display::Instance()->GetWinWidth() };
if ((region.left + region.width) > SCREEN_WIDTH)
{
region.left = SCREEN_WIDTH - region.width;
}
if (region.left < 0.0f)
{
region.left = 0.0f;
}
hoverText_.setPosition(region.left + 10.0f, region.top + 2.0f);
gui::BoxEntityInfo boxInfo;
boxInfo.SetupColor(sfutil::color::Orange - sf::Color(20, 0, 0, 0));
boxInfo.SetupBorder(true, 1.0f);
hoverTextBoxUPtr_
= std::make_unique<gui::BoxEntity>(GetStageName() + "'sHoverText", region, boxInfo);
}
else
{
if (hoverTextBoxUPtr_)
{
hoverTextBoxUPtr_.reset();
}
}
}
void StageBase::TestingStrAppend(const std::string & MESSAGE)
{
game::GameController::Instance()->TestingStrAppend(MESSAGE);
}
void StageBase::TestingStrIncrement(const std::string & MESSAGE)
{
game::GameController::Instance()->TestingStrIncrement(MESSAGE);
}
void StageBase::TestingImageSet(const std::string & MESSAGE)
{
game::GameController::Instance()->TestingImageSet(MESSAGE);
}
void StageBase::ClearAllEntities()
{
entityWithFocusPtrOpt_ = boost::none;
entityPVec_.clear();
}
void StageBase::SpawnPopup(
const misc::PopupCallback_t::IHandlerPtr_t POPUP_HANDLER_PTR,
const popup::PopupInfo & POPUP_INFO) const
{
game::GameController::Instance()->SpawnPopup(POPUP_HANDLER_PTR, POPUP_INFO);
}
void StageBase::RemovePopup(
const popup::PopupButtons::Enum TYPE, const std::size_t SELECTION) const
{
game::GameController::Instance()->RemovePopup(TYPE, SELECTION);
}
void StageBase::TransitionTo(const stage::Stage::Enum NEW_STAGE) const
{
game::GameController::Instance()->TransitionTo(NEW_STAGE);
}
void StageBase::TransitionTo(const stage::SetupPacket & SETUP_PACKET) const
{
game::GameController::Instance()->TransitionTo(SETUP_PACKET);
}
const gui::DisplayChangeResult StageBase::ChangeResolution(
const misc::PopupCallback_t::IHandlerPtr_t POPUP_HANDLER_PTR,
const gui::Resolution & NEW_RES,
const unsigned ANTIALIAS_LEVEL) const
{
return game::GameController::Instance()->ChangeResolution(
POPUP_HANDLER_PTR, NEW_RES, ANTIALIAS_LEVEL);
}
} // namespace stage
} // namespace heroespath
| 31.205882 | 100 | 0.572809 | tilnewman |
b4738fcb5e33aacf0e943ca446289dfcbd2cf839 | 18,214 | cpp | C++ | src/chrono_vehicle/wheeled_vehicle/steering/ChPitmanArmShafts.cpp | iicfcii/chrono | d42e58d6e7fb2a2b254510c1c174789dc9f95dfe | [
"BSD-3-Clause"
] | 3 | 2019-01-15T07:40:33.000Z | 2019-01-15T09:16:45.000Z | src/chrono_vehicle/wheeled_vehicle/steering/ChPitmanArmShafts.cpp | iicfcii/chrono | d42e58d6e7fb2a2b254510c1c174789dc9f95dfe | [
"BSD-3-Clause"
] | 1 | 2019-10-25T10:35:29.000Z | 2019-10-25T10:35:29.000Z | src/chrono_vehicle/wheeled_vehicle/steering/ChPitmanArmShafts.cpp | iicfcii/chrono | d42e58d6e7fb2a2b254510c1c174789dc9f95dfe | [
"BSD-3-Clause"
] | null | null | null | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// Base class for a Pitman Arm steering subsystem.
// Derived from ChSteering, but still an abstract base class.
//
// =============================================================================
#include <vector>
#include "chrono/assets/ChColorAsset.h"
#include "chrono/assets/ChCylinderShape.h"
#include "chrono/assets/ChPointPointDrawing.h"
#include "chrono_vehicle/wheeled_vehicle/steering/ChPitmanArmShafts.h"
namespace chrono {
namespace vehicle {
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
ChPitmanArmShafts::ChPitmanArmShafts(const std::string& name, bool vehicle_frame_inertia, bool rigid_column)
: ChSteering(name), m_vehicle_frame_inertia(vehicle_frame_inertia), m_rigid(rigid_column) {}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChPitmanArmShafts::Initialize(std::shared_ptr<ChChassis> chassis,
const ChVector<>& location,
const ChQuaternion<>& rotation) {
m_position = ChCoordsys<>(location, rotation);
auto chassisBody = chassis->GetBody();
auto sys = chassisBody->GetSystem();
// Chassis orientation (expressed in absolute frame)
// Recall that the suspension reference frame is aligned with the chassis.
ChQuaternion<> chassisRot = chassisBody->GetFrame_REF_to_abs().GetRot();
// Express the steering reference frame in the absolute coordinate system.
ChFrame<> steering_to_abs(location, rotation);
steering_to_abs.ConcatenatePreTransformation(chassisBody->GetFrame_REF_to_abs());
// Transform all points and directions to absolute frame.
std::vector<ChVector<>> points(NUM_POINTS);
std::vector<ChVector<>> dirs(NUM_DIRS);
for (int i = 0; i < NUM_POINTS; i++) {
ChVector<> rel_pos = getLocation(static_cast<PointId>(i));
points[i] = steering_to_abs.TransformPointLocalToParent(rel_pos);
}
for (int i = 0; i < NUM_DIRS; i++) {
ChVector<> rel_dir = getDirection(static_cast<DirectionId>(i));
dirs[i] = steering_to_abs.TransformDirectionLocalToParent(rel_dir);
}
// Unit vectors for orientation matrices.
ChVector<> u;
ChVector<> v;
ChVector<> w;
ChMatrix33<> rot;
// Create and initialize the steering link body
m_link = std::shared_ptr<ChBody>(sys->NewBody());
m_link->SetNameString(m_name + "_link");
m_link->SetPos(points[STEERINGLINK]);
m_link->SetRot(steering_to_abs.GetRot());
m_link->SetMass(getSteeringLinkMass());
if (m_vehicle_frame_inertia) {
ChMatrix33<> inertia = TransformInertiaMatrix(getSteeringLinkInertiaMoments(), getSteeringLinkInertiaProducts(),
chassisRot, steering_to_abs.GetRot());
m_link->SetInertia(inertia);
} else {
m_link->SetInertiaXX(getSteeringLinkInertiaMoments());
m_link->SetInertiaXY(getSteeringLinkInertiaProducts());
}
sys->AddBody(m_link);
m_pP = m_link->TransformPointParentToLocal(points[UNIV]);
m_pI = m_link->TransformPointParentToLocal(points[REVSPH_S]);
m_pTP = m_link->TransformPointParentToLocal(points[TIEROD_PA]);
m_pTI = m_link->TransformPointParentToLocal(points[TIEROD_IA]);
// Create and initialize the Pitman arm body
m_arm = std::shared_ptr<ChBody>(sys->NewBody());
m_arm->SetNameString(m_name + "_arm");
m_arm->SetPos(points[PITMANARM]);
m_arm->SetRot(steering_to_abs.GetRot());
m_arm->SetMass(getPitmanArmMass());
if (m_vehicle_frame_inertia) {
ChMatrix33<> inertia = TransformInertiaMatrix(getPitmanArmInertiaMoments(), getPitmanArmInertiaProducts(),
chassisRot, steering_to_abs.GetRot());
m_arm->SetInertia(inertia);
} else {
m_arm->SetInertiaXX(getPitmanArmInertiaMoments());
m_arm->SetInertiaXY(getPitmanArmInertiaProducts());
}
sys->AddBody(m_arm);
// Cache points for arm visualization (expressed in the arm frame)
m_pC = m_arm->TransformPointParentToLocal(points[REV]);
m_pL = m_arm->TransformPointParentToLocal(points[UNIV]);
// Create and initialize the revolute joint between chassis and Pitman arm.
// The z direction of the joint orientation matrix is dirs[REV_AXIS], assumed
// to be a unit vector.
u = points[PITMANARM] - points[REV];
v = Vcross(dirs[REV_AXIS], u);
v.Normalize();
u = Vcross(v, dirs[REV_AXIS]);
rot.Set_A_axis(u, v, dirs[REV_AXIS]);
m_revolute = chrono_types::make_shared<ChLinkLockRevolute>();
m_revolute->SetNameString(m_name + "_revolute");
m_revolute->Initialize(chassisBody, m_arm, ChCoordsys<>(points[REV], rot.Get_A_quaternion()));
sys->AddLink(m_revolute);
// Create and initialize the universal joint between the Pitman arm and steering link.
// The x and y directions of the joint orientation matrix are given by
// dirs[UNIV_AXIS_ARM] and dirs[UNIV_AXIS_LINK], assumed to be unit vectors
// and orthogonal.
w = Vcross(dirs[UNIV_AXIS_ARM], dirs[UNIV_AXIS_LINK]);
rot.Set_A_axis(dirs[UNIV_AXIS_ARM], dirs[UNIV_AXIS_LINK], w);
m_universal = chrono_types::make_shared<ChLinkUniversal>();
m_universal->SetNameString(m_name + "_universal");
m_universal->Initialize(m_arm, m_link, ChFrame<>(points[UNIV], rot.Get_A_quaternion()));
sys->AddLink(m_universal);
// Create and initialize the revolute-spherical joint (massless idler arm).
// The length of the idler arm is the distance between the two hardpoints.
// The z direction of the revolute joint orientation matrix is
// dirs[REVSPH_AXIS], assumed to be a unit vector.
double distance = (points[REVSPH_S] - points[REVSPH_R]).Length();
u = points[REVSPH_S] - points[REVSPH_R];
v = Vcross(dirs[REVSPH_AXIS], u);
v.Normalize();
u = Vcross(v, dirs[REVSPH_AXIS]);
rot.Set_A_axis(u, v, dirs[REVSPH_AXIS]);
m_revsph = chrono_types::make_shared<ChLinkRevoluteSpherical>();
m_revsph->SetNameString(m_name + "_revsph");
m_revsph->Initialize(chassisBody, m_link, ChCoordsys<>(points[REVSPH_R], rot.Get_A_quaternion()), distance);
sys->AddLink(m_revsph);
//// TODO: Decide if shaftC should be attached to chassis or if it should be "fixed"
//// Right now: fixed.
// Create all shafts in steering column
// Chassis --X-- shaftC --M-- shaftC1 --S-- shaftA1 --G-- shaftA --X-- Arm
// All shafts are aligned with dir[REV_AXIS], assumed to be a unit vector.
double inertia = getSteeringColumnInertia();
m_shaft_C = chrono_types::make_shared<ChShaft>();
m_shaft_C->SetNameString(m_name + "_shaftC");
m_shaft_C->SetInertia(inertia);
m_shaft_C->SetShaftFixed(true);
sys->Add(m_shaft_C);
m_shaft_C1 = chrono_types::make_shared<ChShaft>();
m_shaft_C1->SetNameString(m_name + "_shaftC1");
m_shaft_C1->SetInertia(inertia);
sys->Add(m_shaft_C1);
m_shaft_A1 = chrono_types::make_shared<ChShaft>();
m_shaft_A1->SetNameString(m_name + "_shaftA1");
m_shaft_A1->SetInertia(inertia);
sys->Add(m_shaft_A1);
m_shaft_A = chrono_types::make_shared<ChShaft>();
m_shaft_A->SetNameString(m_name + "_shaftA");
m_shaft_A->SetInertia(inertia);
sys->Add(m_shaft_A);
// Rigidly attach shaftA to the arm body
m_shaft_arm = chrono_types::make_shared<ChShaftsBody>();
m_shaft_arm->SetNameString(m_name + "_shaftA_to_arm");
m_shaft_arm->Initialize(m_shaft_A, m_arm, dirs[REV_AXIS]);
sys->Add(m_shaft_arm);
// Rigidly attach shaftC to the chassis body
////m_shaft_chassis = chrono_types::make_shared<ChShaftsBody>();
////m_shaft_chassis->SetNameString(m_name + "_shaftC_to_chassis");
////m_shaft_chassis->Initialize(m_shaft_C, chassisBody, dirs[REV_AXIS]);
////sys->Add(m_shaft_chassis);
// A motor (for steering input) between shaftC and shaftC1
// The setpoint for the motor angle function is set in Synchronize()
m_shaft_motor = chrono_types::make_shared<ChShaftsMotorAngle>();
m_shaft_motor->SetNameString(m_name + "_motor");
m_shaft_motor->Initialize(m_shaft_C, m_shaft_C1);
auto motor_fun = chrono_types::make_shared<ChFunction_Setpoint>();
m_shaft_motor->SetAngleFunction(motor_fun);
sys->Add(m_shaft_motor);
// A reduction gear between shaftA and shaftA1
// (note order of connected shafts for gear_ratio > 1)
m_shaft_gear = chrono_types::make_shared<ChShaftsGear>();
m_shaft_gear->SetNameString(m_name + "_transmission");
m_shaft_gear->SetTransmissionRatio(getGearRatio());
m_shaft_gear->Initialize(m_shaft_A, m_shaft_A1);
sys->Add(m_shaft_gear);
// Connect shaftA1 and shaftC1 (compliant or rigid connection)
if (m_rigid) {
// Use a gear couple with ratio=1
m_rigid_connection = chrono_types::make_shared<ChShaftsGear>();
m_rigid_connection->SetNameString(m_name + "_rigid_column");
m_rigid_connection->SetTransmissionRatio(1.0);
m_rigid_connection->Initialize(m_shaft_A1, m_shaft_C1);
sys->Add(m_rigid_connection);
} else {
// Use a torsional spring between shaftA1 and shaftC1
m_spring_connection = chrono_types::make_shared<ChShaftsTorsionSpring>();
m_spring_connection->SetNameString(m_name + "_compliant_column");
m_spring_connection->SetTorsionalStiffness(getSteeringCompliance());
////m_spring_connection->SetTorsionalDamping(10);
m_spring_connection->Initialize(m_shaft_C1, m_shaft_A1);
sys->Add(m_spring_connection);
}
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChPitmanArmShafts::Synchronize(double time, double steering) {
auto fun = std::static_pointer_cast<ChFunction_Setpoint>(m_shaft_motor->GetAngleFunction());
fun->SetSetpoint(getMaxAngle() * steering, time);
}
// -----------------------------------------------------------------------------
// Get the total mass of the steering subsystem
// -----------------------------------------------------------------------------
double ChPitmanArmShafts::GetMass() const {
return getSteeringLinkMass() + getPitmanArmMass();
}
// -----------------------------------------------------------------------------
// Get the current COM location of the steering subsystem.
// -----------------------------------------------------------------------------
ChVector<> ChPitmanArmShafts::GetCOMPos() const {
ChVector<> com = getSteeringLinkMass() * m_link->GetPos() + getPitmanArmMass() * m_arm->GetPos();
return com / GetMass();
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChPitmanArmShafts::AddVisualizationAssets(VisualizationType vis) {
if (vis == VisualizationType::NONE)
return;
// Visualization for link
{
auto cyl = chrono_types::make_shared<ChCylinderShape>();
cyl->GetCylinderGeometry().p1 = m_pP;
cyl->GetCylinderGeometry().p2 = m_pI;
cyl->GetCylinderGeometry().rad = getSteeringLinkRadius();
m_link->AddAsset(cyl);
auto cyl_P = chrono_types::make_shared<ChCylinderShape>();
cyl_P->GetCylinderGeometry().p1 = m_pP;
cyl_P->GetCylinderGeometry().p2 = m_pTP;
cyl_P->GetCylinderGeometry().rad = getSteeringLinkRadius();
m_link->AddAsset(cyl_P);
auto cyl_I = chrono_types::make_shared<ChCylinderShape>();
cyl_I->GetCylinderGeometry().p1 = m_pI;
cyl_I->GetCylinderGeometry().p2 = m_pTI;
cyl_I->GetCylinderGeometry().rad = getSteeringLinkRadius();
m_link->AddAsset(cyl_I);
auto col = chrono_types::make_shared<ChColorAsset>();
col->SetColor(ChColor(0.2f, 0.7f, 0.7f));
m_link->AddAsset(col);
}
// Visualization for arm
{
auto cyl = chrono_types::make_shared<ChCylinderShape>();
cyl->GetCylinderGeometry().p1 = m_pC;
cyl->GetCylinderGeometry().p2 = m_pL;
cyl->GetCylinderGeometry().rad = getPitmanArmRadius();
m_arm->AddAsset(cyl);
auto col = chrono_types::make_shared<ChColorAsset>();
col->SetColor(ChColor(0.7f, 0.7f, 0.2f));
m_arm->AddAsset(col);
}
// Visualization for rev-sph link
m_revsph->AddAsset(chrono_types::make_shared<ChPointPointSegment>());
}
void ChPitmanArmShafts::RemoveVisualizationAssets() {
m_link->GetAssets().clear();
m_arm->GetAssets().clear();
m_revsph->GetAssets().clear();
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChPitmanArmShafts::LogConstraintViolations() {
// Revolute joint
{
ChVectorDynamic<> C = m_revolute->GetC();
GetLog() << "Revolute ";
GetLog() << " " << C(0) << " ";
GetLog() << " " << C(1) << " ";
GetLog() << " " << C(2) << " ";
GetLog() << " " << C(3) << " ";
GetLog() << " " << C(4) << "\n";
}
// Universal joint
{
ChVectorDynamic<> C = m_universal->GetC();
GetLog() << "Universal ";
GetLog() << " " << C(0) << " ";
GetLog() << " " << C(1) << " ";
GetLog() << " " << C(2) << " ";
GetLog() << " " << C(3) << "\n";
}
// Revolute-spherical joint
{
ChVectorDynamic<> C = m_revsph->GetC();
GetLog() << "Revolute-spherical ";
GetLog() << " " << C(0) << " ";
GetLog() << " " << C(1) << "\n";
}
//// TODO
//// Constraint violations for the various shaft couples
}
void ChPitmanArmShafts::GetShaftInformation(double time,
double& motor_input,
double& motor_input_der,
std::vector<double>& shaft_angles,
std::vector<double>& shaft_velocities,
std::vector<double>& constraint_violations,
ChVector<>& arm_angular_vel) const {
auto fun = std::static_pointer_cast<ChFunction_Setpoint>(m_shaft_motor->GetAngleFunction());
motor_input = fun->Get_y(time);
motor_input_der = fun->Get_y_dx(time);
shaft_angles.push_back(m_shaft_C->GetPos());
shaft_angles.push_back(m_shaft_C1->GetPos());
shaft_angles.push_back(m_shaft_A1->GetPos());
shaft_angles.push_back(m_shaft_A->GetPos());
shaft_velocities.push_back(m_shaft_C->GetPos_dt());
shaft_velocities.push_back(m_shaft_C1->GetPos_dt());
shaft_velocities.push_back(m_shaft_A1->GetPos_dt());
shaft_velocities.push_back(m_shaft_A->GetPos_dt());
constraint_violations.push_back(m_shaft_motor->GetConstraintViolation());
constraint_violations.push_back(m_shaft_gear->GetConstraintViolation());
if (m_rigid)
constraint_violations.push_back(m_rigid_connection->GetConstraintViolation());
arm_angular_vel = m_arm->GetWvel_loc();
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChPitmanArmShafts::ExportComponentList(rapidjson::Document& jsonDocument) const {
ChPart::ExportComponentList(jsonDocument);
std::vector<std::shared_ptr<ChBody>> bodies;
bodies.push_back(m_link);
bodies.push_back(m_arm);
ChPart::ExportBodyList(jsonDocument, bodies);
std::vector<std::shared_ptr<ChShaft>> shafts;
shafts.push_back(m_shaft_C);
shafts.push_back(m_shaft_C1);
shafts.push_back(m_shaft_A1);
shafts.push_back(m_shaft_A);
ChPart::ExportShaftList(jsonDocument, shafts);
std::vector<std::shared_ptr<ChLink>> joints;
joints.push_back(m_revolute);
joints.push_back(m_revsph);
joints.push_back(m_universal);
ChPart::ExportJointList(jsonDocument, joints);
std::vector<std::shared_ptr<ChShaftsCouple>> couples;
couples.push_back(m_shaft_motor);
couples.push_back(m_shaft_gear);
if (m_rigid)
couples.push_back(m_rigid_connection);
else
couples.push_back(m_spring_connection);
ChPart::ExportCouplesList(jsonDocument, couples);
}
void ChPitmanArmShafts::Output(ChVehicleOutput& database) const {
if (!m_output)
return;
std::vector<std::shared_ptr<ChBody>> bodies;
bodies.push_back(m_link);
bodies.push_back(m_arm);
database.WriteBodies(bodies);
std::vector<std::shared_ptr<ChShaft>> shafts;
shafts.push_back(m_shaft_C);
shafts.push_back(m_shaft_C1);
shafts.push_back(m_shaft_A1);
shafts.push_back(m_shaft_A);
database.WriteShafts(shafts);
std::vector<std::shared_ptr<ChLink>> joints;
joints.push_back(m_revolute);
joints.push_back(m_revsph);
joints.push_back(m_universal);
database.WriteJoints(joints);
std::vector<std::shared_ptr<ChShaftsCouple>> couples;
couples.push_back(m_shaft_motor);
couples.push_back(m_shaft_gear);
if (m_rigid)
couples.push_back(m_rigid_connection);
else
couples.push_back(m_spring_connection);
database.WriteCouples(couples);
}
} // end namespace vehicle
} // end namespace chrono
| 41.022523 | 120 | 0.613649 | iicfcii |
b4779ddd9029d12265fc09f22624ba8f8205dc2a | 4,471 | cpp | C++ | src/thread/future.cpp | Revolution-Populi/fc | 02b7593a96b02d9966358c59d22f344d86fa9a19 | [
"BSL-1.0",
"Apache-2.0",
"Zlib"
] | 37 | 2017-02-04T09:42:48.000Z | 2021-02-17T14:59:15.000Z | src/thread/future.cpp | Revolution-Populi/fc | 02b7593a96b02d9966358c59d22f344d86fa9a19 | [
"BSL-1.0",
"Apache-2.0",
"Zlib"
] | 120 | 2017-11-09T19:46:40.000Z | 2022-01-20T18:26:23.000Z | src/thread/future.cpp | Revolution-Populi/fc | 02b7593a96b02d9966358c59d22f344d86fa9a19 | [
"BSL-1.0",
"Apache-2.0",
"Zlib"
] | 109 | 2017-01-16T14:24:31.000Z | 2022-03-18T21:10:07.000Z | #include <fc/thread/future.hpp>
#include <fc/thread/spin_yield_lock.hpp>
#include <fc/thread/thread.hpp>
#include <fc/thread/unique_lock.hpp>
#include <fc/exception/exception.hpp>
#include <boost/assert.hpp>
namespace fc {
promise_base::promise_base( const char* desc )
:_ready(false),
_blocked_thread(nullptr),
_blocked_fiber_count(0),
_timeout(time_point::maximum()),
_canceled(false),
#ifndef NDEBUG
_cancellation_reason(nullptr),
#endif
_desc(desc),
_compl(nullptr)
{ }
promise_base::~promise_base() { }
const char* promise_base::get_desc()const{
return _desc;
}
void promise_base::cancel(const char* reason /* = nullptr */){
// wlog("${desc} canceled!", ("desc", _desc? _desc : ""));
_canceled = true;
#ifndef NDEBUG
_cancellation_reason = reason;
#endif
}
bool promise_base::ready()const {
return _ready.load();
}
bool promise_base::error()const {
return std::atomic_load( &_exceptp ) != nullptr;
}
void promise_base::set_exception( const fc::exception_ptr& e ){
std::atomic_store( &_exceptp, e );
_set_value(nullptr);
}
void promise_base::_wait( const microseconds& timeout_us ){
if( timeout_us == microseconds::maximum() )
_wait_until( time_point::maximum() );
else
_wait_until( time_point::now() + timeout_us );
}
void promise_base::_wait_until( const time_point& timeout_us ){
if( _ready.load() ) {
fc::exception_ptr ex = std::atomic_load( &_exceptp );
if( ex )
ex->dynamic_rethrow_exception();
return;
}
_enqueue_thread();
// Need to check _ready again to avoid a race condition.
if( _ready.load() )
{
_dequeue_thread();
return _wait_until( timeout_us ); // this will simply return or throw _exceptp
}
std::exception_ptr e;
//
// Create shared_ptr to take ownership of this; i.e. this will
// be deleted when p_this goes out of scope. Consequently,
// it would be Very Bad to let p_this go out of scope
// before we're done reading/writing instance variables!
// See https://github.com/cryptonomex/graphene/issues/597
//
ptr p_this = shared_from_this();
try
{
//
// We clone p_this here because the wait_until() API requires us
// to use std::move(). I.e. wait_until() takes ownership of any
// pointer passed to it. Since we want to keep ownership ourselves,
// we need to have two shared_ptr's to this:
//
// - p_this to keep this alive until the end of the current function
// - p_this2 to be owned by wait_until() as the wait_until() API requires
//
ptr p_this2 = p_this;
thread::current().wait_until( std::move( p_this2 ), timeout_us );
}
catch (...) { e = std::current_exception(); }
_dequeue_thread();
if( e ) std::rethrow_exception(e);
if( _ready.load() ) return _wait_until( timeout_us ); // this will simply return or throw _exceptp
FC_THROW_EXCEPTION( timeout_exception, "" );
}
void promise_base::_enqueue_thread(){
_blocked_fiber_count.fetch_add( 1 );
thread* blocked_thread = _blocked_thread.load();
// only one thread can wait on a promise at any given time
do
assert( !blocked_thread || blocked_thread == &thread::current() );
while( !_blocked_thread.compare_exchange_weak( blocked_thread, &thread::current() ) );
}
void promise_base::_dequeue_thread(){
if( _blocked_fiber_count.fetch_add( -1 ) == 1 )
_blocked_thread.store( nullptr );
}
void promise_base::_notify(){
// copy _blocked_thread into a local so that if the thread unblocks (e.g.,
// because of a timeout) before we get a chance to notify it, we won't be
// calling notify on a null pointer
thread* blocked_thread = _blocked_thread.load();
if( blocked_thread )
blocked_thread->notify( shared_from_this() );
}
void promise_base::_set_value(const void* s){
bool ready = false;
if( !_ready.compare_exchange_strong( ready, true ) ) //don't allow promise to be set more than once
return;
_notify();
auto* hdl = _compl.load();
if( nullptr != hdl )
hdl->on_complete( s, std::atomic_load( &_exceptp ) );
}
void promise_base::_on_complete( detail::completion_handler* c ) {
auto* hdl = _compl.load();
while( !_compl.compare_exchange_weak( hdl, c ) );
delete hdl;
}
}
| 31.70922 | 104 | 0.648624 | Revolution-Populi |
b478a32fa0cc4b7194bfd6bb6c8e483ec3aafabd | 4,303 | cc | C++ | tensorflow/core/tpu/kernels/tpu_compilation_cache_grpc.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 190,993 | 2015-11-09T13:17:30.000Z | 2022-03-31T23:05:27.000Z | tensorflow/core/tpu/kernels/tpu_compilation_cache_grpc.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 48,461 | 2015-11-09T14:21:11.000Z | 2022-03-31T23:17:33.000Z | tensorflow/core/tpu/kernels/tpu_compilation_cache_grpc.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 104,981 | 2015-11-09T13:40:17.000Z | 2022-03-31T19:51:54.000Z | /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/core/tpu/kernels/tpu_compilation_cache_grpc.h"
#include <functional>
#include "grpcpp/impl/codegen/async_stream.h"
#include "grpcpp/impl/codegen/async_unary_call.h"
#include "grpcpp/impl/codegen/channel_interface.h"
#include "grpcpp/impl/codegen/client_callback.h"
#include "grpcpp/impl/codegen/client_unary_call.h"
#include "grpcpp/impl/codegen/method_handler.h"
#include "grpcpp/impl/codegen/rpc_service_method.h"
#include "grpcpp/impl/codegen/server_callback.h"
#include "grpcpp/impl/codegen/service_type.h"
#include "grpcpp/impl/codegen/sync_stream.h"
namespace tensorflow {
namespace tpu {
static const char* grpcTpuCompilationCacheService_method_names[] = {
#if defined(LIBTPU_ON_GCE)
"/tensorflow.tpu.TpuCompilationCacheServiceExternal/GetTpuProgram",
#else // LIBTPU_ON_GCE
"/tensorflow.tpu.TpuCompilationCacheService/GetTpuProgram",
#endif // LIBTPU_ON_GCE
};
std::unique_ptr<grpc::TpuCompilationCacheService::Stub>
grpc::TpuCompilationCacheService::NewStub(
const std::shared_ptr< ::grpc::ChannelInterface>& channel,
const ::grpc::StubOptions& options) {
(void)options;
std::unique_ptr<grpc::TpuCompilationCacheService::Stub> stub(
new grpc::TpuCompilationCacheService::Stub(channel));
return stub;
}
grpc::TpuCompilationCacheService::Stub::Stub(
const std::shared_ptr< ::grpc::ChannelInterface>& channel)
: channel_(channel),
rpcmethod_get_tpu_program_(grpcTpuCompilationCacheService_method_names[0],
::grpc::internal::RpcMethod::NORMAL_RPC,
channel) {}
::grpc::Status grpc::TpuCompilationCacheService::Stub::GetTpuProgram(
::grpc::ClientContext* context, const RequestType& request,
ResponseType* response) {
return ::grpc::internal::BlockingUnaryCall(
channel_.get(), rpcmethod_get_tpu_program_, context, request, response);
}
::grpc::ClientAsyncResponseReader<
grpc::TpuCompilationCacheService::ResponseType>*
grpc::TpuCompilationCacheService::Stub::AsyncGetTpuProgramRaw(
::grpc::ClientContext* context, const RequestType& request,
::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory<
ResponseType>::Create(channel_.get(), cq, rpcmethod_get_tpu_program_,
context, request, true);
}
::grpc::ClientAsyncResponseReader<
grpc::TpuCompilationCacheService::ResponseType>*
grpc::TpuCompilationCacheService::Stub::PrepareAsyncGetTpuProgramRaw(
::grpc::ClientContext* context, const RequestType& request,
::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory<
ResponseType>::Create(channel_.get(), cq, rpcmethod_get_tpu_program_,
context, request, false);
}
grpc::TpuCompilationCacheService::Service::Service() {
AddMethod(new ::grpc::internal::RpcServiceMethod(
grpcTpuCompilationCacheService_method_names[0],
::grpc::internal::RpcMethod::NORMAL_RPC,
new ::grpc::internal::RpcMethodHandler<
grpc::TpuCompilationCacheService::Service, RequestType, ResponseType>(
std::mem_fn(
&grpc::TpuCompilationCacheService::Service::GetTpuProgram),
this)));
}
grpc::TpuCompilationCacheService::Service::~Service() {}
::grpc::Status grpc::TpuCompilationCacheService::Service::GetTpuProgram(
::grpc::ServerContext* context, const RequestType* request,
ResponseType* response) {
(void)context;
(void)request;
(void)response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
} // namespace tpu
} // namespace tensorflow
| 39.477064 | 80 | 0.727399 | EricRemmerswaal |
b479366a4228473f59ee4370175d5a1c46c4071e | 11,738 | cpp | C++ | src/qt/qtwebkit/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp | viewdy/phantomjs | eddb0db1d253fd0c546060a4555554c8ee08c13c | [
"BSD-3-Clause"
] | 1 | 2015-05-27T13:52:20.000Z | 2015-05-27T13:52:20.000Z | src/qt/qtwebkit/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp | mrampersad/phantomjs | dca6f77a36699eb4e1c46f7600cca618f01b0ac3 | [
"BSD-3-Clause"
] | null | null | null | src/qt/qtwebkit/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp | mrampersad/phantomjs | dca6f77a36699eb4e1c46f7600cca618f01b0ac3 | [
"BSD-3-Clause"
] | 1 | 2017-03-19T13:03:23.000Z | 2017-03-19T13:03:23.000Z | /*
* Copyright (C) 2011 Igalia S.L.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "WebKitTestServer.h"
#include "WebViewTest.h"
#include <gtk/gtk.h>
#include <libsoup/soup.h>
#include <string.h>
#include <webkit2/webkit2.h>
// Back forward list limit is 100 by default.
static const int kBackForwardListLimit = 100;
static WebKitTestServer* kServer;
static void serverCallback(SoupServer* server, SoupMessage* msg, const char* path, GHashTable* query, SoupClientContext* context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
if (g_str_has_suffix(path, "favicon.ico")) {
soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND);
return;
}
soup_message_set_status(msg, SOUP_STATUS_OK);
char* body = g_strdup_printf("<html><title>%s</title><body>%s</body></html>", path + 1, path + 1);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, body, strlen(body));
soup_message_body_complete(msg->response_body);
}
class BackForwardListTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(BackForwardListTest);
enum {
Backward,
Forward
};
enum {
CurrentItem = 1 << 0,
AddedItem = 1 << 1,
RemovedItems = 1 << 2
};
static void checkItem(WebKitBackForwardListItem* item, const char* title, const char* uri, const char* originalURI)
{
g_assert(item);
g_assert_cmpstr(webkit_back_forward_list_item_get_uri(item), ==, uri);
g_assert_cmpstr(webkit_back_forward_list_item_get_title(item), == , title);
g_assert_cmpstr(webkit_back_forward_list_item_get_original_uri(item), ==, originalURI);
}
static void checkItemIndex(WebKitBackForwardList* list)
{
g_assert(webkit_back_forward_list_get_nth_item(list, -1) == webkit_back_forward_list_get_back_item(list));
g_assert(webkit_back_forward_list_get_nth_item(list, 0) == webkit_back_forward_list_get_current_item(list));
g_assert(webkit_back_forward_list_get_nth_item(list, 1) == webkit_back_forward_list_get_forward_item(list));
}
static void checkList(WebKitBackForwardList* list, unsigned type, WebKitBackForwardListItem** items, unsigned nItems)
{
GList* listItems = type == BackForwardListTest::Backward ? webkit_back_forward_list_get_back_list(list) :
webkit_back_forward_list_get_forward_list(list);
g_assert(listItems);
unsigned i = 0;
for (GList* listItem = listItems; listItem; listItem = g_list_next(listItem), i++) {
g_assert_cmpuint(i, <, nItems);
g_assert(listItem->data == items[i]);
}
g_list_free(listItems);
}
static void backForwardListChanged(WebKitBackForwardList* list, WebKitBackForwardListItem* addedItem, GList* removedItems, BackForwardListTest* test)
{
test->m_hasChanged = true;
if (test->m_changedFlags & BackForwardListTest::AddedItem) {
g_assert(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(addedItem));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(addedItem));
} else
g_assert(!addedItem);
if (test->m_changedFlags & BackForwardListTest::RemovedItems) {
g_assert(removedItems);
for (GList* iter = removedItems; iter; iter = iter->next) {
g_assert(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(iter->data));
if (test->m_expectedRemovedItems)
g_assert(g_list_find(test->m_expectedRemovedItems, iter->data));
}
} else
g_assert(!removedItems);
}
BackForwardListTest()
: m_list(webkit_web_view_get_back_forward_list(m_webView))
, m_changedFlags(0)
, m_hasChanged(false)
, m_expectedRemovedItems(0)
{
g_signal_connect(m_list, "changed", G_CALLBACK(backForwardListChanged), this);
assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_list));
}
~BackForwardListTest()
{
g_signal_handlers_disconnect_matched(m_list, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
}
void waitUntilLoadFinished()
{
m_hasChanged = false;
WebViewTest::waitUntilLoadFinished();
g_assert(m_hasChanged);
}
void waitUntilLoadFinishedAndCheckRemovedItems(GList* removedItems)
{
m_expectedRemovedItems = removedItems;
waitUntilLoadFinished();
m_expectedRemovedItems = 0;
}
WebKitBackForwardList* m_list;
unsigned long m_changedFlags;
bool m_hasChanged;
GList* m_expectedRemovedItems;
};
static void testBackForwardListNavigation(BackForwardListTest* test, gconstpointer)
{
WebKitBackForwardListItem* items[1];
g_assert(!webkit_web_view_can_go_back(test->m_webView));
g_assert(!webkit_web_view_can_go_forward(test->m_webView));
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 0);
g_assert(!webkit_back_forward_list_get_current_item(test->m_list));
g_assert(!webkit_back_forward_list_get_back_item(test->m_list));
g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));
BackForwardListTest::checkItemIndex(test->m_list);
g_assert(!webkit_back_forward_list_get_back_list(test->m_list));
g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));
CString uriPage1 = kServer->getURIForPath("/Page1");
test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;
test->loadURI(uriPage1.data());
test->waitUntilLoadFinished();
g_assert(!webkit_web_view_can_go_back(test->m_webView));
g_assert(!webkit_web_view_can_go_forward(test->m_webView));
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 1);
WebKitBackForwardListItem* itemPage1 = webkit_back_forward_list_get_current_item(test->m_list);
BackForwardListTest::checkItem(itemPage1, "Page1", uriPage1.data(), uriPage1.data());
g_assert(!webkit_back_forward_list_get_back_item(test->m_list));
g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));
BackForwardListTest::checkItemIndex(test->m_list);
g_assert(!webkit_back_forward_list_get_back_list(test->m_list));
g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));
CString uriPage2 = kServer->getURIForPath("/Page2");
test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;
test->loadURI(uriPage2.data());
test->waitUntilLoadFinished();
g_assert(webkit_web_view_can_go_back(test->m_webView));
g_assert(!webkit_web_view_can_go_forward(test->m_webView));
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);
WebKitBackForwardListItem* itemPage2 = webkit_back_forward_list_get_current_item(test->m_list);
BackForwardListTest::checkItem(itemPage2, "Page2", uriPage2.data(), uriPage2.data());
g_assert(webkit_back_forward_list_get_back_item(test->m_list) == itemPage1);
g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));
BackForwardListTest::checkItemIndex(test->m_list);
items[0] = itemPage1;
BackForwardListTest::checkList(test->m_list, BackForwardListTest::Backward, items, 1);
g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));
test->m_changedFlags = BackForwardListTest::CurrentItem;
test->goBack();
test->waitUntilLoadFinished();
g_assert(!webkit_web_view_can_go_back(test->m_webView));
g_assert(webkit_web_view_can_go_forward(test->m_webView));
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);
g_assert(itemPage1 == webkit_back_forward_list_get_current_item(test->m_list));
BackForwardListTest::checkItem(webkit_back_forward_list_get_current_item(test->m_list), "Page1", uriPage1.data(), uriPage1.data());
g_assert(!webkit_back_forward_list_get_back_item(test->m_list));
g_assert(webkit_back_forward_list_get_forward_item(test->m_list) == itemPage2);
BackForwardListTest::checkItemIndex(test->m_list);
g_assert(!webkit_back_forward_list_get_back_list(test->m_list));
items[0] = itemPage2;
BackForwardListTest::checkList(test->m_list, BackForwardListTest::Forward, items, 1);
test->m_changedFlags = BackForwardListTest::CurrentItem;
test->goForward();
test->waitUntilLoadFinished();
g_assert(webkit_web_view_can_go_back(test->m_webView));
g_assert(!webkit_web_view_can_go_forward(test->m_webView));
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);
g_assert(itemPage2 == webkit_back_forward_list_get_current_item(test->m_list));
BackForwardListTest::checkItem(webkit_back_forward_list_get_current_item(test->m_list), "Page2", uriPage2.data(), uriPage2.data());
g_assert(webkit_back_forward_list_get_back_item(test->m_list) == itemPage1);
g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));
BackForwardListTest::checkItemIndex(test->m_list);
items[0] = itemPage1;
BackForwardListTest::checkList(test->m_list, BackForwardListTest::Backward, items, 1);
g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));
test->m_changedFlags = BackForwardListTest::CurrentItem;
test->goToBackForwardListItem(itemPage1);
test->waitUntilLoadFinished();
g_assert(itemPage1 == webkit_back_forward_list_get_current_item(test->m_list));
}
static void testBackForwardListLimitAndCache(BackForwardListTest* test, gconstpointer)
{
for (int i = 0; i < kBackForwardListLimit; i++) {
GOwnPtr<char> path(g_strdup_printf("/Page%d", i));
test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;
test->loadURI(kServer->getURIForPath(path.get()).data());
test->waitUntilLoadFinished();
}
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, kBackForwardListLimit);
WebKitBackForwardListItem* itemPageFirst = webkit_back_forward_list_get_nth_item(test->m_list, -(kBackForwardListLimit - 1));
GOwnPtr<GList> removedItems(g_list_prepend(0, itemPageFirst));
GOwnPtr<char> path(g_strdup_printf("/Page%d", kBackForwardListLimit));
test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem | BackForwardListTest::RemovedItems;
test->loadURI(kServer->getURIForPath(path.get()).data());
test->waitUntilLoadFinishedAndCheckRemovedItems(removedItems.get());
g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, kBackForwardListLimit);
}
void beforeAll()
{
kServer = new WebKitTestServer();
kServer->run(serverCallback);
BackForwardListTest::add("BackForwardList", "navigation", testBackForwardListNavigation);
BackForwardListTest::add("BackForwardList", "list-limit-and-cache", testBackForwardListLimitAndCache);
}
void afterAll()
{
delete kServer;
}
| 41.772242 | 153 | 0.737775 | viewdy |
b4795dae218444764446204b4ddddc7b50eb5c3c | 47,717 | cc | C++ | src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/add_command_request_test.cc | Sohei-Suzuki-Nexty/sdl_core | 68f082169e0a40fccd9eb0db3c83911c28870f07 | [
"BSD-3-Clause"
] | 5 | 2015-02-26T07:47:26.000Z | 2021-08-03T15:08:53.000Z | src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/add_command_request_test.cc | Sohei-Suzuki-Nexty/sdl_core | 68f082169e0a40fccd9eb0db3c83911c28870f07 | [
"BSD-3-Clause"
] | 73 | 2015-11-12T15:36:48.000Z | 2022-02-11T08:09:52.000Z | src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/add_command_request_test.cc | Sohei-Suzuki-Nexty/sdl_core | 68f082169e0a40fccd9eb0db3c83911c28870f07 | [
"BSD-3-Clause"
] | 8 | 2015-09-11T08:37:55.000Z | 2021-07-13T19:34:02.000Z | /*
* Copyright (c) 2018, Ford Motor Company
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of the Ford Motor Company nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdint.h>
#include <memory>
#include <set>
#include <string>
#include "mobile/add_command_request.h"
#include "gtest/gtest.h"
#include "utils/helpers.h"
#include "application_manager/commands/command_request_test.h"
#include "application_manager/event_engine/event.h"
#include "application_manager/mock_application.h"
#include "application_manager/mock_application_manager.h"
#include "application_manager/mock_help_prompt_manager.h"
#include "application_manager/mock_hmi_interface.h"
#include "application_manager/mock_message_helper.h"
#include "application_manager/mock_resume_ctrl.h"
#include "application_manager/resumption/resumption_data_processor.h"
#include "application_manager/smart_object_keys.h"
#include "smart_objects/smart_object.h"
#include "utils/custom_string.h"
namespace test {
namespace components {
namespace commands_test {
namespace mobile_commands_test {
namespace add_command_request {
namespace am = application_manager;
namespace am_test = application_manager_test;
using am::ApplicationManager;
using am::ApplicationSharedPtr;
using am::commands::CommandImpl;
using am::commands::MessageSharedPtr;
using am::event_engine::EventObserver;
using ns_smart_device_link::ns_smart_objects::SmartObjectSPtr;
using sdl_rpc_plugin::commands::AddCommandRequest;
using ::test::components::application_manager_test::MockApplication;
using ::testing::_;
using ::testing::InSequence;
using ::testing::Return;
using namespace smart_objects;
using app_mngr::commands::RequestFromMobileImpl;
namespace custom_str = utils::custom_string;
namespace strings = ::application_manager::strings;
namespace mobile_result = mobile_apis::Result;
namespace hmi_response = ::application_manager::hmi_response;
namespace hmi_request = ::application_manager::hmi_request;
using namespace strings;
namespace {
const hmi_apis::FunctionID::eType kInvalidFunctionId =
hmi_apis::FunctionID::INVALID_ENUM;
const uint32_t kAppId = 1u;
const uint32_t kCmdId = 1u;
const uint32_t kConnectionKey = 2u;
const std::string kMenuName = "LG";
const uint32_t kFirstParentId = 10u;
const uint32_t kSecondParentId = 1u;
const std::string kErroredVRCommand = "l\namer";
const std::string kFirstVrCommand = "lamer";
const std::string kSecondVrCommand = "hacker";
const uint32_t kFirstCommandId = 10u;
const uint32_t kSecondCommandId = 11u;
const int32_t kType = 34;
const int32_t kGrammarId = 12;
const int32_t kPosition = 10;
} // namespace
class AddCommandRequestTest
: public CommandRequestTest<CommandsTestMocks::kIsNice> {
public:
AddCommandRequestTest()
: msg_(CreateMessage())
, smart_obj_(smart_objects::SmartType_Null)
, default_app_name_("test_default_app_name_")
, lock_ptr_(std::make_shared<sync_primitives::Lock>())
, mock_help_prompt_manager_(
std::make_shared<am_test::MockHelpPromptManager>())
, mock_app_(CreateMockApp()) {
EXPECT_CALL(app_mngr_, application(kConnectionKey))
.WillRepeatedly(Return(mock_app_));
InitGetters();
InitBasicMessage();
}
protected:
void InitBasicMessage() {
(*msg_)[params][connection_key] = kConnectionKey;
(*msg_)[msg_params][app_id] = kAppId;
(*msg_)[msg_params][app_name] = default_app_name_;
}
void InitGetters() {
ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(smart_obj_));
}
void CreateBasicParamsUIRequest() {
SmartObject menu_params = SmartObject(SmartType_Map);
menu_params[position] = kPosition;
menu_params[menu_name] = kMenuName;
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[cmd_id] = kCmdId;
msg_params[strings::menu_params] = menu_params;
msg_params[cmd_icon] = 1;
msg_params[cmd_icon][value] = "10";
msg_params[info] = "UI info";
}
void CreateBasicParamsVRRequest() {
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[cmd_id] = kCmdId;
msg_params[vr_commands] = SmartObject(SmartType_Array);
msg_params[vr_commands][0] = kFirstVrCommand;
msg_params[type] = kPosition;
msg_params[grammar_id] = kGrammarId;
msg_params[info] = "VR info";
}
const am::CommandsMap CreateCommandsMap(SmartObject& first_command,
SmartObject& second_command) {
second_command[menu_params] = SmartObject(SmartType_Map);
second_command[menu_params][hmi_request::parent_id] = kFirstParentId;
second_command[menu_params][menu_name] = kMenuName;
second_command[vr_commands] = SmartObject(SmartType_Array);
second_command[vr_commands][0] = kSecondVrCommand;
am::CommandsMap commands_map;
commands_map.insert(std::make_pair(kFirstCommandId, &first_command));
commands_map.insert(std::make_pair(kSecondCommandId, &second_command));
return commands_map;
}
void CheckOnTimeOutCommandDeletion(
const hmi_apis::FunctionID::eType incoming_cmd,
const hmi_apis::FunctionID::eType cmd_to_delete) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
const am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject sub_menu(SmartType_Map);
EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
.WillOnce(Return(sub_menu));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
Event event(incoming_cmd);
event.set_smart_object(*msg_);
request_ptr->on_event(event);
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(cmd_to_delete), _))
.WillOnce(Return(true));
SmartObjectSPtr response = std::make_shared<SmartObject>(SmartType_Map);
(*response)[strings::msg_params][strings::info] = "info";
EXPECT_CALL(
mock_message_helper_,
CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
.WillOnce(Return(response));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(response,
am::commands::Command::CommandSource::SOURCE_SDL));
std::shared_ptr<RequestFromMobileImpl> base_class_request =
static_cast<std::shared_ptr<RequestFromMobileImpl> >(request_ptr);
base_class_request->OnTimeOut();
}
MessageSharedPtr msg_;
smart_objects::SmartObject smart_obj_;
const utils::custom_string::CustomString default_app_name_;
std::shared_ptr<sync_primitives::Lock> lock_ptr_;
std::shared_ptr<am_test::MockHelpPromptManager> mock_help_prompt_manager_;
MockAppPtr mock_app_;
};
TEST_F(AddCommandRequestTest, Run_AppNotExisted_EXPECT_AppNotRegistered) {
CreateBasicParamsUIRequest();
EXPECT_CALL(app_mngr_, application(kConnectionKey))
.WillOnce(Return(ApplicationSharedPtr()));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_result::APPLICATION_NOT_REGISTERED), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_ImageVerificationFailed_EXPECT_INVALID_DATA) {
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::INVALID_DATA));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_ImageVerificationFailed_EXPECT_WARNINGS) {
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::WARNINGS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_MenuNameHasSyntaxError_EXPECT_INVALID_DATA) {
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[menu_params][hmi_request::parent_id] = kFirstParentId;
const std::string errored_menu_name = "L\nG";
msg_params[menu_params][menu_name] = errored_menu_name;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject parent = SmartObject(SmartType_Map);
EXPECT_CALL(*mock_app_, FindSubMenu(kFirstParentId)).WillOnce(Return(parent));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest,
Run_VRCommandsHaveSyntaxError_EXPECT_INVALID_DATA) {
CreateBasicParamsVRRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[vr_commands][0] = kErroredVRCommand;
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_CMDIconHasError_EXPECT_INVALID_DATA) {
MessageSharedPtr msg = CreateMessage();
SmartObject& msg_params = (*msg)[strings::msg_params];
(*msg)[params][connection_key] = kConnectionKey;
msg_params[cmd_id] = kCmdId;
msg_params[cmd_icon] = 1;
const std::string errored_cmd_icon_value = "1\n0";
msg_params[cmd_icon][value] = errored_cmd_icon_value;
msg_params[vr_commands][0] = kFirstVrCommand;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_CommandIDAlreadyExists_EXPECT_INVALID_ID) {
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
SmartObject existing_cmd_so(smart_objects::SmartType_Map);
EXPECT_CALL(*mock_app_, FindCommand(kCmdId))
.WillOnce(Return(existing_cmd_so));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_CommandNameAlreadyExists_EXPECT_Forwarded) {
CreateBasicParamsUIRequest();
(*msg_)[msg_params][menu_name] = kMenuName;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
EXPECT_CALL(*mock_app_, AddCommand(_, (*msg_)[msg_params]));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest,
Run_CmdAndMsgParentIDsAreDifferentSubmenuNotExisted_EXPECT_INVALID_ID) {
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
const am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject invalid_command(SmartType_Null);
EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
.WillOnce(Return(invalid_command));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest,
Run_CmdAndMsgVrSynonymsAreTheSame_EXPECT_DUPLICATE_NAME) {
CreateBasicParamsVRRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
msg_params[vr_commands][0] = kSecondVrCommand;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
const am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject sub_menu(SmartType_Map);
EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
.WillOnce(Return(sub_menu));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, Run_MsgDataEmpty_EXPECT_INVALID_DATA) {
MessageSharedPtr msg = CreateMessage();
(*msg)[params][connection_key] = kConnectionKey;
SmartObject& msg_params = (*msg)[strings::msg_params];
msg_params[app_id] = kAppId;
msg_params[cmd_id] = kCmdId;
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest,
Run_CmdAndMsg_UI_and_Vr_AreCorrect_EXPECT_VR_AND_UI_SENT) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
SmartObject& image = msg_params[cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
const am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject sub_menu(SmartType_Map);
EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
.WillOnce(Return(sub_menu));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, GetRunMethods_SUCCESS) {
CreateBasicParamsUIRequest();
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
}
TEST_F(AddCommandRequestTest, OnEvent_UI_SUCCESS) {
CreateBasicParamsUIRequest();
(*msg_)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(
Return(DataAccessor<am::CommandsMap>(commands_map, lock_ptr_)));
Event event(hmi_apis::FunctionID::UI_AddCommand);
event.set_smart_object(*msg_);
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_app_, help_prompt_manager())
.WillOnce(ReturnRef(*mock_help_prompt_manager_));
EXPECT_CALL(*mock_help_prompt_manager_,
OnVrCommandAdded(kCmdId, (*msg_)[msg_params], false));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest, OnEvent_VR_SUCCESS) {
CreateBasicParamsVRRequest();
MessageSharedPtr msg = CreateMessage(SmartType_Map);
(*msg)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
(*msg)[msg_params][cmd_id] = kCmdId;
Event event(hmi_apis::FunctionID::VR_AddCommand);
event.set_smart_object(*msg);
EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params]));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(
Return(DataAccessor<am::CommandsMap>(commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_app_, help_prompt_manager())
.WillOnce(ReturnRef(*mock_help_prompt_manager_));
EXPECT_CALL(*mock_help_prompt_manager_,
OnVrCommandAdded(kCmdId, (*msg_)[msg_params], false));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_VR_DeleteCommand) {
CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::VR_AddCommand,
hmi_apis::FunctionID::VR_DeleteCommand);
}
TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_UI_DeleteCommand) {
CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::UI_AddCommand,
hmi_apis::FunctionID::UI_DeleteCommand);
}
TEST_F(AddCommandRequestTest, OnEvent_BothSend_SUCCESS) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::WARNINGS;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_app_, help_prompt_manager())
.WillOnce(ReturnRef(*mock_help_prompt_manager_));
EXPECT_CALL(*mock_help_prompt_manager_, OnVrCommandAdded(kCmdId, _, false));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
request_ptr->on_event(event_ui);
request_ptr->on_event(event_vr);
}
TEST_F(AddCommandRequestTest, OnEvent_UnknownEvent_UNSUCCESS) {
EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
Event event(hmi_apis::FunctionID::INVALID_ENUM);
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest, OnEvent_AppNotExisted_UNSUCCESS) {
CreateBasicParamsUIRequest();
EXPECT_CALL(app_mngr_, application(kConnectionKey))
.WillOnce(Return(ApplicationSharedPtr()));
Event event(hmi_apis::FunctionID::UI_AddCommand);
EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest,
OnEvent_HmiResponseCodeIsRejected_ExpectUICommandRemoved) {
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::REJECTED;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::REJECTED), _));
Event event(hmi_apis::FunctionID::UI_AddCommand);
event.set_smart_object(*msg_);
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest,
OnEvent_HmiResponseCodeIsWarnings_ExpectCommandUpdated) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::WARNINGS;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::WARNINGS), _));
EXPECT_CALL(*mock_app_, help_prompt_manager())
.WillOnce(ReturnRef(*mock_help_prompt_manager_));
EXPECT_CALL(*mock_help_prompt_manager_, OnVrCommandAdded(kCmdId, _, false));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
request_ptr->on_event(event_ui);
request_ptr->on_event(event_vr);
}
TEST_F(
AddCommandRequestTest,
OnEvent_UI_HmiResponseCodeIsGenericError_VR_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
request_ptr->on_event(event_ui);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
MessageSharedPtr msg_vr = CreateMessage(SmartType_Map);
(*msg_vr)[strings::params][hmi_response::code] =
hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
(*msg_vr)[msg_params][cmd_id] = kCmdId;
event_vr.set_smart_object(*msg_vr);
request_ptr->on_event(event_vr);
}
TEST_F(
AddCommandRequestTest,
OnEvent_VR_HmiResponseCodeIsGenericError_UI_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
request_ptr->on_event(event_vr);
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
MessageSharedPtr msg_ui = CreateMessage(SmartType_Map);
(*msg_ui)[strings::params][hmi_response::code] =
hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
(*msg_ui)[msg_params][cmd_id] = kCmdId;
event_ui.set_smart_object(*msg_ui);
request_ptr->on_event(event_ui);
}
TEST_F(
AddCommandRequestTest,
OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_UI_NotAvailableInterfaceState_ExpectCommandRemoved) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
.WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
request_ptr->on_event(event_ui);
request_ptr->on_event(event_vr);
}
TEST_F(
AddCommandRequestTest,
OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_VR_NotAvailableInterfaceState_ExpectCommandRemoved) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
.WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
request_ptr->on_event(event_ui);
request_ptr->on_event(event_vr);
}
TEST_F(
AddCommandRequestTest,
OnEvent_UI_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) {
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
Event event(hmi_apis::FunctionID::UI_AddCommand);
event.set_smart_object(*msg_);
request_ptr->on_event(event);
}
TEST_F(
AddCommandRequestTest,
OnEvent_VR_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) {
CreateBasicParamsVRRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
EXPECT_CALL(
mock_rpc_service_,
ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(mock_hmi_interfaces_,
GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
.WillRepeatedly(
Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
EXPECT_CALL(
mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _));
Event event(hmi_apis::FunctionID::VR_AddCommand);
event.set_smart_object(*msg_);
request_ptr->on_event(event);
}
TEST_F(AddCommandRequestTest,
OnEvent_UI_EventWithNotSuccesResponseCode_ExpectVRCommandDelete) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
MessageSharedPtr msg_ui = CreateMessage(SmartType_Map);
(*msg_ui)[strings::params][hmi_response::code] =
hmi_apis::Common_Result::ABORTED;
(*msg_ui)[msg_params][cmd_id] = kCmdId;
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_ui);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
event_vr.set_smart_object(*msg_);
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_DeleteCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2);
request_ptr->on_event(event_ui);
request_ptr->on_event(event_vr);
}
TEST_F(AddCommandRequestTest,
OnEvent_UI_VR_Events_VRErrorPresent_ExpectRemoveCommand) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& params = (*msg_)[strings::params];
params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS;
SmartObject& image = (*msg_)[msg_params][cmd_icon];
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
am::CommandsMap commands_map;
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _));
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
Event event_ui(hmi_apis::FunctionID::UI_AddCommand);
event_ui.set_smart_object(*msg_);
request_ptr->on_event(event_ui);
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_DeleteCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2);
Event event_vr(hmi_apis::FunctionID::VR_AddCommand);
MessageSharedPtr msg_vr = CreateMessage(SmartType_Map);
(*msg_vr)[strings::params][hmi_response::code] =
hmi_apis::Common_Result::ABORTED;
(*msg_vr)[msg_params][cmd_id] = kCmdId;
event_vr.set_smart_object(*msg_vr);
request_ptr->on_event(event_vr);
}
TEST_F(AddCommandRequestTest,
OnTimeOut_AppNotExisted_NoAppRemoveCommandCalled) {
CreateBasicParamsUIRequest();
EXPECT_CALL(app_mngr_, application(kConnectionKey))
.WillOnce(Return(ApplicationSharedPtr()));
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0);
SmartObjectSPtr response = std::make_shared<SmartObject>(SmartType_Map);
(*response)[strings::msg_params][strings::info] = "info";
EXPECT_CALL(
mock_message_helper_,
CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
.WillOnce(Return(response));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
response, am::commands::Command::CommandSource::SOURCE_SDL));
std::shared_ptr<RequestFromMobileImpl> base_class_request =
static_cast<std::shared_ptr<RequestFromMobileImpl> >(
CreateCommand<AddCommandRequest>(msg_));
base_class_request->OnTimeOut();
}
TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) {
CreateBasicParamsVRRequest();
CreateBasicParamsUIRequest();
SmartObject& msg_params = (*msg_)[strings::msg_params];
SmartObject& image = msg_params[cmd_icon];
msg_params[menu_params][hmi_request::parent_id] = kSecondParentId;
EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _))
.WillOnce(Return(mobile_apis::Result::SUCCESS));
EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(smart_obj_));
SmartObject first_command = SmartObject(SmartType_Map);
SmartObject second_command = SmartObject(SmartType_Map);
const am::CommandsMap commands_map =
CreateCommandsMap(first_command, second_command);
EXPECT_CALL(*mock_app_, commands_map())
.WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
commands_map, lock_ptr_)));
SmartObject sub_menu(SmartType_Map);
EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
.WillOnce(Return(sub_menu));
{
InSequence dummy;
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand), _))
.WillOnce(Return(true));
EXPECT_CALL(mock_rpc_service_,
ManageHMICommand(
HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand), _))
.WillOnce(Return(true));
}
EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
std::shared_ptr<AddCommandRequest> request_ptr =
CreateCommand<AddCommandRequest>(msg_);
request_ptr->Run();
EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId));
SmartObjectSPtr response = std::make_shared<SmartObject>(SmartType_Map);
(*response)[strings::msg_params][strings::info] = "info";
EXPECT_CALL(
mock_message_helper_,
CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR))
.WillOnce(Return(response));
EXPECT_CALL(mock_rpc_service_,
ManageMobileCommand(
response, am::commands::Command::CommandSource::SOURCE_SDL));
std::shared_ptr<RequestFromMobileImpl> base_class_request =
static_cast<std::shared_ptr<RequestFromMobileImpl> >(request_ptr);
base_class_request->OnTimeOut();
}
} // namespace add_command_request
} // namespace mobile_commands_test
} // namespace commands_test
} // namespace components
} // namespace test
| 40.472434 | 108 | 0.73959 | Sohei-Suzuki-Nexty |
b47bb4969bebca7039e05b3833d22c2b2052bddd | 10,276 | cc | C++ | src/lib/dns/tests/nsec3hash_unittest.cc | svenauhagen/kea | 8a575ad46dee1487364fad394e7a325337200839 | [
"Apache-2.0"
] | 273 | 2015-01-22T14:14:42.000Z | 2022-03-13T10:27:44.000Z | src/lib/dns/tests/nsec3hash_unittest.cc | jxiaobin/kea | 1987a50a458921f9e5ac84cb612782c07f3b601d | [
"Apache-2.0"
] | 104 | 2015-01-16T16:37:06.000Z | 2021-08-08T19:38:45.000Z | src/lib/dns/tests/nsec3hash_unittest.cc | jxiaobin/kea | 1987a50a458921f9e5ac84cb612782c07f3b601d | [
"Apache-2.0"
] | 133 | 2015-02-21T14:06:39.000Z | 2022-02-27T08:56:40.000Z | // Copyright (C) 2012-2015 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <config.h>
#include <string>
#include <gtest/gtest.h>
#include <boost/scoped_ptr.hpp>
#include <dns/nsec3hash.h>
#include <dns/labelsequence.h>
#include <dns/rdataclass.h>
#include <util/encode/hex.h>
using boost::scoped_ptr;
using namespace std;
using namespace isc::dns;
using namespace isc::dns::rdata;
using namespace isc::util;
using namespace isc::util::encode;
namespace {
typedef scoped_ptr<NSEC3Hash> NSEC3HashPtr;
// Commonly used NSEC3 suffix, defined to reduce the amount of typing
const char* const nsec3_common = "2T7B4G4VSA5SMI47K61MV5BV1A22BOJR A RRSIG";
class NSEC3HashTest : public ::testing::Test {
protected:
NSEC3HashTest() :
test_hash(NSEC3Hash::create(generic::NSEC3PARAM("1 0 12 aabbccdd"))),
test_hash_nsec3(NSEC3Hash::create(generic::NSEC3
("1 0 12 aabbccdd " +
string(nsec3_common))))
{
const uint8_t salt[] = {0xaa, 0xbb, 0xcc, 0xdd};
test_hash_args.reset(NSEC3Hash::create(1, 12, salt, sizeof(salt)));
}
~NSEC3HashTest() {
// Make sure we reset the hash creator to the default
setNSEC3HashCreator(NULL);
}
// An NSEC3Hash object commonly used in tests. Parameters are borrowed
// from the RFC5155 example. Construction of this object implicitly
// checks a successful case of the creation.
NSEC3HashPtr test_hash;
// Similar to test_hash, but created from NSEC3 RR.
NSEC3HashPtr test_hash_nsec3;
// Similar to test_hash, but created from passed args.
NSEC3HashPtr test_hash_args;
};
TEST_F(NSEC3HashTest, unknownAlgorithm) {
EXPECT_THROW(NSEC3HashPtr(
NSEC3Hash::create(
generic::NSEC3PARAM("2 0 12 aabbccdd"))),
UnknownNSEC3HashAlgorithm);
EXPECT_THROW(NSEC3HashPtr(
NSEC3Hash::create(
generic::NSEC3("2 0 12 aabbccdd " +
string(nsec3_common)))),
UnknownNSEC3HashAlgorithm);
const uint8_t salt[] = {0xaa, 0xbb, 0xcc, 0xdd};
EXPECT_THROW(NSEC3HashPtr(NSEC3Hash::create(2, 12, salt, sizeof(salt))),
UnknownNSEC3HashAlgorithm);
}
// Common checks for NSEC3 hash calculation
void
calculateCheck(NSEC3Hash& hash) {
// A couple of normal cases from the RFC5155 example.
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
hash.calculate(Name("example")));
EXPECT_EQ("35MTHGPGCU1QG68FAB165KLNSNK3DPVL",
hash.calculate(Name("a.example")));
// Check case-insensitiveness
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
hash.calculate(Name("EXAMPLE")));
// Repeat for the LabelSequence variant.
// A couple of normal cases from the RFC5155 example.
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
hash.calculate(LabelSequence(Name("example"))));
EXPECT_EQ("35MTHGPGCU1QG68FAB165KLNSNK3DPVL",
hash.calculate(LabelSequence(Name("a.example"))));
// Check case-insensitiveness
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
hash.calculate(LabelSequence(Name("EXAMPLE"))));
}
TEST_F(NSEC3HashTest, calculate) {
{
SCOPED_TRACE("calculate check with NSEC3PARAM based hash");
calculateCheck(*test_hash);
}
{
SCOPED_TRACE("calculate check with NSEC3 based hash");
calculateCheck(*test_hash_nsec3);
}
{
SCOPED_TRACE("calculate check with args based hash");
calculateCheck(*test_hash_args);
}
// Some boundary cases: 0-iteration and empty salt. Borrowed from the
// .com zone data.
EXPECT_EQ("CK0POJMG874LJREF7EFN8430QVIT8BSM",
NSEC3HashPtr(NSEC3Hash::create(generic::NSEC3PARAM("1 0 0 -")))
->calculate(Name("com")));
EXPECT_EQ("CK0POJMG874LJREF7EFN8430QVIT8BSM",
NSEC3HashPtr(NSEC3Hash::create(generic::NSEC3PARAM("1 0 0 -")))
->calculate(LabelSequence(Name("com"))));
// Using unusually large iterations, something larger than the 8-bit range.
// (expected hash value generated by BIND 9's dnssec-signzone)
EXPECT_EQ("COG6A52MJ96MNMV3QUCAGGCO0RHCC2Q3",
NSEC3HashPtr(NSEC3Hash::create(
generic::NSEC3PARAM("1 0 256 AABBCCDD")))
->calculate(LabelSequence(Name("example.org"))));
}
// Common checks for match cases
template <typename RDATAType>
void
matchCheck(NSEC3Hash& hash, const string& postfix) {
// If all parameters match, it's considered to be matched.
EXPECT_TRUE(hash.match(RDATAType("1 0 12 aabbccdd" + postfix)));
// Algorithm doesn't match
EXPECT_FALSE(hash.match(RDATAType("2 0 12 aabbccdd" + postfix)));
// Iterations doesn't match
EXPECT_FALSE(hash.match(RDATAType("1 0 1 aabbccdd" + postfix)));
// Salt doesn't match
EXPECT_FALSE(hash.match(RDATAType("1 0 12 aabbccde" + postfix)));
// Salt doesn't match: the other has an empty salt
EXPECT_FALSE(hash.match(RDATAType("1 0 12 -" + postfix)));
// Flags don't matter
EXPECT_TRUE(hash.match(RDATAType("1 1 12 aabbccdd" + postfix)));
}
TEST_F(NSEC3HashTest, matchWithNSEC3) {
{
SCOPED_TRACE("match NSEC3PARAM based hash against NSEC3 parameters");
matchCheck<generic::NSEC3>(*test_hash, " " + string(nsec3_common));
}
{
SCOPED_TRACE("match NSEC3 based hash against NSEC3 parameters");
matchCheck<generic::NSEC3>(*test_hash_nsec3,
" " + string(nsec3_common));
}
}
TEST_F(NSEC3HashTest, matchWithNSEC3PARAM) {
{
SCOPED_TRACE("match NSEC3PARAM based hash against NSEC3 parameters");
matchCheck<generic::NSEC3PARAM>(*test_hash, "");
}
{
SCOPED_TRACE("match NSEC3 based hash against NSEC3 parameters");
matchCheck<generic::NSEC3PARAM>(*test_hash_nsec3, "");
}
}
// A simple faked hash calculator and a dedicated creator for it.
class TestNSEC3Hash : public NSEC3Hash {
virtual string calculate(const Name&) const {
return ("00000000000000000000000000000000");
}
virtual string calculate(const LabelSequence&) const {
return ("00000000000000000000000000000000");
}
virtual bool match(const generic::NSEC3PARAM&) const {
return (true);
}
virtual bool match(const generic::NSEC3&) const {
return (true);
}
};
// This faked creator basically creates the faked calculator regardless of
// the passed NSEC3PARAM or NSEC3. But if the most significant bit of flags
// is set, it will behave like the default creator.
class TestNSEC3HashCreator : public NSEC3HashCreator {
public:
virtual NSEC3Hash* create(const generic::NSEC3PARAM& param) const {
if ((param.getFlags() & 0x80) != 0) {
return (default_creator_.create(param));
}
return (new TestNSEC3Hash);
}
virtual NSEC3Hash* create(const generic::NSEC3& nsec3) const {
if ((nsec3.getFlags() & 0x80) != 0) {
return (default_creator_.create(nsec3));
}
return (new TestNSEC3Hash);
}
virtual NSEC3Hash* create(uint8_t, uint16_t,
const uint8_t*, size_t) const {
isc_throw(isc::Unexpected,
"This method is not implemented here.");
}
private:
DefaultNSEC3HashCreator default_creator_;
};
TEST_F(NSEC3HashTest, setCreator) {
// Re-check an existing case using the default creator/hash implementation
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(Name("example")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(LabelSequence(Name("example"))));
// Replace the creator, and confirm the hash values are faked
TestNSEC3HashCreator test_creator;
setNSEC3HashCreator(&test_creator);
// Re-create the hash object with the new creator
test_hash.reset(NSEC3Hash::create(generic::NSEC3PARAM("1 0 12 aabbccdd")));
EXPECT_EQ("00000000000000000000000000000000",
test_hash->calculate(Name("example")));
EXPECT_EQ("00000000000000000000000000000000",
test_hash->calculate(LabelSequence(Name("example"))));
// Same for hash from NSEC3 RDATA
test_hash.reset(NSEC3Hash::create(generic::NSEC3
("1 0 12 aabbccdd " +
string(nsec3_common))));
EXPECT_EQ("00000000000000000000000000000000",
test_hash->calculate(Name("example")));
EXPECT_EQ("00000000000000000000000000000000",
test_hash->calculate(LabelSequence(Name("example"))));
// If we set a special flag big (0x80) on creation, it will act like the
// default creator.
test_hash.reset(NSEC3Hash::create(generic::NSEC3PARAM(
"1 128 12 aabbccdd")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(Name("example")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(LabelSequence(Name("example"))));
test_hash.reset(NSEC3Hash::create(generic::NSEC3
("1 128 12 aabbccdd " +
string(nsec3_common))));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(Name("example")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(LabelSequence(Name("example"))));
// Reset the creator to default, and confirm that
setNSEC3HashCreator(NULL);
test_hash.reset(NSEC3Hash::create(generic::NSEC3PARAM("1 0 12 aabbccdd")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(Name("example")));
EXPECT_EQ("0P9MHAVEQVM6T7VBL5LOP2U3T2RP3TOM",
test_hash->calculate(LabelSequence(Name("example"))));
}
} // end namespace
| 38.059259 | 79 | 0.649864 | svenauhagen |
b47d03c744f790f2be2d4b36804b0db8d951e0cd | 1,262 | cpp | C++ | trading_technologies/main.cpp | akhiltiwari13/phyllanthus_emblica | 7c7bb65270b94f13216ab2d8f25bad74f78c813d | [
"MIT"
] | null | null | null | trading_technologies/main.cpp | akhiltiwari13/phyllanthus_emblica | 7c7bb65270b94f13216ab2d8f25bad74f78c813d | [
"MIT"
] | null | null | null | trading_technologies/main.cpp | akhiltiwari13/phyllanthus_emblica | 7c7bb65270b94f13216ab2d8f25bad74f78c813d | [
"MIT"
] | null | null | null | #include <cstdint>
#include <stdexcept>
#include <iostream>
enum Side { NONE, LEFT, RIGHT };
class ChainLink
{
public:
void append(ChainLink* rightPart)
{
if (this->right != NULL)
throw std::logic_error("Link is already connected.");
this->right = rightPart;
rightPart->left = this;
}
Side longerSide()
{
/* throw std::logic_error("Waiting to be implemented"); */
auto cur = left;
uint32_t leftLen{0};
uint32_t rightLen{0};
while((cur != nullptr) && (cur != right)){
cur = cur->left;
++leftLen;
}
if(cur == right)
return Side::NONE;
// reset curr
cur = right;
while(cur != nullptr) {
cur = cur->right;
++rightLen;
}
if (rightLen == leftLen )
return Side::NONE;
return rightLen>leftLen? Side::RIGHT : Side::LEFT;
}
private:
ChainLink* left;
ChainLink* right;
};
#ifndef RunTests
int main()
{
ChainLink* left = new ChainLink();
ChainLink* middle = new ChainLink();
ChainLink* right = new ChainLink();
left->append(middle);
middle->append(right);
std::cout << left->longerSide();
}
#endif
| 21.033333 | 66 | 0.538827 | akhiltiwari13 |
b47f1a4bdafe07ec3dd893ab7c26441475ccc87b | 2,817 | cpp | C++ | discrete-maths/graph-planarity/a_graph_embedding.cpp | nothingelsematters/university | 5561969b1b11678228aaf7e6660e8b1a93d10294 | [
"WTFPL"
] | 1 | 2018-06-03T17:48:50.000Z | 2018-06-03T17:48:50.000Z | discrete-maths/graph-planarity/a_graph_embedding.cpp | nothingelsematters/University | b1e188cb59e5a436731b92c914494626a99e1ae0 | [
"WTFPL"
] | null | null | null | discrete-maths/graph-planarity/a_graph_embedding.cpp | nothingelsematters/University | b1e188cb59e5a436731b92c914494626a99e1ae0 | [
"WTFPL"
] | 14 | 2019-04-07T21:27:09.000Z | 2021-12-05T13:37:25.000Z | #include <iostream>
bool bipartition(std::pair<size_t, size_t>* edges, size_t* hamilton_cycle, bool* partition, size_t edges_size,
bool* visited, size_t current_index, bool first_part = true) {
if (visited[current_index]) {
return partition[current_index] == first_part;
}
visited[current_index] = true;
partition[current_index] = first_part;
auto current = edges[current_index];
std::pair<size_t, size_t> hamilton_current({hamilton_cycle[current.first], hamilton_cycle[current.second]});
for (size_t i = 0; i < edges_size; ++i) {
if (!((hamilton_current.first < hamilton_cycle[edges[i].first] &&
hamilton_cycle[edges[i].first] < hamilton_current.second &&
hamilton_current.second < hamilton_cycle[edges[i].second]) ||
(hamilton_current.first > hamilton_cycle[edges[i].first] &&
hamilton_cycle[edges[i].second] > hamilton_current.first &&
hamilton_current.second > hamilton_cycle[edges[i].second]))) {
continue;
}
if (!bipartition(edges, hamilton_cycle, partition, edges_size, visited, i, !first_part)) {
return false;
}
}
return true;
}
int main() {
size_t vertex_size;
size_t edges_size;
std::cin >> vertex_size >> edges_size;
std::pair<size_t, size_t>* edges = new std::pair<size_t, size_t>[edges_size];
size_t* hamilton_cycle = new size_t[vertex_size];
bool* partition = new bool[edges_size];
std::fill(partition, partition + edges_size, false);
for (size_t i = 0; i < edges_size; ++i) {
std::cin >> edges[i].first >> edges[i].second;
}
for (size_t i = 0; i < vertex_size; ++i) {
size_t vertex;
std::cin >> vertex;
hamilton_cycle[vertex - 1] = i;
}
for (size_t i = 0; i < edges_size; ++i) {
if (hamilton_cycle[--edges[i].first] > hamilton_cycle[--edges[i].second]) {
std::swap(edges[i].first, edges[i].second);
}
}
bool* visited = new bool[edges_size];
std::fill(visited, visited + edges_size, false);
for (size_t i = 0; i < edges_size; ++i) {
if (!visited[i] && !bipartition(edges, hamilton_cycle, partition, edges_size,
visited, i)) {
std::cout << "NO\n";
return 0;
}
}
std::cout << "YES\n";
for (size_t i = 0; i < vertex_size; ++i) {
std::cout << 2 * hamilton_cycle[i] << ' ' << 0 << ' ';
}
std::cout << '\n';
for (size_t i = 0; i < edges_size; ++i) {
size_t edge_begin = hamilton_cycle[edges[i].first];
size_t edge_end = hamilton_cycle[edges[i].second];
std::cout << edge_begin + edge_end << ' ' <<
(partition[i] ? 1 : -1) * abs(edge_begin - edge_end) << '\n';
}
}
| 35.2125 | 112 | 0.586084 | nothingelsematters |
b47fb2c62845996fb27441aaab474f3b6ed7726e | 2,778 | hpp | C++ | lib/src/Delphi/Syntax/Statements/DelphiRaiseStatementSyntax.hpp | henrikfroehling/polyglot | 955fb37c2f54ebbaf933c16bf9e0e4bcca8a4142 | [
"MIT"
] | null | null | null | lib/src/Delphi/Syntax/Statements/DelphiRaiseStatementSyntax.hpp | henrikfroehling/polyglot | 955fb37c2f54ebbaf933c16bf9e0e4bcca8a4142 | [
"MIT"
] | 50 | 2021-06-30T20:01:50.000Z | 2021-11-28T16:21:26.000Z | lib/src/Delphi/Syntax/Statements/DelphiRaiseStatementSyntax.hpp | henrikfroehling/polyglot | 955fb37c2f54ebbaf933c16bf9e0e4bcca8a4142 | [
"MIT"
] | null | null | null | #ifndef INTERLINCK_DELPHI_SYNTAX_STATEMENTS_DELPHIRAISESTATEMENTSYNTAX_H
#define INTERLINCK_DELPHI_SYNTAX_STATEMENTS_DELPHIRAISESTATEMENTSYNTAX_H
#include "interlinck/Core/Syntax/SyntaxVariant.hpp"
#include "interlinck/Core/Types.hpp"
#include "Core/Basic/Macros.hpp"
#include "Delphi/Syntax/Statements/DelphiStatementSyntax.hpp"
namespace interlinck::Core::Support
{
class SyntaxFactory;
} // end namespace interlinck::Core::Support
namespace interlinck::Core::Syntax
{
class ISyntaxToken;
} // end namespace interlinck::Core::Syntax
namespace interlinck::Delphi::Syntax
{
class DelphiExpressionSyntax;
class DelphiRaiseStatementSyntax : public DelphiStatementSyntax
{
public:
explicit DelphiRaiseStatementSyntax(const Core::Syntax::ISyntaxToken* raiseKeyword,
const Core::Syntax::ISyntaxToken* semiColonToken,
const DelphiExpressionSyntax* expression = nullptr) noexcept;
~DelphiRaiseStatementSyntax() noexcept override = default;
inline const Core::Syntax::ISyntaxToken* raiseKeyword() const noexcept { return _raiseKeyword; }
inline const DelphiExpressionSyntax* expression() const noexcept { return _expression; }
inline const Core::Syntax::ISyntaxToken* semiColonToken() const noexcept { return _semiColonToken; }
inline il_size childCount() const noexcept final { return _expression != nullptr ? 3 : 2; }
Core::Syntax::SyntaxVariant child(il_size index) const noexcept final;
inline Core::Syntax::SyntaxVariant first() const noexcept final { return Core::Syntax::SyntaxVariant::asToken(_raiseKeyword); }
inline Core::Syntax::SyntaxVariant last() const noexcept final { return Core::Syntax::SyntaxVariant::asToken(_semiColonToken); }
inline il_string typeName() const noexcept override { CREATE_TYPENAME(DelphiRaiseStatementSyntax) }
inline bool isRaiseStatement() const noexcept final { return true; }
static const DelphiRaiseStatementSyntax* create(Core::Support::SyntaxFactory& syntaxFactory,
const Core::Syntax::ISyntaxToken* raiseKeyword,
const Core::Syntax::ISyntaxToken* semiColonToken,
const DelphiExpressionSyntax* expression = nullptr) noexcept;
private:
const Core::Syntax::ISyntaxToken* _raiseKeyword;
const Core::Syntax::ISyntaxToken* _semiColonToken;
// might be optional; for example in an exception block
//
// except
// raise; <-- re-raises the exception
const DelphiExpressionSyntax* _expression;
};
} // end namespace interlinck::Delphi::Syntax
#endif // INTERLINCK_DELPHI_SYNTAX_STATEMENTS_DELPHIRAISESTATEMENTSYNTAX_H
| 40.26087 | 132 | 0.719942 | henrikfroehling |
b480038da169d5118a8875c3d30acadae6284878 | 184 | cpp | C++ | documents/Buffer Overflow/main.cpp | sspony/oop244 | 4fdf8abf58f52b0c083eb6dad65ad4dfcdd4397a | [
"MIT"
] | null | null | null | documents/Buffer Overflow/main.cpp | sspony/oop244 | 4fdf8abf58f52b0c083eb6dad65ad4dfcdd4397a | [
"MIT"
] | null | null | null | documents/Buffer Overflow/main.cpp | sspony/oop244 | 4fdf8abf58f52b0c083eb6dad65ad4dfcdd4397a | [
"MIT"
] | null | null | null | #include <iostream>
#include "Foo.h"
using namespace std;
int main (void)
{
Foo theFoo;
cout << theFoo;
theFoo.SetMsg("Hello World");
cout << theFoo;
return 0;
}
| 12.266667 | 31 | 0.608696 | sspony |
b4801650e7f5e418935965cd92a24ec95a2af019 | 14,374 | cpp | C++ | src/meta/MetaServiceHandler.cpp | Sasasu/nebula | 78ac8edb396162da3d01e4cb485a2ae789a6d633 | [
"Apache-2.0"
] | 1 | 2020-04-10T06:34:24.000Z | 2020-04-10T06:34:24.000Z | src/meta/MetaServiceHandler.cpp | Sasasu/nebula | 78ac8edb396162da3d01e4cb485a2ae789a6d633 | [
"Apache-2.0"
] | null | null | null | src/meta/MetaServiceHandler.cpp | Sasasu/nebula | 78ac8edb396162da3d01e4cb485a2ae789a6d633 | [
"Apache-2.0"
] | 1 | 2020-03-25T10:17:26.000Z | 2020-03-25T10:17:26.000Z | /* Copyright (c) 2018 vesoft inc. All rights reserved.
*
* This source code is licensed under Apache 2.0 License,
* attached with Common Clause Condition 1.0, found in the LICENSES directory.
*/
#include "meta/MetaServiceUtils.h"
#include "meta/MetaServiceHandler.h"
#include "meta/processors/partsMan/CreateSpaceProcessor.h"
#include "meta/processors/partsMan/DropSpaceProcessor.h"
#include "meta/processors/partsMan/ListSpacesProcessor.h"
#include "meta/processors/partsMan/GetSpaceProcessor.h"
#include "meta/processors/partsMan/ListHostsProcessor.h"
#include "meta/processors/partsMan/ListPartsProcessor.h"
#include "meta/processors/partsMan/GetPartsAllocProcessor.h"
#include "meta/processors/schemaMan/CreateTagProcessor.h"
#include "meta/processors/schemaMan/AlterTagProcessor.h"
#include "meta/processors/schemaMan/DropTagProcessor.h"
#include "meta/processors/schemaMan/GetTagProcessor.h"
#include "meta/processors/schemaMan/ListTagsProcessor.h"
#include "meta/processors/schemaMan/CreateEdgeProcessor.h"
#include "meta/processors/schemaMan/AlterEdgeProcessor.h"
#include "meta/processors/schemaMan/DropEdgeProcessor.h"
#include "meta/processors/schemaMan/GetEdgeProcessor.h"
#include "meta/processors/schemaMan/ListEdgesProcessor.h"
#include "meta/processors/indexMan/CreateTagIndexProcessor.h"
#include "meta/processors/indexMan/DropTagIndexProcessor.h"
#include "meta/processors/indexMan/GetTagIndexProcessor.h"
#include "meta/processors/indexMan/ListTagIndexesProcessor.h"
#include "meta/processors/indexMan/RebuildTagIndexProcessor.h"
#include "meta/processors/indexMan/ListTagIndexStatusProcessor.h"
#include "meta/processors/indexMan/CreateEdgeIndexProcessor.h"
#include "meta/processors/indexMan/DropEdgeIndexProcessor.h"
#include "meta/processors/indexMan/GetEdgeIndexProcessor.h"
#include "meta/processors/indexMan/ListEdgeIndexesProcessor.h"
#include "meta/processors/indexMan/RebuildEdgeIndexProcessor.h"
#include "meta/processors/indexMan/ListEdgeIndexStatusProcessor.h"
#include "meta/processors/customKV/MultiPutProcessor.h"
#include "meta/processors/customKV/GetProcessor.h"
#include "meta/processors/customKV/MultiGetProcessor.h"
#include "meta/processors/customKV/ScanProcessor.h"
#include "meta/processors/customKV/RemoveProcessor.h"
#include "meta/processors/customKV/RemoveRangeProcessor.h"
#include "meta/processors/admin/HBProcessor.h"
#include "meta/processors/usersMan/AuthenticationProcessor.h"
#include "meta/processors/admin/BalanceProcessor.h"
#include "meta/processors/admin/LeaderBalanceProcessor.h"
#include "meta/processors/admin/CreateSnapshotProcessor.h"
#include "meta/processors/admin/DropSnapshotProcessor.h"
#include "meta/processors/admin/ListSnapshotsProcessor.h"
#include "meta/processors/configMan/RegConfigProcessor.h"
#include "meta/processors/configMan/GetConfigProcessor.h"
#include "meta/processors/configMan/SetConfigProcessor.h"
#include "meta/processors/configMan/ListConfigsProcessor.h"
#include "meta/processors/jobMan/AdminJobProcessor.h"
#define RETURN_FUTURE(processor) \
auto f = processor->getFuture(); \
processor->process(req); \
return f;
namespace nebula {
namespace meta {
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createSpace(const cpp2::CreateSpaceReq& req) {
auto* processor = CreateSpaceProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropSpace(const cpp2::DropSpaceReq& req) {
auto* processor = DropSpaceProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListSpacesResp>
MetaServiceHandler::future_listSpaces(const cpp2::ListSpacesReq& req) {
auto* processor = ListSpacesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::AdminJobResp>
MetaServiceHandler::future_runAdminJob(const cpp2::AdminJobReq& req) {
auto* processor = AdminJobProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetSpaceResp>
MetaServiceHandler::future_getSpace(const cpp2::GetSpaceReq& req) {
auto* processor = GetSpaceProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListHostsResp>
MetaServiceHandler::future_listHosts(const cpp2::ListHostsReq& req) {
auto* processor = ListHostsProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListPartsResp>
MetaServiceHandler::future_listParts(const cpp2::ListPartsReq& req) {
auto* processor = ListPartsProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetPartsAllocResp>
MetaServiceHandler::future_getPartsAlloc(const cpp2::GetPartsAllocReq& req) {
auto* processor = GetPartsAllocProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_multiPut(const cpp2::MultiPutReq& req) {
auto* processor = MultiPutProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetResp>
MetaServiceHandler::future_get(const cpp2::GetReq& req) {
auto* processor = GetProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::MultiGetResp>
MetaServiceHandler::future_multiGet(const cpp2::MultiGetReq& req) {
auto* processor = MultiGetProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ScanResp>
MetaServiceHandler::future_scan(const cpp2::ScanReq& req) {
auto* processor = ScanProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_remove(const cpp2::RemoveReq& req) {
auto* processor = RemoveProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_removeRange(const cpp2::RemoveRangeReq& req) {
auto* processor = RemoveRangeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createTag(const cpp2::CreateTagReq& req) {
auto* processor = CreateTagProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_alterTag(const cpp2::AlterTagReq& req) {
auto* processor = AlterTagProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropTag(const cpp2::DropTagReq& req) {
auto* processor = DropTagProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetTagResp>
MetaServiceHandler::future_getTag(const cpp2::GetTagReq &req) {
auto* processor = GetTagProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListTagsResp>
MetaServiceHandler::future_listTags(const cpp2::ListTagsReq& req) {
auto* processor = ListTagsProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createEdge(const cpp2::CreateEdgeReq& req) {
auto* processor = CreateEdgeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_alterEdge(const cpp2::AlterEdgeReq& req) {
auto* processor = AlterEdgeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropEdge(const cpp2::DropEdgeReq& req) {
auto* processor = DropEdgeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetEdgeResp>
MetaServiceHandler::future_getEdge(const cpp2::GetEdgeReq& req) {
auto* processor = GetEdgeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListEdgesResp>
MetaServiceHandler::future_listEdges(const cpp2::ListEdgesReq& req) {
auto* processor = ListEdgesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createTagIndex(const cpp2::CreateTagIndexReq& req) {
auto* processor = CreateTagIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropTagIndex(const cpp2::DropTagIndexReq& req) {
auto* processor = DropTagIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetTagIndexResp>
MetaServiceHandler::future_getTagIndex(const cpp2::GetTagIndexReq &req) {
auto* processor = GetTagIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListTagIndexesResp>
MetaServiceHandler::future_listTagIndexes(const cpp2::ListTagIndexesReq& req) {
auto* processor = ListTagIndexesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_rebuildTagIndex(const cpp2::RebuildIndexReq& req) {
auto* processor = RebuildTagIndexProcessor::instance(kvstore_, adminClient_.get());
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListIndexStatusResp>
MetaServiceHandler::future_listTagIndexStatus(const cpp2::ListIndexStatusReq& req) {
auto* processor = ListTagIndexStatusProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createEdgeIndex(const cpp2::CreateEdgeIndexReq& req) {
auto* processor = CreateEdgeIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropEdgeIndex(const cpp2::DropEdgeIndexReq& req) {
auto* processor = DropEdgeIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetEdgeIndexResp>
MetaServiceHandler::future_getEdgeIndex(const cpp2::GetEdgeIndexReq& req) {
auto* processor = GetEdgeIndexProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListEdgeIndexesResp>
MetaServiceHandler::future_listEdgeIndexes(const cpp2::ListEdgeIndexesReq& req) {
auto* processor = ListEdgeIndexesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_rebuildEdgeIndex(const cpp2::RebuildIndexReq& req) {
auto* processor = RebuildEdgeIndexProcessor::instance(kvstore_, adminClient_.get());
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListIndexStatusResp>
MetaServiceHandler::future_listEdgeIndexStatus(const cpp2::ListIndexStatusReq& req) {
auto* processor = ListEdgeIndexStatusProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::HBResp>
MetaServiceHandler::future_heartBeat(const cpp2::HBReq& req) {
auto* processor = HBProcessor::instance(kvstore_, clusterId_, &heartBeatStat_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createUser(const cpp2::CreateUserReq& req) {
auto* processor = CreateUserProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropUser(const cpp2::DropUserReq& req) {
auto* processor = DropUserProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_alterUser(const cpp2::AlterUserReq& req) {
auto* processor = AlterUserProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_grantRole(const cpp2::GrantRoleReq& req) {
auto* processor = GrantProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_revokeRole(const cpp2::RevokeRoleReq& req) {
auto* processor = RevokeProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListUsersResp>
MetaServiceHandler::future_listUsers(const cpp2::ListUsersReq& req) {
auto* processor = ListUsersProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListRolesResp>
MetaServiceHandler::future_listRoles(const cpp2::ListRolesReq& req) {
auto* processor = ListRolesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_changePassword(const cpp2::ChangePasswordReq& req) {
auto* processor = ChangePasswordProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListRolesResp>
MetaServiceHandler::future_getUserRoles(const cpp2::GetUserRolesReq& req) {
auto* processor = GetUserRolesProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::BalanceResp>
MetaServiceHandler::future_balance(const cpp2::BalanceReq& req) {
auto* processor = BalanceProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_leaderBalance(const cpp2::LeaderBalanceReq& req) {
auto* processor = LeaderBalanceProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_regConfig(const cpp2::RegConfigReq &req) {
auto* processor = RegConfigProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::GetConfigResp>
MetaServiceHandler::future_getConfig(const cpp2::GetConfigReq &req) {
auto* processor = GetConfigProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_setConfig(const cpp2::SetConfigReq &req) {
auto* processor = SetConfigProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListConfigsResp>
MetaServiceHandler::future_listConfigs(const cpp2::ListConfigsReq &req) {
auto* processor = ListConfigsProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_createSnapshot(const cpp2::CreateSnapshotReq& req) {
auto* processor = CreateSnapshotProcessor::instance(kvstore_, adminClient_.get());
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ExecResp>
MetaServiceHandler::future_dropSnapshot(const cpp2::DropSnapshotReq& req) {
auto* processor = DropSnapshotProcessor::instance(kvstore_, adminClient_.get());
RETURN_FUTURE(processor);
}
folly::Future<cpp2::ListSnapshotsResp>
MetaServiceHandler::future_listSnapshots(const cpp2::ListSnapshotsReq& req) {
auto* processor = ListSnapshotsProcessor::instance(kvstore_);
RETURN_FUTURE(processor);
}
} // namespace meta
} // namespace nebula
| 36.206549 | 88 | 0.787116 | Sasasu |
b48053bf9790f7fe0af1be9aa6984f5e050ac4a2 | 5,344 | hpp | C++ | src/lib/optimizer/strategy/subquery_to_join_rule.hpp | mrcl-tst/hyrise | eec50b39de9f530b0a1732ceb5822b7222f3fe17 | [
"MIT"
] | 583 | 2015-01-10T00:55:32.000Z | 2022-03-25T12:24:30.000Z | src/lib/optimizer/strategy/subquery_to_join_rule.hpp | mrcl-tst/hyrise | eec50b39de9f530b0a1732ceb5822b7222f3fe17 | [
"MIT"
] | 1,573 | 2015-01-07T15:47:22.000Z | 2022-03-31T11:48:03.000Z | src/lib/optimizer/strategy/subquery_to_join_rule.hpp | mrcl-tst/hyrise | eec50b39de9f530b0a1732ceb5822b7222f3fe17 | [
"MIT"
] | 145 | 2015-03-09T16:26:07.000Z | 2022-02-15T12:53:23.000Z | #pragma once
#include "abstract_rule.hpp"
#include "expression/abstract_expression.hpp"
#include "types.hpp"
namespace opossum {
class AbstractExpression;
class AbstractLQPNode;
class AliasNode;
class AggregateNode;
class BinaryPredicateExpression;
class LQPSubqueryExpression;
class PredicateNode;
class ProjectionNode;
/**
* Optimizes:
* - (NOT) IN predicates with a subquery as the right operand
* - (NOT) EXISTS predicates
* - comparison (<,>,<=,>=,=,<>) predicates with subquery as the right operand
* Does not currently optimize:
* - (NOT) IN expressions where
* - the left value is not a column expression.
* - NOT IN with a correlated subquery
* - Correlated subqueries where the correlated parameter
* - is used outside predicates
* - is used in predicates at a point where it cannot be pulled up into a join predicate (below limits, etc.)
*/
class SubqueryToJoinRule : public AbstractRule {
public:
std::string name() const override;
struct PredicateNodeInfo {
/**
* Join predicate to achieve the semantic of the input expression type (IN, comparison, ...) in the created join.
*
* This can be nullptr (for (NOT) EXISTS), in this case only the join predicates from correlated predicates in the
* subquery will be used in the created join.
*/
std::shared_ptr<BinaryPredicateExpression> join_predicate;
JoinMode join_mode;
std::shared_ptr<LQPSubqueryExpression> subquery;
};
/**
* Result of pulling up correlated predicates from an LQP.
*/
struct PredicatePullUpResult {
std::shared_ptr<AbstractLQPNode> adapted_lqp;
std::vector<std::shared_ptr<BinaryPredicateExpression>> join_predicates;
size_t pulled_predicate_node_count = 0;
/**
* Expressions from the subquery required by the extracted join predicates.
*
* This list contains every expression only once, even if it is used (required) by multiple join predicates.
* This is a vector instead of an unordered_set so that tests are reproducible. Since correlation is usually very
* low there shouldn't be much of a performance difference.
*/
std::vector<std::shared_ptr<AbstractExpression>> required_output_expressions = {};
};
/**
* Extract information about the input LQP into a general format.
*
* Returns nullopt if the LQP does not match one of the supported formats.
*/
static std::optional<PredicateNodeInfo> is_predicate_node_join_candidate(const PredicateNode& predicate_node);
/**
* Searches for usages of correlated parameters.
*
* The first boolean is false when a correlated parameter is used outside of PredicateNodes (for example in joins).
* In this case we can never optimize this LQP. If it is true, the size_t contains the number of PredicateNodes in
* the LQP that use correlated parameters.
*/
static std::pair<bool, size_t> assess_correlated_parameter_usage(
const std::shared_ptr<AbstractLQPNode>& lqp,
const std::map<ParameterID, std::shared_ptr<AbstractExpression>>& parameter_mapping);
/**
* Tries to safely extract new join predicates from a PredicateNode.
*
* Returns a binary predicate expressions where the left operand is always the expression associated with the
* correlated parameter (and thus a column from the left subtree) and the right operand a column from the subqueries
* LQP. Also returns a new expression containing all non-correlated parts of the original nodes expression. If
* every part of the original nodes expression was turned into join predicates, nullptr is returned instead.
*/
static std::pair<std::vector<std::shared_ptr<BinaryPredicateExpression>>, std::shared_ptr<AbstractExpression>>
try_to_extract_join_predicates(const std::shared_ptr<PredicateNode>& predicate_node,
const std::map<ParameterID, std::shared_ptr<AbstractExpression>>& parameter_mapping,
bool is_below_aggregate);
/**
* Copy an aggregate node and adapt it to group by all required columns.
*/
static std::shared_ptr<AggregateNode> adapt_aggregate_node(
const std::shared_ptr<AggregateNode>& node,
const std::vector<std::shared_ptr<AbstractExpression>>& required_output_expressions);
/**
* Copy an alias node and adapt it to keep all required columns.
*/
static std::shared_ptr<AliasNode> adapt_alias_node(
const std::shared_ptr<AliasNode>& node,
const std::vector<std::shared_ptr<AbstractExpression>>& required_output_expressions);
/**
* Copy a projection node and adapt it to keep all required columns.
*/
static std::shared_ptr<ProjectionNode> adapt_projection_node(
const std::shared_ptr<ProjectionNode>& node,
const std::vector<std::shared_ptr<AbstractExpression>>& required_output_expressions);
/**
* Walk the subquery LQP, removing all correlated PredicateNodes and adapting other nodes as necessary.
*/
static PredicatePullUpResult pull_up_correlated_predicates(
const std::shared_ptr<AbstractLQPNode>& node,
const std::map<ParameterID, std::shared_ptr<AbstractExpression>>& parameter_mapping);
protected:
void _apply_to_plan_without_subqueries(const std::shared_ptr<AbstractLQPNode>& lqp_root) const override;
};
} // namespace opossum
| 40.484848 | 118 | 0.732036 | mrcl-tst |
b481d34f4ba709b2e8d5352ff726536239af2ba6 | 3,517 | cpp | C++ | clang/test/SemaSYCL/accessor_inheritance.cpp | hanzhan1/llvm | efe40bb5c797b102088e3cd2579a0f57ccf93310 | [
"Apache-2.0"
] | null | null | null | clang/test/SemaSYCL/accessor_inheritance.cpp | hanzhan1/llvm | efe40bb5c797b102088e3cd2579a0f57ccf93310 | [
"Apache-2.0"
] | null | null | null | clang/test/SemaSYCL/accessor_inheritance.cpp | hanzhan1/llvm | efe40bb5c797b102088e3cd2579a0f57ccf93310 | [
"Apache-2.0"
] | null | null | null | // RUN: %clang_cc1 -fsycl -fsycl-is-device -ast-dump %s | FileCheck %s
#include "Inputs/sycl.hpp"
struct Base {
int A, B;
cl::sycl::accessor<char, 1, cl::sycl::access::mode::read> AccField;
};
struct Captured : Base,
cl::sycl::accessor<char, 1, cl::sycl::access::mode::read> {
int C;
};
int main() {
Captured Obj;
cl::sycl::kernel_single_task<class kernel>(
[=]() {
Obj.use();
});
}
// Check kernel parameters
// CHECK: FunctionDecl {{.*}}kernel{{.*}} 'void (int, int, __global char *, cl::sycl::range<1>, cl::sycl::range<1>, cl::sycl::id<1>, __global char *, cl::sycl::range<1>, cl::sycl::range<1>, cl::sycl::id<1>, int)'
// CHECK: ParmVarDecl{{.*}} used _arg_A 'int'
// CHECK: ParmVarDecl{{.*}} used _arg_B 'int'
// CHECK: ParmVarDecl{{.*}} used _arg_AccField '__global char *'
// CHECK: ParmVarDecl{{.*}} used _arg_AccField 'cl::sycl::range<1>'
// CHECK: ParmVarDecl{{.*}} used _arg_AccField 'cl::sycl::range<1>'
// CHECK: ParmVarDecl{{.*}} used _arg_AccField 'cl::sycl::id<1>'
// CHECK: ParmVarDecl{{.*}} used _arg__base '__global char *'
// CHECK: ParmVarDecl{{.*}} used _arg__base 'cl::sycl::range<1>'
// CHECK: ParmVarDecl{{.*}} used _arg__base 'cl::sycl::range<1>'
// CHECK: ParmVarDecl{{.*}} used _arg__base 'cl::sycl::id<1>'
// CHECK: ParmVarDecl{{.*}} used _arg_C 'int'
// Check lambda initialization
// CHECK: VarDecl {{.*}} used '(lambda at {{.*}}accessor_inheritance.cpp
// CHECK-NEXT: InitListExpr {{.*}}
// CHECK-NEXT: InitListExpr {{.*}} 'Captured'
// CHECK-NEXT: InitListExpr {{.*}} 'Base'
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} '_arg_A' 'int'
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} '_arg_B' 'int'
// CHECK-NEXT: CXXConstructExpr {{.*}} 'cl::sycl::accessor<char, 1, cl::sycl::access::mode::read>':'cl::sycl::accessor<char, 1, cl::sycl::access::mode::read, cl::sycl::access::target::global_buffer, cl::sycl::access::placeholder::false_t, cl::sycl::ONEAPI::accessor_property_list<>>' 'void () noexcept'
// CHECK-NEXT: CXXConstructExpr {{.*}} 'cl::sycl::accessor<char, 1, cl::sycl::access::mode::read>':'cl::sycl::accessor<char, 1, cl::sycl::access::mode::read, cl::sycl::access::target::global_buffer, cl::sycl::access::placeholder::false_t, cl::sycl::ONEAPI::accessor_property_list<>>' 'void () noexcept'
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} '_arg_C' 'int'
// Check __init calls
// CHECK: CXXMemberCallExpr {{.*}} 'void'
// CHECK-NEXT: MemberExpr {{.*}} .__init
// CHECK-NEXT: MemberExpr {{.*}} .AccField
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'Base' lvalue <DerivedToBase (Base)>
// CHECK-NEXT: MemberExpr {{.*}} 'Captured' lvalue .
// CHECK-NEXT: DeclRefExpr {{.*}}'(lambda at {{.*}}accessor_inheritance.cpp
// CHECK-NEXT: ImplicitCastExpr {{.*}} '__global char *' <LValueToRValue>
// CHECK-NEXT: DeclRefExpr {{.*}} '__global char *' lvalue ParmVar {{.*}} '_arg_AccField' '__global char *'
// CHECK: CXXMemberCallExpr {{.*}} 'void'
// CHECK-NEXT: MemberExpr{{.*}} lvalue .__init
// CHECK-NEXT: MemberExpr{{.*}}'Captured' lvalue .
// CHECK-NEXT: DeclRefExpr {{.*}} '(lambda at {{.*}}accessor_inheritance.cpp
// CHECK-NEXT: ImplicitCastExpr {{.*}} '__global char *' <LValueToRValue>
// CHECK-NEXT: DeclRefExpr {{.*}} '__global char *' lvalue ParmVar {{.*}} '_arg__base' '__global char *'
| 53.287879 | 302 | 0.64373 | hanzhan1 |
b4835ccb7a3c3fe7cab83e3b6246ac0a76449464 | 6,285 | cc | C++ | src/relay/analysis/kind_check.cc | heweiwill/incubator-tvm | 5317afb79616454a27dedd4cf3b28dd0986aacdb | [
"Apache-2.0"
] | 5 | 2020-06-19T03:22:24.000Z | 2021-03-17T22:16:48.000Z | src/relay/analysis/kind_check.cc | heweiwill/incubator-tvm | 5317afb79616454a27dedd4cf3b28dd0986aacdb | [
"Apache-2.0"
] | 2 | 2020-07-08T12:34:59.000Z | 2020-07-11T15:54:47.000Z | src/relay/analysis/kind_check.cc | heweiwill/incubator-tvm | 5317afb79616454a27dedd4cf3b28dd0986aacdb | [
"Apache-2.0"
] | 2 | 2019-08-24T00:06:36.000Z | 2022-03-03T02:07:27.000Z | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*!
*
* \file kindchecker.cc
*
* \brief Check that types are well formed by applying "kinding rules".
*
* This pass ensures we do not do things that violate the design of the
* type system when writing down types.
*
* For example tensors are not allowed to contain functions in Relay.
*
* We check this by ensuring the `dtype` field of a Tensor always
* contains a data type such as `int`, `float`, `uint`.
*/
#include <tvm/ir/type_functor.h>
#include <tvm/relay/analysis.h>
#include <tvm/ir/error.h>
namespace tvm {
namespace relay {
using namespace tvm::runtime;
struct KindChecker : TypeFunctor<Kind(const Type&)> {
const IRModule& mod;
ErrorReporter err_reporter;
explicit KindChecker(const IRModule& mod) : mod(mod), err_reporter() {}
void ReportFatalError(const Error& err) {
this->err_reporter.Report(err);
this->err_reporter.RenderErrors(mod);
}
void CheckKindMatches(const Type& t, const Type& outer,
Kind expected, const std::string& description) {
Kind k = this->VisitType(t);
if (k != expected) {
ReportFatalError(ErrorBuilder()
<< "Incorrect kind for a " << description
<< ". Type " << t << " inside " << outer
<< " is of kind " << k
<< " but was expected to be "
<< expected);
}
}
Kind VisitType_(const IncompleteTypeNode* op) override {
return op->kind;
}
Kind VisitType_(const TypeVarNode* op) override {
return op->kind;
}
Kind VisitType_(const GlobalTypeVarNode* op) override {
return op->kind;
}
Kind VisitType_(const TensorTypeNode* op) override {
return Kind::kType;
}
Kind VisitType_(const TupleTypeNode* op) override {
// tuples should only contain normal types
for (const Type& t : op->fields) {
CheckKindMatches(t, GetRef<TupleType>(op), Kind::kType,
"tuple member");
}
return Kind::kType;
}
Kind VisitType_(const FuncTypeNode* op) override {
// Func types should only take normal types for arguments
// and only return a normal type. They should also have
// well-formed constraints
FuncType ft = GetRef<FuncType>(op);
for (const Type& t : op->arg_types) {
CheckKindMatches(t, ft, Kind::kType, "function type parameter");
}
CheckKindMatches(ft->ret_type, ft, Kind::kType, "function return type");
for (const TypeConstraint& tc : op->type_constraints) {
CheckKindMatches(tc, ft, Kind::kConstraint, "function type constraint");
}
return Kind::kType;
}
Kind VisitType_(const RelayRefTypeNode* op) override {
// ref types should only contain normal types
RelayRefType rt = GetRef<RelayRefType>(op);
CheckKindMatches(op->value, rt, Kind::kType, "ref contents");
return Kind::kType;
}
Kind VisitType_(const TypeRelationNode* op) override {
// arguments to type relation should be normal types
for (const Type& t : op->args) {
CheckKindMatches(t, GetRef<TypeRelation>(op), Kind::kType,
"argument to type relation");
}
return Kind::kConstraint;
}
Kind VisitType_(const TypeCallNode* op) override {
// type call func should be a global type var, args should be type
TypeCall tc = GetRef<TypeCall>(op);
const auto* gtv = op->func.as<GlobalTypeVarNode>();
if (gtv == nullptr) {
ReportFatalError(
ErrorBuilder() <<"The callee in " << tc
<< " is not a global type var, but is " << op->func);
}
CheckKindMatches(op->func, tc, Kind::kAdtHandle, "type call function");
for (const Type& t : op->args) {
CheckKindMatches(t, tc, Kind::kType, "type call argument");
}
// finally we need to check the module to check the number of type params
auto var = GetRef<GlobalTypeVar>(gtv);
auto data = mod->LookupTypeDef(var);
if (data->type_vars.size() != op->args.size()) {
ReportFatalError(ErrorBuilder()
<< "Expected " << data->type_vars.size() << "arguments for " << tc
<< "; got " << op->args.size());
}
return Kind::kType;
}
Kind VisitType_(const TypeDataNode* op) override {
// Constructors can reference the header var, but no other GlobalTypeVars.
// In theory, a TypeData could be nested, so the header scope
// should be tracked recursively, but it is unclear that we need
// to support it.
TypeData td = GetRef<TypeData>(op);
CheckKindMatches(op->header, td, Kind::kAdtHandle, "type data header");
for (const auto& var : op->type_vars) {
CheckKindMatches(var, td, Kind::kType, "ADT type var");
}
for (const auto& con : op->constructors) {
if (!con->belong_to.same_as(op->header)) {
ReportFatalError(ErrorBuilder()
<<con << " has header " << con->belong_to
<< " but " << op << " has header " << op->header);
}
for (const Type& t : con->inputs) {
CheckKindMatches(t, td, Kind::kType, "ADT constructor input");
}
}
return Kind::kTypeData;
}
Kind Check(const Type& t) {
return this->VisitType(t);
}
};
Kind KindCheck(const Type& t, const IRModule& mod) {
KindChecker kc(mod);
return kc.Check(t);
}
TVM_REGISTER_GLOBAL("relay.analysis.check_kind")
.set_body([](TVMArgs args, TVMRetValue* ret) {
if (args.size() == 1) {
*ret = KindCheck(args[0], IRModule({}, {}));
} else {
*ret = KindCheck(args[0], args[1]);
}
});
} // namespace relay
} // namespace tvm
| 31.425 | 78 | 0.648846 | heweiwill |
b483edc29433ebcce8397fc2fe7b4556fa6df288 | 1,571 | cpp | C++ | tests/math_unit/math/fwd/scal/fun/pow_test.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 1 | 2019-09-06T15:53:17.000Z | 2019-09-06T15:53:17.000Z | tests/math_unit/math/fwd/scal/fun/pow_test.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 8 | 2019-01-17T18:51:16.000Z | 2019-01-17T18:51:39.000Z | tests/math_unit/math/fwd/scal/fun/pow_test.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | null | null | null | #include <stan/math/fwd/scal.hpp>
#include <gtest/gtest.h>
#include <math/fwd/scal/fun/nan_util.hpp>
TEST(AgradFwdPow, Fvar) {
using stan::math::fvar;
using std::isnan;
using std::log;
using std::pow;
fvar<double> x(0.5, 1.0);
double y = 5.0;
fvar<double> a = pow(x, y);
EXPECT_FLOAT_EQ(pow(0.5, 5.0), a.val_);
EXPECT_FLOAT_EQ(5.0 * pow(0.5, 5.0 - 1.0), a.d_);
fvar<double> b = pow(y, x);
EXPECT_FLOAT_EQ(pow(5.0, 0.5), b.val_);
EXPECT_FLOAT_EQ(log(5.0) * pow(5.0, 0.5), b.d_);
fvar<double> z(1.2, 2.0);
fvar<double> c = pow(x, z);
EXPECT_FLOAT_EQ(pow(0.5, 1.2), c.val_);
EXPECT_FLOAT_EQ((2.0 * log(0.5) + 1.2 * 1.0 / 0.5) * pow(0.5, 1.2), c.d_);
fvar<double> w(-0.4, 1.0);
fvar<double> d = pow(w, x);
isnan(d.val_);
isnan(d.d_);
}
TEST(AgradFwdPow, FvarFvarDouble) {
using stan::math::fvar;
using std::log;
using std::pow;
fvar<fvar<double> > x;
x.val_.val_ = 0.5;
x.val_.d_ = 1.0;
fvar<fvar<double> > y;
y.val_.val_ = 0.5;
y.d_.val_ = 1.0;
fvar<fvar<double> > a = pow(x, y);
EXPECT_FLOAT_EQ(pow(0.5, 0.5), a.val_.val_);
EXPECT_FLOAT_EQ(0.5 * pow(0.5, -0.5), a.val_.d_);
EXPECT_FLOAT_EQ(log(0.5) * pow(0.5, 0.5), a.d_.val_);
EXPECT_FLOAT_EQ(pow(0.5, -0.5) * (0.5 * log(0.5) + 1.0), a.d_.d_);
}
struct pow_fun {
template <typename T0, typename T1>
inline typename boost::math::tools::promote_args<T0, T1>::type operator()(
const T0 arg1, const T1 arg2) const {
return pow(arg1, arg2);
}
};
TEST(AgradFwdPow, nan_0) {
pow_fun pow_;
test_nan_fwd(pow_, 3.0, 5.0, false);
}
| 23.80303 | 76 | 0.602801 | alashworth |
b486e13ea20cff2c3d3b82c920400ce2eae2ea1c | 13,660 | cpp | C++ | src/modules/processes/contrib/nvolkov/CosmeticCorrection/CosmeticCorrectionParameters.cpp | fmeschia/pixinsight-class-library | 11b956e27d6eee3e119a7b1c337d090d7a03f436 | [
"JasPer-2.0",
"libtiff"
] | null | null | null | src/modules/processes/contrib/nvolkov/CosmeticCorrection/CosmeticCorrectionParameters.cpp | fmeschia/pixinsight-class-library | 11b956e27d6eee3e119a7b1c337d090d7a03f436 | [
"JasPer-2.0",
"libtiff"
] | null | null | null | src/modules/processes/contrib/nvolkov/CosmeticCorrection/CosmeticCorrectionParameters.cpp | fmeschia/pixinsight-class-library | 11b956e27d6eee3e119a7b1c337d090d7a03f436 | [
"JasPer-2.0",
"libtiff"
] | null | null | null | // ____ ______ __
// / __ \ / ____// /
// / /_/ // / / /
// / ____// /___ / /___ PixInsight Class Library
// /_/ \____//_____/ PCL 2.4.9
// ----------------------------------------------------------------------------
// Standard CosmeticCorrection Process Module Version 1.2.5
// ----------------------------------------------------------------------------
// CosmeticCorrectionParameters.cpp - Released 2021-04-09T19:41:49Z
// ----------------------------------------------------------------------------
// This file is part of the standard CosmeticCorrection PixInsight module.
//
// Copyright (c) 2011-2020 Nikolay Volkov
// Copyright (c) 2003-2020 Pleiades Astrophoto S.L.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
// of their contributors, may be used to endorse or promote products derived
// from this software without specific prior written permission. For written
// permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
// reproduce the following acknowledgment in the end-user documentation
// and/or other materials provided with the product:
//
// "This product is based on software from the PixInsight project, developed
// by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
// Alternatively, if that is where third-party acknowledgments normally
// appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
#include "CosmeticCorrectionParameters.h"
namespace pcl
{
// ----------------------------------------------------------------------------
CCTargetFrames* TheTargetFrames = nullptr;
CCTargetFrameEnabled* TheTargetFrameEnabled = nullptr;
CCTargetFramePath* TheTargetFramePath = nullptr;
CCOutputDir* TheOutputDir = nullptr;
CCOutputExtension* TheOutputExtension = nullptr;
CCPrefix* ThePrefix = nullptr;
CCPostfix* ThePostfix = nullptr;
CCOverwrite* TheOverwrite = nullptr;
CCCFA* TheCFA = nullptr;
CCAmount* TheAmount = nullptr;
CCUseMasterDark* TheUseMasterDark = nullptr;
CCMasterDarkPath* TheMasterPath = nullptr;
CCHotDarkCheck* TheHotDarkCheck = nullptr;
CCColdLevel* TheColdLevel = nullptr;
CCColdDarkCheck* TheColdDarkCheck = nullptr;
CCHotLevel* TheHotLevel = nullptr;
CCUseAutoDetect* TheUseAutoDetect = nullptr;
CCHotAutoCheck* TheHotAutoCheck = nullptr;
CCHotAutoValue* TheHotAutoValue = nullptr;
CCColdAutoCheck* TheColdAutoCheck = nullptr;
CCColdAutoValue* TheColdAutoValue = nullptr;
CCUseDefectList* TheUseDefectList = nullptr;
CCDefects* TheDefects = nullptr;
CCDefectEnabled* TheDefectEnabled = nullptr;
CCDefectIsRow* TheDefectIsRow = nullptr;
CCDefectAddress* TheDefectAddress = nullptr;
CCDefectIsRange* TheDefectIsRange = nullptr;
CCDefectBegin* TheDefectBegin = nullptr;
CCDefectEnd* TheDefectEnd = nullptr;
// ----------------------------------------------------------------------------
CCTargetFrames::CCTargetFrames( MetaProcess* P )
: MetaTable( P )
{
TheTargetFrames = this;
}
IsoString CCTargetFrames::Id() const
{
return "targetFrames";
}
// ----------------------------------------------------------------------------
CCTargetFrameEnabled::CCTargetFrameEnabled( MetaTable* T )
: MetaBoolean( T )
{
TheTargetFrameEnabled = this;
}
IsoString CCTargetFrameEnabled::Id() const
{
return "enabled";
}
bool CCTargetFrameEnabled::DefaultValue() const
{
return true;
}
// ----------------------------------------------------------------------------
CCTargetFramePath::CCTargetFramePath( MetaTable* T )
: MetaString( T )
{
TheTargetFramePath = this;
}
IsoString CCTargetFramePath::Id() const
{
return "path";
}
// ----------------------------------------------------------------------------
CCOutputDir::CCOutputDir( MetaProcess* P )
: MetaString( P )
{
TheOutputDir = this;
}
IsoString CCOutputDir::Id() const
{
return "outputDir";
}
// ----------------------------------------------------------------------------
CCOutputExtension::CCOutputExtension( MetaProcess* P )
: MetaString( P )
{
TheOutputExtension = this;
}
IsoString CCOutputExtension::Id() const
{
return "outputExtension";
}
String CCOutputExtension::DefaultValue() const
{
return ".xisf";
}
// ----------------------------------------------------------------------------
CCPrefix::CCPrefix( MetaProcess* P )
: MetaString( P )
{
ThePrefix = this;
}
IsoString CCPrefix::Id() const
{
return "prefix";
}
String CCPrefix::DefaultValue() const
{
return "";
}
// ----------------------------------------------------------------------------
CCPostfix::CCPostfix( MetaProcess* P )
: MetaString( P )
{
ThePostfix = this;
}
IsoString CCPostfix::Id() const
{
return "postfix";
}
String CCPostfix::DefaultValue() const
{
return "_cc";
}
// ----------------------------------------------------------------------------
CCOverwrite::CCOverwrite( MetaProcess* P )
: MetaBoolean( P )
{
TheOverwrite = this;
}
IsoString CCOverwrite::Id() const
{
return "overwrite";
}
bool CCOverwrite::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCCFA::CCCFA( MetaProcess* P )
: MetaBoolean( P )
{
TheCFA = this;
}
IsoString CCCFA::Id() const
{
return "cfa";
}
bool CCCFA::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCAmount::CCAmount( MetaProcess* P )
: MetaFloat( P )
{
TheAmount = this;
}
IsoString CCAmount::Id() const
{
return "amount";
}
IsoString CCAmount::Aliases() const
{
return "transferFn";
}
int CCAmount::Precision() const
{
return 2;
}
double CCAmount::DefaultValue() const
{
return 1;
}
double CCAmount::MinimumValue() const
{
return 0;
}
double CCAmount::MaximumValue() const
{
return 1;
}
// -----------------------------------------------------------Via Master Dark-----------------
CCUseMasterDark::CCUseMasterDark( MetaProcess* P )
: MetaBoolean( P )
{
TheUseMasterDark = this;
}
IsoString CCUseMasterDark::Id() const
{
return "useMasterDark";
}
bool CCUseMasterDark::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCMasterDarkPath::CCMasterDarkPath( MetaProcess* P )
: MetaString( P )
{
TheMasterPath = this;
}
IsoString CCMasterDarkPath::Id() const
{
return "masterDarkPath";
}
// ----------------------------------------------------------------------------
CCHotDarkCheck::CCHotDarkCheck( MetaProcess* P )
: MetaBoolean( P )
{
TheHotDarkCheck = this;
}
IsoString CCHotDarkCheck::Id() const
{
return "hotDarkCheck";
}
bool CCHotDarkCheck::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCHotLevel::CCHotLevel( MetaProcess* P )
: MetaFloat( P )
{
TheHotLevel = this;
}
IsoString CCHotLevel::Id() const
{
return "hotDarkLevel";
}
int CCHotLevel::Precision() const
{
return 10;
}
double CCHotLevel::DefaultValue() const
{
return 1;
}
double CCHotLevel::MinimumValue() const
{
return 0;
}
double CCHotLevel::MaximumValue() const
{
return 1;
}
// ----------------------------------------------------------------------------
CCColdDarkCheck::CCColdDarkCheck( MetaProcess* P )
: MetaBoolean( P )
{
TheColdDarkCheck = this;
}
IsoString CCColdDarkCheck::Id() const
{
return "coldDarkCheck";
}
bool CCColdDarkCheck::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCColdLevel::CCColdLevel( MetaProcess* P )
: MetaFloat( P )
{
TheColdLevel = this;
}
IsoString CCColdLevel::Id() const
{
return "coldDarkLevel";
}
int CCColdLevel::Precision() const
{
return 10;
}
double CCColdLevel::DefaultValue() const
{
return 0;
}
double CCColdLevel::MinimumValue() const
{
return 0;
}
double CCColdLevel::MaximumValue() const
{
return 1;
}
// -----------------------------------------------------------Via Auto Detect-----------------
CCUseAutoDetect::CCUseAutoDetect( MetaProcess* P )
: MetaBoolean( P )
{
TheUseAutoDetect = this;
}
IsoString CCUseAutoDetect::Id() const
{
return "useAutoDetect";
}
bool CCUseAutoDetect::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCHotAutoCheck::CCHotAutoCheck( MetaProcess* P )
: MetaBoolean( P )
{
TheHotAutoCheck = this;
}
IsoString CCHotAutoCheck::Id() const
{
return "hotAutoCheck";
}
bool CCHotAutoCheck::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCHotAutoValue::CCHotAutoValue( MetaProcess* P )
: MetaFloat( P )
{
TheHotAutoValue = this;
}
IsoString CCHotAutoValue::Id() const
{
return "hotAutoValue";
}
int CCHotAutoValue::Precision() const
{
return 1;
}
double CCHotAutoValue::DefaultValue() const
{
return 3;
}
double CCHotAutoValue::MinimumValue() const
{
return 0;
}
double CCHotAutoValue::MaximumValue() const
{
return 50;
}
// ----------------------------------------------------------------------------
CCColdAutoCheck::CCColdAutoCheck( MetaProcess* P )
: MetaBoolean( P )
{
TheColdAutoCheck = this;
}
IsoString CCColdAutoCheck::Id() const
{
return "coldAutoCheck";
}
bool CCColdAutoCheck::DefaultValue() const
{
return false;
}
// ----------------------------------------------------------------------------
CCColdAutoValue::CCColdAutoValue( MetaProcess* P )
: MetaFloat( P )
{
TheColdAutoValue = this;
}
IsoString CCColdAutoValue::Id() const
{
return "coldAutoValue";
}
int CCColdAutoValue::Precision() const
{
return 1;
}
double CCColdAutoValue::DefaultValue() const
{
return 3;
}
double CCColdAutoValue::MinimumValue() const
{
return 0;
}
double CCColdAutoValue::MaximumValue() const
{
return 50;
}
// ----------------------------------------------------------------------------
CCUseDefectList::CCUseDefectList( MetaProcess* P )
: MetaBoolean( P )
{
TheUseDefectList = this;
}
IsoString CCUseDefectList::Id() const
{
return "useDefectList";
}
// ----------------------------------------------------------------------------
CCDefects::CCDefects( MetaProcess* P )
: MetaTable( P )
{
TheDefects = this;
}
IsoString CCDefects::Id() const
{
return "defects";
}
// ----------------------------------------------------------------------------
CCDefectEnabled::CCDefectEnabled( MetaTable* T )
: MetaBoolean( T )
{
TheDefectEnabled = this;
}
IsoString CCDefectEnabled::Id() const
{
return "defectEnabled";
}
// ----------------------------------------------------------------------------
CCDefectIsRow::CCDefectIsRow( MetaTable* T )
: MetaBoolean( T )
{
TheDefectIsRow = this;
}
IsoString CCDefectIsRow::Id() const
{
return "defectIsRow";
}
// ----------------------------------------------------------------------------
CCDefectAddress::CCDefectAddress( MetaTable* T )
: MetaUInt16( T )
{
TheDefectAddress = this;
}
IsoString CCDefectAddress::Id() const
{
return "defectAddress";
}
// ----------------------------------------------------------------------------
CCDefectIsRange::CCDefectIsRange( MetaTable* T )
: MetaBoolean( T )
{
TheDefectIsRange = this;
}
IsoString CCDefectIsRange::Id() const
{
return "defectIsRange";
}
// ----------------------------------------------------------------------------
CCDefectBegin::CCDefectBegin( MetaTable* T )
: MetaUInt16( T )
{
TheDefectBegin = this;
}
IsoString CCDefectBegin::Id() const
{
return "defectBegin";
}
// ----------------------------------------------------------------------------
CCDefectEnd::CCDefectEnd( MetaTable* T )
: MetaUInt16( T )
{
TheDefectEnd = this;
}
IsoString CCDefectEnd::Id() const
{
return "defectEnd";
}
// ----------------------------------------------------------------------------
} // namespace pcl
// ----------------------------------------------------------------------------
// EOF CosmeticCorrectionParameters.cpp - Released 2021-04-09T19:41:49Z
| 21.21118 | 94 | 0.565813 | fmeschia |
b48bb453520fe2347c7ee858c1188bb783bf24d1 | 4,317 | cpp | C++ | src/entity_systems/ffi_path.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | 11 | 2015-03-02T07:43:00.000Z | 2021-12-04T04:53:02.000Z | src/entity_systems/ffi_path.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | 1 | 2015-03-28T17:17:13.000Z | 2016-10-10T05:49:07.000Z | src/entity_systems/ffi_path.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | 3 | 2016-11-04T01:14:31.000Z | 2020-05-07T23:42:27.000Z | /****************************
Copyright © 2014 Luke Salisbury
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
****************************/
#include "ffi_path.h"
#include "ffi_functions.h"
#include <cmath>
#include "core.h"
#define FIXEDPI 3.1415926535897932384626433832795
/**
* @brief Lux_FFI_Path_Move_Object
* @param object_id
* @param fixed_speed
* @param x
* @param y
* @param loop
* @return
*/
int32_t Lux_FFI_Path_Move_Object( uint32_t object_id, int32_t fixed_speed, int16_t * x, int16_t * y, uint8_t loop )
{
float movex, movey, speed, angle = 0;
LuxPath next, prev;
uint16_t next_path_point = 0;
MapObject * map_object = Lux_FFI_Object_Get( object_id );
if ( map_object )
{
if ( !map_object->_path.size() )
{
return -2;
}
// Movement direction
speed = MAKE_FIXED_FLOAT(fixed_speed) * MAKE_FIXED_FLOAT(lux::core->GetFrameDelta() );
if ( speed > 0.0 )
{
next_path_point = map_object->path_point+1;
if ( loop ) // Loop around
{
if ( map_object->path_point >= map_object->_path.size()-1 )
{
next_path_point = 0;
}
}
else
{
if ( map_object->path_point >= map_object->_path.size()-1 )
return map_object->path_point;
}
prev.x = map_object->position.x;
prev.y = map_object->position.y;
next = map_object->_path.at(next_path_point);
}
else if ( speed < 0.0 )
{
next_path_point = map_object->path_point-1;
if ( loop ) // Loop around
{
if ( (map_object->path_point == 0) && map_object->path_point > map_object->_path.size() )
{
next_path_point = map_object->_path.size()-1;
}
}
else
{
if ( (map_object->path_point == 0) && map_object->path_point > map_object->_path.size() )
return map_object->path_point;
}
prev.x = map_object->position.x;
prev.y = map_object->position.y;
prev = map_object->_path.at(map_object->path_point);
next = map_object->_path.at(next_path_point);
}
else
return -1;
angle = atan2( (float)(prev.y - next.y), (float)(prev.x - next.x));
movey = sin(angle) * speed;
movex = cos(angle) * speed;
map_object->path_current_x -= MAKE_FLOAT_FIXED(movex);
map_object->path_current_y -= MAKE_FLOAT_FIXED(movey);
map_object->position.x = MAKE_FIXED_INT(map_object->path_current_x);
map_object->position.y = MAKE_FIXED_INT(map_object->path_current_y);
if ( map_object->position.x == next.x && map_object->position.y == next.y)
{
map_object->path_current_x = MAKE_INT_FIXED(map_object->position.x);
map_object->path_current_y = MAKE_INT_FIXED(map_object->position.y);
map_object->path_point = next_path_point;
}
if (x)
*x = map_object->position.x;
if (y)
*y = map_object->position.y;
return map_object->path_point;
}
return -1;
}
/**
* @brief Lux_FFI_Path_Count
* @param object_id
* @return
*/
int32_t Lux_FFI_Path_Count( uint32_t object_id )
{
MapObject * map_object = Lux_FFI_Object_Get( object_id );
if ( map_object )
{
return (int32_t)map_object->_path.size();
}
return -1;
}
/**
* @brief Lux_FFI_Path_Point
* @param object_id
* @param point
* @param x
* @param y
* @param ms_length
* @return
*/
uint8_t Lux_FFI_Path_Point( uint32_t object_id, uint8_t point, int16_t * x, int16_t * y, uint32_t *ms_length )
{
if ( point < 0 )
return 0;
LuxPath next;
MapObject * map_object = Lux_FFI_Object_Get( object_id );
if ( map_object )
{
next = map_object->_path.at(point);
if (x)
*x = next.x;
if (y)
*y = next.y;
if (ms_length)
*ms_length = next.ms_length;
return 1;
}
return 0;
}
| 26.006024 | 243 | 0.682187 | mokoi |
b48c4d31ac1bcb213e103c329e5a28a441479e8b | 23,581 | cpp | C++ | FFX_CAS/cas-samples/libs/cauldron/src/DX12/GLTF/GltfPbrPass.cpp | TonyJennifer/OpenSource | 442e705eb42197ccdc44557a61caf91deebfcd05 | [
"MIT"
] | 2 | 2019-07-27T11:40:02.000Z | 2021-04-30T05:16:13.000Z | src/DX12/GLTF/GltfPbrPass.cpp | swq0553/Cauldron | 8530be0b7c65886726761944ec7855ce74d09db9 | [
"MIT"
] | null | null | null | src/DX12/GLTF/GltfPbrPass.cpp | swq0553/Cauldron | 8530be0b7c65886726761944ec7855ce74d09db9 | [
"MIT"
] | null | null | null | // AMD AMDUtils code
//
// Copyright(c) 2018 Advanced Micro Devices, Inc.All rights reserved.
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 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 NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS 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.
#include "stdafx.h"
#include "GltfPbrPass.h"
#include "Misc\ThreadPool.h"
#include "GltfHelpers.h"
#include "Base\ShaderCompilerHelper.h"
namespace CAULDRON_DX12
{
//--------------------------------------------------------------------------------------
//
// OnCreate
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::OnCreate(
Device *pDevice,
UploadHeap* pUploadHeap,
ResourceViewHeaps *pHeaps,
DynamicBufferRing *pDynamicBufferRing,
StaticBufferPool *pStaticBufferPool,
GLTFTexturesAndBuffers *pGLTFTexturesAndBuffers,
SkyDome *pSkyDome,
Texture *pShadowMap,
DXGI_FORMAT outFormat,
uint32_t sampleCount)
{
m_sampleCount = sampleCount;
m_pResourceViewHeaps = pHeaps;
m_pStaticBufferPool = pStaticBufferPool;
m_pDynamicBufferRing = pDynamicBufferRing;
m_pGLTFTexturesAndBuffers = pGLTFTexturesAndBuffers;
m_outFormat = outFormat;
const json &j3 = m_pGLTFTexturesAndBuffers->m_pGLTFCommon->j3;
/////////////////////////////////////////////
// Load BRDF look up table for the PBR shader
m_BrdfLut.InitFromFile(pDevice, pUploadHeap, "BrdfLut.dds", false); // LUT images are stored as linear
// Create default material
//
{
m_defaultMaterial.m_pbrMaterialParameters.m_doubleSided = false;
m_defaultMaterial.m_pbrMaterialParameters.m_blending = false;
m_defaultMaterial.m_pbrMaterialParameters.m_params.m_emissiveFactor = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
m_defaultMaterial.m_pbrMaterialParameters.m_params.m_baseColorFactor = XMVectorSet(1.0f, 0.0f, 0.0f, 1.0f);
m_defaultMaterial.m_pbrMaterialParameters.m_params.m_metallicRoughnessValues = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
m_defaultMaterial.m_pbrMaterialParameters.m_params.m_specularGlossinessFactor = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
std::map<std::string, Texture *> texturesBase;
CreateGPUMaterialData(&m_defaultMaterial, texturesBase, pSkyDome, pShadowMap);
}
// Load PBR 2.0 Materials
//
const json::array_t &materials = j3["materials"];
m_materialsData.resize(materials.size());
for (uint32_t i = 0; i < materials.size(); i++)
{
PBRMaterial *tfmat = &m_materialsData[i];
// Get PBR material parameters and texture IDs
//
std::map<std::string, int> textureIds;
ProcessMaterials(materials[i], &tfmat->m_pbrMaterialParameters, textureIds);
// translate texture IDs into textureViews
//
std::map<std::string, Texture *> texturesBase;
for (auto const& value : textureIds)
texturesBase[value.first] = m_pGLTFTexturesAndBuffers->GetTextureViewByID(value.second);
CreateGPUMaterialData(tfmat, texturesBase, pSkyDome, pShadowMap);
}
// Load Meshes
//
if (j3.find("meshes") != j3.end())
{
const json::array_t &meshes = j3["meshes"];
const json::array_t &accessors = j3["accessors"];
m_meshes.resize(meshes.size());
for (uint32_t i = 0; i < meshes.size(); i++)
{
PBRMesh *tfmesh = &m_meshes[i];
const json::array_t &primitives = meshes[i]["primitives"];
tfmesh->m_pPrimitives.resize(primitives.size());
for (uint32_t p = 0; p < primitives.size(); p++)
{
json::object_t primitive = primitives[p];
PBRPrimitives *pPrimitive = &tfmesh->m_pPrimitives[p];
// Sets primitive's material, or set a default material if none was specified in the GLTF
//
auto mat = primitive.find("material");
pPrimitive->m_pMaterial = (mat != primitive.end()) ? &m_materialsData[mat->second] : &m_defaultMaterial;
// Gets the geometry topology (so far we are not doing anything with this)
//
int32_t mode = GetElementInt(primitive, "mode", 4);
// Defines for the shader compiler, they will hold the PS and VS bindings for the geometry, io and textures
//
DefineList attributeDefines;
// Set input layout from glTF attributes and set VS bindings
//
const json::object_t &attribute = primitive["attributes"];
std::vector<tfAccessor> vertexBuffers(attribute.size());
std::vector<std::string> semanticNames(attribute.size());
std::vector<D3D12_INPUT_ELEMENT_DESC> layout(attribute.size());
uint32_t cnt = 0;
for (auto it = attribute.begin(); it != attribute.end(); it++, cnt++)
{
const json::object_t &accessor = accessors[it->second];
// let the compiler know we have this stream
attributeDefines[std::string("HAS_") + it->first] = "1";
// split semantic name from index, DX doesnt like the trailing number
uint32_t semanticIndex = 0;
SplitGltfAttribute(it->first, &semanticNames[cnt], &semanticIndex);
// Create Input Layout
//
layout[cnt].SemanticName = semanticNames[cnt].c_str(); // we need to set it in the pipeline function (because of multithreading)
layout[cnt].SemanticIndex = semanticIndex;
layout[cnt].Format = GetFormat(accessor.at("type"), accessor.at("componentType"));
layout[cnt].InputSlot = (UINT)cnt;
layout[cnt].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
layout[cnt].InstanceDataStepRate = 0;
layout[cnt].AlignedByteOffset = D3D12_APPEND_ALIGNED_ELEMENT;
// Get VB accessors
//
m_pGLTFTexturesAndBuffers->m_pGLTFCommon->GetBufferDetails(it->second, &vertexBuffers[cnt]);
}
// Get Index and vertex buffer buffer accessors and create the geometry
//
tfAccessor indexBuffer;
m_pGLTFTexturesAndBuffers->m_pGLTFCommon->GetBufferDetails(primitive["indices"], &indexBuffer);
m_pGLTFTexturesAndBuffers->CreateGeometry(indexBuffer, vertexBuffers, &pPrimitive->m_geometry);
// Create the descriptors, the root signature and the pipeline
//
{
bool bUsingSkinning = m_pGLTFTexturesAndBuffers->m_pGLTFCommon->FindMeshSkinId(i) != -1;
CreateDescriptors(pDevice->GetDevice(), bUsingSkinning, &attributeDefines, pPrimitive);
CreatePipeline(pDevice->GetDevice(), semanticNames, layout, &attributeDefines, pPrimitive);
}
}
}
}
}
//--------------------------------------------------------------------------------------
//
// CreateGPUMaterialData
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::CreateGPUMaterialData(PBRMaterial *tfmat, std::map<std::string, Texture *> &texturesBase, SkyDome *pSkyDome, Texture *pShadowMap)
{
// count the number of textures to init bindings and descriptor
{
tfmat->m_textureCount = (int)texturesBase.size();
tfmat->m_textureCount += 1; // This is for the BRDF LUT texture
if (pSkyDome)
tfmat->m_textureCount += 2; // +2 because the skydome has a specular, diffusse and BDRF maps
if (pShadowMap != NULL) // will use a shadowmap texture if present
tfmat->m_textureCount += 1;
}
// Alloc descriptor layout and init the descriptor set
if (tfmat->m_textureCount >= 0)
{
// allocate descriptor table for the textures
m_pResourceViewHeaps->AllocCBV_SRV_UAVDescriptor(tfmat->m_textureCount, &tfmat->m_texturesTable);
uint32_t cnt = 0;
//create SRVs and #defines for the BRDF LUT resources
tfmat->m_pbrMaterialParameters.m_defines["ID_brdfTexture"] = std::to_string(cnt);
CreateSamplerForBrdfLut(cnt, &tfmat->m_samplers[cnt]);
m_BrdfLut.CreateSRV(cnt, &tfmat->m_texturesTable);
cnt++;
//create SRVs and #defines for the IBL resources
if (pSkyDome)
{
tfmat->m_pbrMaterialParameters.m_defines["ID_diffuseCube"] = std::to_string(cnt);
pSkyDome->SetDescriptorDiff(cnt, &tfmat->m_texturesTable, cnt, &tfmat->m_samplers[cnt]);
cnt++;
tfmat->m_pbrMaterialParameters.m_defines["ID_specularCube"] = std::to_string(cnt);
pSkyDome->SetDescriptorSpec(cnt, &tfmat->m_texturesTable, cnt, &tfmat->m_samplers[cnt]);
cnt++;
tfmat->m_pbrMaterialParameters.m_defines["USE_IBL"] = "1";
}
// Create SRV for the shadowmap
if (pShadowMap != NULL)
{
tfmat->m_pbrMaterialParameters.m_defines["ID_shadowMap"] = std::to_string(cnt);
pShadowMap->CreateSRV(cnt, &tfmat->m_texturesTable);
CreateSamplerForShadowMap(cnt, &tfmat->m_samplers[cnt]);
cnt++;
}
//create SRVs and #defines so the shader compiler knows what the index of each texture is
for (auto it = texturesBase.begin(); it != texturesBase.end(); it++)
{
tfmat->m_pbrMaterialParameters.m_defines[std::string("ID_") + it->first] = std::to_string(cnt);
it->second->CreateSRV(cnt, &tfmat->m_texturesTable);
CreateSamplerForPBR(cnt, &tfmat->m_samplers[cnt]);
cnt++;
}
}
}
//--------------------------------------------------------------------------------------
//
// OnDestroy
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::OnDestroy()
{
for (uint32_t m = 0; m < m_meshes.size(); m++)
{
PBRMesh *pMesh = &m_meshes[m];
for (uint32_t p = 0; p < pMesh->m_pPrimitives.size(); p++)
{
PBRPrimitives *pPrimitive = &pMesh->m_pPrimitives[p];
pPrimitive->m_PipelineRender->Release();
pPrimitive->m_RootSignature->Release();
}
}
m_BrdfLut.OnDestroy();
}
//--------------------------------------------------------------------------------------
//
// CreateDescriptors for a combination of material and geometry
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::CreateDescriptors(ID3D12Device* pDevice, bool bUsingSkinning, DefineList *pAttributeDefines, PBRPrimitives *pPrimitive)
{
CD3DX12_DESCRIPTOR_RANGE DescRange[1];
DescRange[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, pPrimitive->m_pMaterial->m_textureCount, 0); // texture table
int params = 0;
CD3DX12_ROOT_PARAMETER RTSlot[4];
// b0 <- Constant buffer 'per frame'
RTSlot[params++].InitAsConstantBufferView(0, 0, D3D12_SHADER_VISIBILITY_ALL);
// textures table
if (pPrimitive->m_pMaterial->m_textureCount > 0)
{
RTSlot[params++].InitAsDescriptorTable(1, &DescRange[0], D3D12_SHADER_VISIBILITY_PIXEL);
}
// b1 <- Constant buffer 'per object', these are mainly the material data
RTSlot[params++].InitAsConstantBufferView(1, 0, D3D12_SHADER_VISIBILITY_ALL);
// b2 <- Constant buffer holding the skinning matrices
if (bUsingSkinning)
{
RTSlot[params++].InitAsConstantBufferView(2, 0, D3D12_SHADER_VISIBILITY_VERTEX);
(*pAttributeDefines)["ID_SKINNING_MATRICES"] = std::to_string(2);
}
// the root signature contains 3 slots to be used
CD3DX12_ROOT_SIGNATURE_DESC descRootSignature = CD3DX12_ROOT_SIGNATURE_DESC();
descRootSignature.pParameters = RTSlot;
descRootSignature.NumParameters = params;
descRootSignature.pStaticSamplers = pPrimitive->m_pMaterial->m_samplers;
descRootSignature.NumStaticSamplers = pPrimitive->m_pMaterial->m_textureCount;
// deny uneccessary access to certain pipeline stages
descRootSignature.Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE
| D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
| D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS
| D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS
| D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS;
ID3DBlob *pOutBlob, *pErrorBlob = NULL;
ThrowIfFailed(D3D12SerializeRootSignature(&descRootSignature, D3D_ROOT_SIGNATURE_VERSION_1, &pOutBlob, &pErrorBlob));
ThrowIfFailed(pDevice->CreateRootSignature(0, pOutBlob->GetBufferPointer(), pOutBlob->GetBufferSize(), IID_PPV_ARGS(&pPrimitive->m_RootSignature)));
pPrimitive->m_RootSignature->SetName(L"GltfPbr::D3D12SerializeRootSignature");
pOutBlob->Release();
if (pErrorBlob)
pErrorBlob->Release();
}
//--------------------------------------------------------------------------------------
//
// CreatePipeline
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::CreatePipeline(ID3D12Device* pDevice, std::vector<std::string> semanticNames, std::vector<D3D12_INPUT_ELEMENT_DESC> layout, DefineList *pAttributeDefines, PBRPrimitives *pPrimitive)
{
/////////////////////////////////////////////
// Compile and create shaders
D3D12_SHADER_BYTECODE shaderVert, shaderPixel;
{
// Create #defines based on material properties and vertex attributes
DefineList defines = pPrimitive->m_pMaterial->m_pbrMaterialParameters.m_defines + (*pAttributeDefines);
CompileShaderFromFile("GLTFPbrPass-VS.hlsl", &defines, "mainVS", "vs_5_0", 0, &shaderVert);
CompileShaderFromFile("GLTFPbrPass-PS.hlsl", &defines, "mainPS", "ps_5_0", 0, &shaderPixel);
}
// Set blending
//
CD3DX12_BLEND_DESC blendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
blendState.RenderTarget[0] = D3D12_RENDER_TARGET_BLEND_DESC
{
(pPrimitive->m_pMaterial->m_pbrMaterialParameters.m_defines.Has("DEF_alphaMode_BLEND")),
FALSE,
D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_OP_ADD,
D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
D3D12_LOGIC_OP_NOOP,
D3D12_COLOR_WRITE_ENABLE_ALL,
};
/////////////////////////////////////////////
// Create a PSO description
D3D12_GRAPHICS_PIPELINE_STATE_DESC descPso = {};
descPso.InputLayout = { layout.data(), (UINT)layout.size() };
descPso.pRootSignature = pPrimitive->m_RootSignature;
descPso.VS = shaderVert;
descPso.PS = shaderPixel;
descPso.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
descPso.RasterizerState.CullMode = (pPrimitive->m_pMaterial->m_pbrMaterialParameters.m_doubleSided) ? D3D12_CULL_MODE_NONE : D3D12_CULL_MODE_FRONT;
descPso.BlendState = blendState;
descPso.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
descPso.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL;
descPso.SampleMask = UINT_MAX;
descPso.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
descPso.NumRenderTargets = 1;
descPso.RTVFormats[0] = m_outFormat;
descPso.DSVFormat = DXGI_FORMAT_D32_FLOAT;
descPso.SampleDesc.Count = m_sampleCount;
descPso.NodeMask = 0;
ThrowIfFailed(
pDevice->CreateGraphicsPipelineState(&descPso, IID_PPV_ARGS(&pPrimitive->m_PipelineRender))
);
}
//--------------------------------------------------------------------------------------
//
// Draw
//
//--------------------------------------------------------------------------------------
void GltfPbrPass::Draw(ID3D12GraphicsCommandList* pCommandList)
{
UserMarker(pCommandList, "gltfPBR");
struct Transparent
{
float m_depth;
PBRPrimitives *m_pPrimitive;
D3D12_GPU_VIRTUAL_ADDRESS m_perFrameDesc;
D3D12_GPU_VIRTUAL_ADDRESS m_perObjectDesc;
D3D12_GPU_VIRTUAL_ADDRESS m_pPerSkeleton;
operator float() { return -m_depth; }
};
std::vector<Transparent> m_transparent;
// Set descriptor heaps
pCommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D12DescriptorHeap *pDescriptorHeaps[] = { m_pResourceViewHeaps->GetCBV_SRV_UAVHeap(), m_pResourceViewHeaps->GetSamplerHeap() };
pCommandList->SetDescriptorHeaps(2, pDescriptorHeaps);
// loop through nodes
//
std::vector<tfNode> *pNodes = &m_pGLTFTexturesAndBuffers->m_pGLTFCommon->m_nodes;
XMMATRIX *pNodesMatrices = m_pGLTFTexturesAndBuffers->m_pGLTFCommon->m_transformedData.m_worldSpaceMats.data();
for (uint32_t i = 0; i < pNodes->size(); i++)
{
tfNode *pNode = &pNodes->at(i);
if ((pNode == NULL) || (pNode->meshIndex < 0))
continue;
// skinning matrices constant buffer
D3D12_GPU_VIRTUAL_ADDRESS pPerSkeleton = m_pGLTFTexturesAndBuffers->GetSkinningMatricesBuffer(pNode->skinIndex);
// loop through primitives
//
PBRMesh *pMesh = &m_meshes[pNode->meshIndex];
for (uint32_t p = 0; p < pMesh->m_pPrimitives.size(); p++)
{
PBRPrimitives *pPrimitive = &pMesh->m_pPrimitives[p];
if (pPrimitive->m_PipelineRender == NULL)
continue;
// Set per Object constants
//
per_object *cbPerObject;
D3D12_GPU_VIRTUAL_ADDRESS perObjectDesc;
m_pDynamicBufferRing->AllocConstantBuffer(sizeof(per_object), (void **)&cbPerObject, &perObjectDesc);
cbPerObject->mWorld = pNodesMatrices[i];
PBRMaterialParameters *pPbrParams = &pPrimitive->m_pMaterial->m_pbrMaterialParameters;
cbPerObject->m_pbrParams = pPbrParams->m_params;
// Draw primitive
//
if (pPbrParams->m_blending == false)
{
// If solid draw it
//
pPrimitive->DrawPrimitive(pCommandList, m_pGLTFTexturesAndBuffers->m_perFrameConstants, perObjectDesc, pPerSkeleton);
}
else
{
// If transparent queue it for sorting
//
XMMATRIX mat = pNodesMatrices[i] * m_pGLTFTexturesAndBuffers->m_pGLTFCommon->m_perFrameData.mCameraViewProj;
XMVECTOR v = m_pGLTFTexturesAndBuffers->m_pGLTFCommon->m_meshes[pNode->meshIndex].m_pPrimitives[p].m_center;
Transparent t;
t.m_depth = XMVectorGetW(XMVector4Transform(v, mat));
t.m_pPrimitive = pPrimitive;
t.m_perFrameDesc = m_pGLTFTexturesAndBuffers->m_perFrameConstants;
t.m_perObjectDesc = perObjectDesc;
t.m_pPerSkeleton = pPerSkeleton;
m_transparent.push_back(t);
}
}
}
// sort transparent primitives
//
std::sort(m_transparent.begin(), m_transparent.end());
// Draw them sorted front to back
//
int tt = 0;
for (auto &t : m_transparent)
{
t.m_pPrimitive->DrawPrimitive(pCommandList, t.m_perFrameDesc, t.m_perObjectDesc, t.m_pPerSkeleton);
}
}
void PBRPrimitives::DrawPrimitive(ID3D12GraphicsCommandList *pCommandList, D3D12_GPU_VIRTUAL_ADDRESS perFrameDesc, D3D12_GPU_VIRTUAL_ADDRESS perObjectDesc, D3D12_GPU_VIRTUAL_ADDRESS pPerSkeleton)
{
// Bind indices and vertices using the right offsets into the buffer
//
pCommandList->IASetIndexBuffer(&m_geometry.m_IBV);
pCommandList->IASetVertexBuffers(0, (UINT)m_geometry.m_VBV.size(), m_geometry.m_VBV.data());
// Bind Descriptor sets
//
pCommandList->SetGraphicsRootSignature(m_RootSignature);
int paramIndex = 0;
// bind the per scene constant buffer descriptor
pCommandList->SetGraphicsRootConstantBufferView(paramIndex++, perFrameDesc);
// bind the textures and samplers descriptors
if (m_pMaterial->m_textureCount > 0)
{
pCommandList->SetGraphicsRootDescriptorTable(paramIndex++, m_pMaterial->m_texturesTable.GetGPU());
}
// bind the per object constant buffer descriptor
pCommandList->SetGraphicsRootConstantBufferView(paramIndex++, perObjectDesc);
// bind the skeleton bind matrices constant buffer descriptor
if (pPerSkeleton != 0)
pCommandList->SetGraphicsRootConstantBufferView(paramIndex++, pPerSkeleton);
// Bind Pipeline
//
pCommandList->SetPipelineState(m_PipelineRender);
// Draw
//
pCommandList->DrawIndexedInstanced(m_geometry.m_NumIndices, 1, 0, 0, 0);
}
} | 45.261036 | 203 | 0.584284 | TonyJennifer |
b491fa6871156142217c1b7732510bbdfc49c210 | 3,040 | hh | C++ | test/maple/MockSwitch.hh | Alexey-Ershov/runos | dfbf8f74d7f45d25f0d4fad743b51f572ec272c9 | [
"Apache-2.0"
] | 9 | 2019-04-04T18:03:36.000Z | 2019-05-03T23:48:59.000Z | test/maple/MockSwitch.hh | Alexey-Ershov/runos | dfbf8f74d7f45d25f0d4fad743b51f572ec272c9 | [
"Apache-2.0"
] | 16 | 2019-04-04T12:22:19.000Z | 2019-04-09T19:04:42.000Z | test/maple/MockSwitch.hh | Alexey-Ershov/runos | dfbf8f74d7f45d25f0d4fad743b51f572ec272c9 | [
"Apache-2.0"
] | 2 | 2019-10-11T14:17:26.000Z | 2022-03-15T10:06:08.000Z | #pragma once
#include <map>
#include <ostream>
#include <boost/test/unit_test.hpp>
#include "api/Packet.hh"
#include "oxm/field_set.hh"
#include "maple/Backend.hh"
#include "maple/Flow.hh"
namespace runos {
class MockSwitch : public maple::Backend {
using Flow = maple::Flow;
using FlowPtr = maple::FlowPtr;
struct Classifier {
unsigned prio;
oxm::field_set match;
friend bool operator== (const Classifier& lhs, const Classifier& rhs)
{ return lhs.prio == rhs.prio && lhs.match == rhs.match; }
friend bool operator< (const Classifier& lhs, const Classifier& rhs)
{ return lhs.prio > rhs.prio; }
friend std::ostream& operator<< (std::ostream& out, const Classifier& c)
{ return out << "prio=" << c.prio << ", " << c.match; }
};
typedef std::map< Classifier, FlowPtr >
FlowTable;
FlowPtr miss;
FlowTable flow_table;
public:
explicit MockSwitch(FlowPtr miss)
: miss(miss)
{ }
virtual void install(unsigned priority,
oxm::field_set const& fs,
FlowPtr flow) override
{
Classifier classifier {priority, fs};
BOOST_TEST_MESSAGE("Installing flow " << classifier);
BOOST_REQUIRE_MESSAGE(flow_table.emplace(classifier, flow).second,
"Overlapping flow " << classifier);
}
virtual void remove(FlowPtr flow) override
{
BOOST_TEST_MESSAGE("Removing flow " << flow);
for (auto it = flow_table.begin(); it != flow_table.end(); ++it) {
if (it->second == flow)
flow_table.erase(it);
}
}
virtual void remove(unsigned priority,
oxm::field_set const& match) override
{
Classifier key{ priority, std::move(match) };
BOOST_TEST_MESSAGE("Removing flow " << key);
for (auto it = flow_table.begin(); it != flow_table.end(); ++it) {
if (it->first == key)
flow_table.erase(it);
}
}
virtual void remove(oxm::field_set const& match) override
{
BOOST_TEST_MESSAGE("Removing flow " << match);
for (auto it = flow_table.begin(); it != flow_table.end(); ++it) {
if (it->first.match == match)
flow_table.erase(it);
}
}
FlowPtr operator()(const Packet& pkt) const
{
auto it = flow_table.cbegin();
auto match = flow_table.cend();
for (; it != flow_table.cend(); ++it) {
if (it->first.match & pkt) {
match = it;
break;
}
}
if (it != flow_table.cend())
++it;
for (; it != flow_table.cend() &&
it->first.prio == match->first.prio;
++it)
{
BOOST_REQUIRE( not (it->first.match & pkt) );
}
if (match != flow_table.cend())
return match->second;
else
return miss;
}
};
}
| 27.142857 | 80 | 0.536842 | Alexey-Ershov |
b493cd7548c9022d25a50a0e387a5b3d3e8e5e68 | 12,165 | cpp | C++ | Gui/gui/MainWindowBase.cpp | igui/OppositeRenderer | 2442741792b3f0f426025c2015002694fab692eb | [
"MIT"
] | 9 | 2016-06-25T15:52:05.000Z | 2020-01-15T17:31:49.000Z | Gui/gui/MainWindowBase.cpp | igui/OppositeRenderer | 2442741792b3f0f426025c2015002694fab692eb | [
"MIT"
] | null | null | null | Gui/gui/MainWindowBase.cpp | igui/OppositeRenderer | 2442741792b3f0f426025c2015002694fab692eb | [
"MIT"
] | 2 | 2018-10-17T18:33:37.000Z | 2022-03-14T20:17:30.000Z | /*
* Copyright (c) 2013 Opposite Renderer
* For the full copyright and license information, please view the LICENSE.txt
* file that was distributed with this source code.
*/
#include "Application.hxx"
#include "MainWindowBase.hxx"
#include "renderer/OptixRenderer.h"
#include <QString>
#include <QMessageBox>
#include <QStandardPaths>
#include "RenderWidget.hxx"
#include "gui/AboutWindow.hxx"
#include "gui/ComputeDeviceInformationWidget.hxx"
#include "gui/docks/RenderInformationDock.hxx"
#include "gui/docks/OutputDock.hxx"
#include "gui/docks/PPMDock.hxx"
#include "gui/docks/CameraDock.hxx"
#include "gui/docks/SceneDock.hxx"
#include "gui/docks/ConsoleDock.hxx"
#include "ComputeDeviceRepository.h"
#include "config.h"
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qlineedit.h>
#include "gui/ui/resources.h"
const int MainWindowBase::maxRecentFiles = 5;
MainWindowBase::MainWindowBase(Application& application)
: m_application(application),
m_camera(application.getCamera())
{
setupUi(this);
actionReload_scene->setVisible(false);
//connect(&application.getOutputSettingsModel(), SIGNAL(resolutionUpdated()), this, SLOT(onOutputSettingsResolutionUpdated()));
//connect(&application.getPPMSettingsModel(), SIGNAL(updated()), this, SLOT(onPPMSettingsModelUpdated()));
connect(&application, SIGNAL(applicationError(QString)), this, SLOT(onApplicationError(QString)));
// Render Information Dock
RenderInformationDock* renderInformationDock = new RenderInformationDock(this, application.getRenderStatisticsModel(), application);
this->addDockWidget(Qt::RightDockWidgetArea, renderInformationDock);
connect(renderInformationDock, SIGNAL(renderStatusToggle()), this, SLOT(onRenderStatusToggle()));
connect(renderInformationDock, SIGNAL(renderRestart()), this, SLOT(onRenderRestart()));
// Output Dock
OutputDock* outputDock = new OutputDock(this, application.getOutputSettingsModel());
this->addDockWidget(Qt::RightDockWidgetArea, outputDock);
// PPM Information dock
PPMDock* ppmDock = new PPMDock(this, m_application, m_application.getPPMSettingsModel());
this->addDockWidget(Qt::RightDockWidgetArea, ppmDock);
// Camera Dock
CameraDock* cameraDock = new CameraDock(this, application.getCamera(), application.getPPMSettingsModel(), application.getOutputSettingsModel());
this->addDockWidget(Qt::RightDockWidgetArea, cameraDock);
connect(&application, SIGNAL(cameraUpdated()), cameraDock, SLOT(onCameraUpdated()));
connect(cameraDock, SIGNAL(cameraUpdated()), &application, SLOT(onCameraUpdated()));
// Scene Dock
SceneDock* sceneDock = new SceneDock(this, application.getSceneManager());
this->addDockWidget(Qt::RightDockWidgetArea, sceneDock);
// Console Dock
ConsoleDock *consoleDock = new ConsoleDock(this);
this->m_consoleDock = consoleDock;
this->addDockWidget(Qt::BottomDockWidgetArea, consoleDock);
// Status Bar Running Status and Time
m_statusbar_runningStatusLabel = new QLabel(this);
this->statusBar()->addPermanentWidget(m_statusbar_runningStatusLabel, 1);
m_statusbar_runningStatusLabel->setGeometry(100, 0, 100, 12);
QTimer* runningStatusLabelTimer = new QTimer(this);
runningStatusLabelTimer->setInterval(100);
connect(runningStatusLabelTimer, SIGNAL(timeout()), this, SLOT(onUpdateRunningStatusLabelTimer()));
runningStatusLabelTimer->start();
// Status Bar Render Method
m_statusbar_renderMethodLabel = new QLabel(this);
this->statusBar()->addPermanentWidget(m_statusbar_renderMethodLabel, 1);
m_statusbar_renderMethodLabel->setGeometry(100, 0, 100, 12);
// Render Widget
m_renderWidget = new RenderWidget(centralwidget, application.getCamera(), application.getOutputSettingsModel());
gridLayout->addWidget(m_renderWidget, 0, 0, 1, 1);
connect(m_renderWidget, SIGNAL(cameraUpdated()), &application, SLOT(onCameraUpdated()));
connect(&application, SIGNAL(newFrameReadyForDisplay(const float*, unsigned long long)),
m_renderWidget, SLOT(onNewFrameReadyForDisplay(const float*, unsigned long long)),
Qt::QueuedConnection);
connect(&application, SIGNAL(runningStatusChanged()), this, SLOT(onRunningStatusChanged()));
connect(&application, SIGNAL(renderMethodChanged()), this, SLOT(onRenderMethodChanged()));
connect(this, SIGNAL(renderRestart()), &m_application, SLOT(onRenderRestart()));
connect(this, SIGNAL(renderStatusToggle()), &m_application, SLOT(onRenderStatusToggle()));
// recent files
for (int i = 0; i < maxRecentFiles; ++i) {
QAction *action = new QAction(this);
action->setVisible(false);
connect(action, SIGNAL(triggered()),
this, SLOT(onOpenRecentFile()));
menuFile->insertAction(actionQuit, action);
m_recentFileActions.append(action);
}
m_recentActionsSeparator = new QAction(this);
m_recentActionsSeparator->setSeparator(true);
menuFile->insertAction(actionQuit, m_recentActionsSeparator);
connect(this, SIGNAL(recentFilesChanged()), this, SLOT(onRecentFilesChanged()));
connect(&application.getSceneManager(), SIGNAL(sceneUpdated()), this, SLOT(onSceneUpdated()));
onRunningStatusChanged();
onRenderMethodChanged();
onRecentFilesChanged();
}
void MainWindowBase::closeEvent( QCloseEvent* event )
{
}
ConsoleDock *MainWindowBase::consoleDock()
{
return m_consoleDock;
}
MainWindowBase::~MainWindowBase()
{
}
void MainWindowBase::onActionAbout()
{
AboutWindow* aboutWindow = new AboutWindow(this);
aboutWindow->show();
connect(aboutWindow, SIGNAL(finished()), aboutWindow, SLOT(deleteLater()));
}
void MainWindowBase::onRenderStatusToggle()
{
emit renderStatusToggle();
}
void MainWindowBase::onSetCameraToDefault()
{
m_application.setCameraToSceneDefault();
}
void MainWindowBase::onChangeRenderMethodPM()
{
m_application.setRenderMethod(RenderMethod::PHOTON_MAPPING);
emit renderRestart();
}
void MainWindowBase::onChangeRenderMethodPPM()
{
m_application.setRenderMethod(RenderMethod::PROGRESSIVE_PHOTON_MAPPING);
emit renderRestart();
}
void MainWindowBase::onChangeRenderMethodPT()
{
m_application.setRenderMethod(RenderMethod::PATH_TRACING);
emit renderRestart();
}
void MainWindowBase::onConfigureGPUDevices()
{
/*QDialog* dialog = new QDialog(this);
ComputeDeviceInformationWidget* widget = new ComputeDeviceInformationWidget(dialog, ComputeDeviceRepository::get());
dialog->show();*/
}
void MainWindowBase::onOpenSceneFile()
{
QString desktopDir = QStandardPaths::locate(QStandardPaths::DesktopLocation, "", QStandardPaths::LocateDirectory);
QString fileName = QFileDialog::getOpenFileName(
this,
tr("Open File"),
desktopDir,
tr("Scene files (*.dae *.blend *.3ds);;Any(*.*)")
);
if(fileName.length() > 0)
{
m_lastOpenedSceneFile = QFileInfo(fileName);
actionReload_scene->setText(QString("Reload last scene (%1)").arg(m_lastOpenedSceneFile.completeBaseName()));
actionReload_scene->setVisible(true);
loadSceneByName(fileName);
}
}
void MainWindowBase::onRunningStatusChanged()
{
if(m_application.getRunningStatus() == RunningStatus::RUNNING)
{
actionRenderStatusToggle->setText("Pause");
}
else if(m_application.getRunningStatus() == RunningStatus::STOPPED)
{
actionRenderStatusToggle->setText("Start");
}
}
void MainWindowBase::onRenderMethodChanged()
{
QString str;
if(m_application.getRenderMethod() == RenderMethod::PATH_TRACING)
{
str = "Path Tracing";
}
else
{
str = "Progressive Photon Mapping";
if(ACCELERATION_STRUCTURE == ACCELERATION_STRUCTURE_UNIFORM_GRID)
{
str += " (Sorted uniform grid)";
}
else if(ACCELERATION_STRUCTURE == ACCELERATION_STRUCTURE_KD_TREE_CPU)
{
str += " (CPU k-d tree)";
}
else if(ACCELERATION_STRUCTURE == ACCELERATION_STRUCTURE_STOCHASTIC_HASH)
{
str += " (Stochastic hash)";
}
}
m_statusbar_renderMethodLabel->setText(QString("Render method: ") + str);
}
void MainWindowBase::onUpdateRunningStatusLabelTimer()
{
m_statusbar_runningStatusLabel->setText(QString("Status: ") + getApplicationStatusString(m_application));
}
void MainWindowBase::loadSceneByName( QString & sceneName )
{
try
{
m_application.getSceneManager().setScene(sceneName.toUtf8().constData());
}
catch(const std::exception & E)
{
QMessageBox::warning(this, "Error loading scene file", QString(E.what()));
}
catch(...)
{
QMessageBox::warning(this, "Unknown error", "Unknown error happened when importing this scene. This is not a valid scene.");
}
}
void MainWindowBase::onReloadLastScene()
{
if(m_lastOpenedSceneFile.exists())
{
loadSceneByName(m_lastOpenedSceneFile.canonicalFilePath());
}
}
void MainWindowBase::onActionOpenBuiltInScene()
{
bool ok;
QString sceneName = QInputDialog::getText(this, tr("Please provide a built-in scene name"),
tr("Name (customscene/ class name):"), QLineEdit::Normal, "", &ok);
if (ok && !sceneName.isEmpty())
{
loadSceneByName(sceneName);
}
}
void MainWindowBase::onRenderRestart()
{
emit renderRestart();
}
void MainWindowBase::onApplicationError( QString appError )
{
QMessageBox::warning(this, "An application error occurred", appError);
}
QString MainWindowBase::getApplicationStatusString(const Application & application, bool showSeconds)
{
QString status = "";
if(application.getSceneManager().getStatus() == SceneManagerStatus::IMPORTING)
{
status += "Importing scene";
}
else if(application.getRunningStatus() == RunningStatus::STOPPED)
{
status += "Stopped";
}
else if(application.getRunningStatus() == RunningStatus::PAUSE)
{
status += "Pause";
}
else
{
if(application.getRendererStatus() == RendererStatus::NOT_INITIALIZED)
{
status += "Not initialized";
}
else if(application.getRendererStatus() == RendererStatus::INITIALIZING_ENGINE)
{
status += "Initializing engine";
}
else if(application.getRendererStatus() == RendererStatus::INITIALIZING_SCENE)
{
status += "Initializing scene";
}
else if(application.getRendererStatus() == RendererStatus::RENDERING)
{
status += "Running";
if(showSeconds)
{
status += QString(" (%1 seconds)").arg(application.getRenderTimeSeconds(), 0, 'f', 1);
}
}
}
return status;
}
void MainWindowBase::onActionSaveImagePPM()
{
printf("Save image as PPM!");
}
void MainWindowBase::onRecentFilesChanged()
{
QStringList files = QSettings().value("recentFileList").toStringList();
int numRecentFiles = qMin(files.size(), maxRecentFiles);
for (int i = 0; i < numRecentFiles; ++i) {
QString strippedName = QFileInfo(files[i]).fileName();
QString text = tr("&%1 %2").arg(i + 1).arg(strippedName);
m_recentFileActions[i]->setText(text);
m_recentFileActions[i]->setData(files[i]);
m_recentFileActions[i]->setVisible(true);
}
for (int j = numRecentFiles; j < maxRecentFiles; ++j)
m_recentFileActions[j]->setVisible(false);
m_recentActionsSeparator->setVisible(numRecentFiles > 0);
}
void MainWindowBase::onOpenRecentFile()
{
QAction *action = qobject_cast<QAction *>(sender());
if (action){
QString fileName = action->data().toString();
loadSceneByName(fileName);
}
}
void MainWindowBase::onSceneUpdated()
{
QString fileName = m_application.getSceneManager().getScene()->getSceneName();
QSettings settings;
QStringList files = settings.value("recentFileList").toStringList();
files.removeAll(fileName);
files.prepend(fileName);
while (files.size() > maxRecentFiles)
files.removeLast();
settings.setValue("recentFileList", files);
emit onRecentFilesChanged();
} | 32.013158 | 148 | 0.707028 | igui |
b4946609ec6aeb7f5c34e3a25774331781473ebd | 105 | cpp | C++ | src/bot/Malware/SharedKernel/Processors/processorresolverbase.cpp | jsdelivrbot/eductional-botnet | 7cd021c176331cc0642f4b92a5a7b598df610c37 | [
"MIT"
] | 8 | 2017-05-01T19:37:15.000Z | 2021-08-05T04:03:38.000Z | src/bot/Malware/SharedKernel/Processors/processorresolverbase.cpp | jsdelivrbot/eductional-botnet | 7cd021c176331cc0642f4b92a5a7b598df610c37 | [
"MIT"
] | null | null | null | src/bot/Malware/SharedKernel/Processors/processorresolverbase.cpp | jsdelivrbot/eductional-botnet | 7cd021c176331cc0642f4b92a5a7b598df610c37 | [
"MIT"
] | 4 | 2018-01-25T19:26:02.000Z | 2021-05-14T14:37:38.000Z | #include "processorresolverbase.h"
using namespace network::messages::server;
namespace processors
{
}
| 13.125 | 42 | 0.790476 | jsdelivrbot |
b4955daf50bfddcf5527694d94e5dbf83e7b6cb7 | 6,513 | cxx | C++ | applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | /*=========================================================================
*
* Copyright RTK Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#include "rtkdualenergyforwardmodel_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkConfiguration.h"
#include "rtkMacro.h"
#include "rtkSpectralForwardModelImageFilter.h"
#include "rtkConstantImageSource.h"
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
int main(int argc, char * argv[])
{
GGO(rtkdualenergyforwardmodel, args_info);
typedef float PixelValueType;
const unsigned int Dimension = 3;
typedef itk::VectorImage< PixelValueType, Dimension > DecomposedProjectionType;
typedef itk::ImageFileReader<DecomposedProjectionType> DecomposedProjectionReaderType;
typedef itk::VectorImage< PixelValueType, Dimension > DualEnergyProjectionsType;
typedef itk::ImageFileWriter< DualEnergyProjectionsType > DualEnergyProjectionWriterType;
typedef itk::VectorImage< PixelValueType, Dimension-1 > IncidentSpectrumImageType;
typedef itk::ImageFileReader<IncidentSpectrumImageType> IncidentSpectrumReaderType;
typedef itk::Image< PixelValueType, Dimension-1 > DetectorResponseImageType;
typedef itk::ImageFileReader<DetectorResponseImageType> DetectorResponseReaderType;
typedef itk::Image< PixelValueType, Dimension-1 > MaterialAttenuationsImageType;
typedef itk::ImageFileReader<MaterialAttenuationsImageType> MaterialAttenuationsReaderType;
// Read all inputs
DecomposedProjectionReaderType::Pointer decomposedProjectionReader = DecomposedProjectionReaderType::New();
decomposedProjectionReader->SetFileName( args_info.input_arg );
decomposedProjectionReader->Update();
IncidentSpectrumReaderType::Pointer incidentSpectrumReaderHighEnergy = IncidentSpectrumReaderType::New();
incidentSpectrumReaderHighEnergy->SetFileName( args_info.high_arg );
incidentSpectrumReaderHighEnergy->Update();
IncidentSpectrumReaderType::Pointer incidentSpectrumReaderLowEnergy = IncidentSpectrumReaderType::New();
incidentSpectrumReaderLowEnergy->SetFileName( args_info.low_arg );
incidentSpectrumReaderLowEnergy->Update();
MaterialAttenuationsReaderType::Pointer materialAttenuationsReader = MaterialAttenuationsReaderType::New();
materialAttenuationsReader->SetFileName( args_info.attenuations_arg );
materialAttenuationsReader->Update();
// If the detector response is given by the user, use it. Otherwise, assume it is included in the
// incident spectrum, and fill the response with ones
DetectorResponseReaderType::Pointer detectorResponseReader = DetectorResponseReaderType::New();
DetectorResponseImageType::Pointer detectorImage;
if(args_info.detector_given)
{
detectorResponseReader->SetFileName( args_info.detector_arg );
detectorResponseReader->Update();
detectorImage = detectorResponseReader->GetOutput();
}
else
{
rtk::ConstantImageSource<DetectorResponseImageType>::Pointer detectorSource = rtk::ConstantImageSource<DetectorResponseImageType>::New();
DetectorResponseImageType::SizeType sourceSize;
sourceSize[0] = 1;
sourceSize[1] = incidentSpectrumReaderHighEnergy->GetOutput()->GetVectorLength();
detectorSource->SetSize(sourceSize);
detectorSource->SetConstant(1.0);
detectorSource->Update();
detectorImage = detectorSource->GetOutput();
}
// Get parameters from the images
const unsigned int MaximumEnergy = incidentSpectrumReaderHighEnergy->GetOutput()->GetVectorLength();
// Generate a set of zero-filled intensity projections
DualEnergyProjectionsType::Pointer dualEnergyProjections = DualEnergyProjectionsType::New();
dualEnergyProjections->CopyInformation(decomposedProjectionReader->GetOutput());
dualEnergyProjections->SetVectorLength(2);
dualEnergyProjections->Allocate();
// Check that the inputs have the expected size
DecomposedProjectionType::IndexType indexDecomp;
indexDecomp.Fill(0);
if (decomposedProjectionReader->GetOutput()->GetVectorLength() != 2)
itkGenericExceptionMacro(<< "Decomposed projections (i.e. initialization data) image has vector length "
<< decomposedProjectionReader->GetOutput()->GetVectorLength()
<< ", should be 2");
if (materialAttenuationsReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1] != MaximumEnergy)
itkGenericExceptionMacro(<< "Material attenuations image has "
<< materialAttenuationsReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]
<< "energies, should have "
<< MaximumEnergy);
// Create and set the filter
typedef rtk::SpectralForwardModelImageFilter<DecomposedProjectionType, DualEnergyProjectionsType> ForwardModelFilterType;
ForwardModelFilterType::Pointer forward = ForwardModelFilterType::New();
forward->SetInputDecomposedProjections(decomposedProjectionReader->GetOutput());
forward->SetInputMeasuredProjections(dualEnergyProjections);
forward->SetInputIncidentSpectrum(incidentSpectrumReaderHighEnergy->GetOutput());
forward->SetInputSecondIncidentSpectrum(incidentSpectrumReaderLowEnergy->GetOutput());
forward->SetDetectorResponse(detectorImage);
forward->SetMaterialAttenuations(materialAttenuationsReader->GetOutput());
forward->SetIsSpectralCT(false);
forward->SetComputeVariances(args_info.variances_given);
TRY_AND_EXIT_ON_ITK_EXCEPTION(forward->Update())
// Write output
DualEnergyProjectionWriterType::Pointer writer = DualEnergyProjectionWriterType::New();
writer->SetInput(forward->GetOutput());
writer->SetFileName(args_info.output_arg);
writer->Update();
// If requested, write the variances
if (args_info.variances_given)
{
writer->SetInput(forward->GetOutput(1));
writer->SetFileName(args_info.variances_arg);
writer->Update();
}
return EXIT_SUCCESS;
}
| 45.545455 | 141 | 0.758483 | cyrilmory |
b49a98e656312b3e2676cc20919bac02e1428e90 | 12,016 | cc | C++ | content/renderer/media/android/renderer_media_player_manager.cc | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2019-01-28T08:09:58.000Z | 2021-11-15T15:32:10.000Z | content/renderer/media/android/renderer_media_player_manager.cc | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | content/renderer/media/android/renderer_media_player_manager.cc | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 6 | 2020-09-23T08:56:12.000Z | 2021-11-18T03:40:49.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/media/android/renderer_media_player_manager.h"
#include "base/command_line.h"
#include "content/common/media/media_player_messages_android.h"
#include "content/public/common/renderer_preferences.h"
#include "content/renderer/media/android/webmediaplayer_android.h"
#include "content/renderer/media/cdm/renderer_cdm_manager.h"
#include "content/renderer/render_view_impl.h"
#include "media/base/cdm_context.h"
#include "media/base/media_switches.h"
#include "ui/gfx/geometry/rect_f.h"
namespace content {
RendererMediaPlayerManager::RendererMediaPlayerManager(
RenderFrame* render_frame)
: RenderFrameObserver(render_frame),
next_media_player_id_(0) {
}
RendererMediaPlayerManager::~RendererMediaPlayerManager() {
DCHECK(media_players_.empty())
<< "RendererMediaPlayerManager is owned by RenderFrameImpl and is "
"destroyed only after all media players are destroyed.";
}
bool RendererMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(RendererMediaPlayerManager, msg)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaMetadataChanged,
OnMediaMetadataChanged)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlaybackCompleted,
OnMediaPlaybackCompleted)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaBufferingUpdate,
OnMediaBufferingUpdate)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekRequest, OnSeekRequest)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekCompleted, OnSeekCompleted)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaError, OnMediaError)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaVideoSizeChanged,
OnVideoSizeChanged)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaTimeUpdate, OnTimeUpdate)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_WaitingForDecryptionKey,
OnWaitingForDecryptionKey)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlayerReleased,
OnMediaPlayerReleased)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_ConnectedToRemoteDevice,
OnConnectedToRemoteDevice)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DisconnectedFromRemoteDevice,
OnDisconnectedFromRemoteDevice)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_CancelledRemotePlaybackRequest,
OnCancelledRemotePlaybackRequest)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_RemoteRouteAvailabilityChanged,
OnRemoteRouteAvailabilityChanged)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void RendererMediaPlayerManager::Initialize(
MediaPlayerHostMsg_Initialize_Type type,
int player_id,
const GURL& url,
const GURL& first_party_for_cookies,
int demuxer_client_id,
const GURL& frame_url,
bool allow_credentials,
int delegate_id,
int media_session_id) {
MediaPlayerHostMsg_Initialize_Params media_player_params;
media_player_params.type = type;
media_player_params.player_id = player_id;
media_player_params.demuxer_client_id = demuxer_client_id;
media_player_params.url = url;
media_player_params.first_party_for_cookies = first_party_for_cookies;
media_player_params.frame_url = frame_url;
media_player_params.allow_credentials = allow_credentials;
media_player_params.delegate_id = delegate_id;
media_player_params.media_session_id = media_session_id;
Send(new MediaPlayerHostMsg_Initialize(routing_id(), media_player_params));
}
void RendererMediaPlayerManager::Start(int player_id) {
Send(new MediaPlayerHostMsg_Start(routing_id(), player_id));
}
void RendererMediaPlayerManager::Pause(
int player_id,
bool is_media_related_action) {
Send(new MediaPlayerHostMsg_Pause(
routing_id(), player_id, is_media_related_action));
}
void RendererMediaPlayerManager::Seek(
int player_id,
const base::TimeDelta& time) {
Send(new MediaPlayerHostMsg_Seek(routing_id(), player_id, time));
}
void RendererMediaPlayerManager::SetVolume(int player_id, double volume) {
Send(new MediaPlayerHostMsg_SetVolume(routing_id(), player_id, volume));
}
void RendererMediaPlayerManager::SetPoster(int player_id, const GURL& poster) {
Send(new MediaPlayerHostMsg_SetPoster(routing_id(), player_id, poster));
}
void RendererMediaPlayerManager::SuspendAndReleaseResources(int player_id) {
Send(new MediaPlayerHostMsg_SuspendAndRelease(routing_id(), player_id));
}
void RendererMediaPlayerManager::DestroyPlayer(int player_id) {
Send(new MediaPlayerHostMsg_DestroyMediaPlayer(routing_id(), player_id));
}
void RendererMediaPlayerManager::RequestRemotePlayback(int player_id) {
Send(new MediaPlayerHostMsg_RequestRemotePlayback(routing_id(), player_id));
}
void RendererMediaPlayerManager::RequestRemotePlaybackControl(int player_id) {
Send(new MediaPlayerHostMsg_RequestRemotePlaybackControl(routing_id(),
player_id));
}
void RendererMediaPlayerManager::OnMediaMetadataChanged(
int player_id,
base::TimeDelta duration,
int width,
int height,
bool success) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnMediaMetadataChanged(duration, width, height, success);
}
void RendererMediaPlayerManager::OnMediaPlaybackCompleted(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnPlaybackComplete();
}
void RendererMediaPlayerManager::OnMediaBufferingUpdate(int player_id,
int percent) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnBufferingUpdate(percent);
}
void RendererMediaPlayerManager::OnSeekRequest(
int player_id,
const base::TimeDelta& time_to_seek) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnSeekRequest(time_to_seek);
}
void RendererMediaPlayerManager::OnSeekCompleted(
int player_id,
const base::TimeDelta& current_time) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnSeekComplete(current_time);
}
void RendererMediaPlayerManager::OnMediaError(int player_id, int error) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnMediaError(error);
}
void RendererMediaPlayerManager::OnVideoSizeChanged(int player_id,
int width,
int height) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnVideoSizeChanged(width, height);
}
void RendererMediaPlayerManager::OnTimeUpdate(
int player_id,
base::TimeDelta current_timestamp,
base::TimeTicks current_time_ticks) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnTimeUpdate(current_timestamp, current_time_ticks);
}
void RendererMediaPlayerManager::OnWaitingForDecryptionKey(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnWaitingForDecryptionKey();
}
void RendererMediaPlayerManager::OnMediaPlayerReleased(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnPlayerReleased();
}
void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id,
const std::string& remote_playback_message) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnConnectedToRemoteDevice(remote_playback_message);
}
void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnDisconnectedFromRemoteDevice();
}
void RendererMediaPlayerManager::OnCancelledRemotePlaybackRequest(
int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnCancelledRemotePlaybackRequest();
}
void RendererMediaPlayerManager::OnDidExitFullscreen(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnDidExitFullscreen();
}
void RendererMediaPlayerManager::OnPlayerPlay(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnMediaPlayerPlay();
}
void RendererMediaPlayerManager::OnPlayerPause(int player_id) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnMediaPlayerPause();
}
void RendererMediaPlayerManager::OnRemoteRouteAvailabilityChanged(
int player_id,
bool routes_available) {
media::RendererMediaPlayerInterface* player = GetMediaPlayer(player_id);
if (player)
player->OnRemoteRouteAvailabilityChanged(routes_available);
}
void RendererMediaPlayerManager::EnterFullscreen(int player_id) {
Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
}
void RendererMediaPlayerManager::SetCdm(int player_id, int cdm_id) {
if (cdm_id == media::CdmContext::kInvalidCdmId) {
NOTREACHED();
return;
}
Send(new MediaPlayerHostMsg_SetCdm(routing_id(), player_id, cdm_id));
}
int RendererMediaPlayerManager::RegisterMediaPlayer(
media::RendererMediaPlayerInterface* player) {
media_players_[next_media_player_id_] = player;
return next_media_player_id_++;
}
void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
media_players_.erase(player_id);
}
media::RendererMediaPlayerInterface* RendererMediaPlayerManager::GetMediaPlayer(
int player_id) {
std::map<int, media::RendererMediaPlayerInterface*>::iterator iter =
media_players_.find(player_id);
if (iter != media_players_.end())
return iter->second;
return NULL;
}
void RendererMediaPlayerManager::OnDestruct() {
delete this;
}
#if defined(VIDEO_HOLE)
void RendererMediaPlayerManager::RequestExternalSurface(
int player_id,
const gfx::RectF& geometry) {
Send(new MediaPlayerHostMsg_NotifyExternalSurface(
routing_id(), player_id, true, geometry));
}
void RendererMediaPlayerManager::DidCommitCompositorFrame() {
std::map<int, gfx::RectF> geometry_change;
RetrieveGeometryChanges(&geometry_change);
for (std::map<int, gfx::RectF>::iterator it = geometry_change.begin();
it != geometry_change.end();
++it) {
Send(new MediaPlayerHostMsg_NotifyExternalSurface(
routing_id(), it->first, false, it->second));
}
}
void RendererMediaPlayerManager::RetrieveGeometryChanges(
std::map<int, gfx::RectF>* changes) {
DCHECK(changes->empty());
for (std::map<int, media::RendererMediaPlayerInterface*>::iterator player_it =
media_players_.begin();
player_it != media_players_.end();
++player_it) {
media::RendererMediaPlayerInterface* player = player_it->second;
if (player && player->hasVideo()) {
if (player->UpdateBoundaryRectangle())
(*changes)[player_it->first] = player->GetBoundaryRectangle();
}
}
}
bool
RendererMediaPlayerManager::ShouldUseVideoOverlayForEmbeddedEncryptedVideo() {
const RendererPreferences& prefs = static_cast<RenderFrameImpl*>(
render_frame())->render_view()->renderer_preferences();
return prefs.use_video_overlay_for_embedded_encrypted_video;
}
#endif // defined(VIDEO_HOLE)
} // namespace content
| 36.192771 | 80 | 0.764148 | Wzzzx |
a3335aaca6be045e10a2ce5d019d2de716834385 | 1,350 | hpp | C++ | NeuralNetworkCode/src/Stimulus/Stimulus.hpp | SFB1089/BrainCode | d7fab1f455c2c58f9be73be47e9f4538b426155c | [
"MIT"
] | null | null | null | NeuralNetworkCode/src/Stimulus/Stimulus.hpp | SFB1089/BrainCode | d7fab1f455c2c58f9be73be47e9f4538b426155c | [
"MIT"
] | null | null | null | NeuralNetworkCode/src/Stimulus/Stimulus.hpp | SFB1089/BrainCode | d7fab1f455c2c58f9be73be47e9f4538b426155c | [
"MIT"
] | null | null | null | #ifndef Stimulus_HPP
#define Stimulus_HPP
#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include <random>
#include <fstream>
#include "../GlobalFunctions.hpp"
#include "../NeuronPopSample.hpp"
/* class Stimulus is a virtual base class for injecting a determined
* current into each neuron during each time step.
* - double current(int neuronId, int populationId) returns the current for the
* current time step
* - void timeStepFinished() needs to be called after one time step is finished.
* It updates the stimulus object, if neccessary
* - get_raw_stimulus(int neuronId, int populationId) returns some non-
* normalized version of the input current as specified.
*/
class Stimulus
{
protected:
GlobalSimInfo * info;
NeuronPopSample * neurons;
double ** signal_array;
public:
Stimulus(NeuronPopSample * neur,GlobalSimInfo * info);
virtual ~Stimulus() { delete [] signal_array;}
virtual void Update(std::vector<std::vector<double>> * synaptic_dV) ;
virtual std::string GetType() = 0;
virtual void SaveParameters(std::ofstream * stream);
virtual void LoadParameters(std::vector<std::string> *input){}
double GetSignalArray(int p,int i){return signal_array[p][i];}
};
#endif //Stimulus_HPP
| 30.681818 | 81 | 0.691852 | SFB1089 |
a3340fae155e9100cf02236a6d99062b31766727 | 5,177 | cxx | C++ | Libraries/ITK/Testing/BoundaryShiftIntegral/itkBinaryIntersectWithPaddingImageFilterTest.cxx | NifTK/NifTK | 2358b333c89ff1bba1c232eecbbcdc8003305dfe | [
"BSD-3-Clause"
] | 13 | 2018-07-28T13:36:38.000Z | 2021-11-01T19:17:39.000Z | Libraries/ITK/Testing/BoundaryShiftIntegral/itkBinaryIntersectWithPaddingImageFilterTest.cxx | NifTK/NifTK | 2358b333c89ff1bba1c232eecbbcdc8003305dfe | [
"BSD-3-Clause"
] | null | null | null | Libraries/ITK/Testing/BoundaryShiftIntegral/itkBinaryIntersectWithPaddingImageFilterTest.cxx | NifTK/NifTK | 2358b333c89ff1bba1c232eecbbcdc8003305dfe | [
"BSD-3-Clause"
] | 10 | 2018-08-20T07:06:00.000Z | 2021-07-07T07:55:27.000Z | /*=============================================================================
NifTK: A software platform for medical image computing.
Copyright (c) University College London (UCL). All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.
See LICENSE.txt in the top level directory for details.
=============================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include <itkImage.h>
#include <itkNumericTraits.h>
#include <itkBinaryIntersectWithPaddingImageFilter.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <time.h>
/**
* Test the BinaryIntersectWithPaddingImageFilter by generating 256x256x256 images
* and filling them with random values between 0 to 4, then testing whether
* the output image is generated correctly.
*/
int itkBinaryIntersectWithPaddingImageFilterTest(int, char* [])
{
srand(time(NULL));
// Define the dimension of the images
const unsigned int Dimension = 3;
const unsigned char IntensityRange = 5;
const unsigned char PaddingValue = 3;
// Declare the types of the images
typedef unsigned char PixelType;
typedef itk::Image<PixelType, Dimension> ImageType1;
typedef itk::Image<PixelType, Dimension> ImageType2;
// Declare the type of the index to access images
typedef itk::Index<Dimension> IndexType;
// Declare the type of the size
typedef itk::Size<Dimension> SizeType;
// Declare the type of the Region
typedef itk::ImageRegion<Dimension> RegionType;
// Declare the type for the ADD filter
typedef itk::BinaryIntersectWithPaddingImageFilter< ImageType1,
ImageType2 > FilterType;
// Declare the pointers to images
typedef ImageType1::Pointer ImageType1Pointer;
typedef ImageType2::Pointer ImageType2Pointer;
typedef FilterType::Pointer FilterTypePointer;
// Create two images
ImageType1Pointer inputImageA = ImageType1::New();
ImageType2Pointer inputImageB = ImageType1::New();
// Define their size, and start index
SizeType size;
size[0] = 256;
size[1] = 256;
size[2] = 256;
IndexType start;
start[0] = 0;
start[1] = 0;
start[2] = 0;
RegionType region;
region.SetIndex( start );
region.SetSize( size );
// Initialize Image A
inputImageA->SetLargestPossibleRegion( region );
inputImageA->SetBufferedRegion( region );
inputImageA->SetRequestedRegion( region );
inputImageA->Allocate();
// Initialize Image B
inputImageB->SetLargestPossibleRegion( region );
inputImageB->SetBufferedRegion( region );
inputImageB->SetRequestedRegion( region );
inputImageB->Allocate();
// Declare Iterator types apropriated for each image
typedef itk::ImageRegionIteratorWithIndex<ImageType1> IteratorType1;
typedef itk::ImageRegionIteratorWithIndex<ImageType2> IteratorType2;
// Create one iterator for Image A (this is a light object)
IteratorType1 it1( inputImageA, inputImageA->GetBufferedRegion() );
it1.GoToBegin();
// Initialize the content of Image A
std::cout << "First operand " << std::endl;
while( !it1.IsAtEnd() )
{
it1.Set( rand()%IntensityRange );
//std::cout << static_cast<itk::NumericTraits<PixelType>::PrintType>(it1.Get()) << std::endl;
++it1;
}
// Create one iterator for Image B (this is a light object)
IteratorType1 it2( inputImageB, inputImageB->GetBufferedRegion() );
it2.GoToBegin();
// Initialize the content of Image B
std::cout << "Second operand " << std::endl;
while( !it2.IsAtEnd() )
{
it2.Set( rand()%IntensityRange );
//std::cout << static_cast<itk::NumericTraits<PixelType>::PrintType>(it2.Get()) << std::endl;
++it2;
}
// Create an ADD Filter
FilterTypePointer filter = FilterType::New();
// Connect the input images
filter->SetInput1( inputImageA );
filter->SetInput2( inputImageB );
filter->SetPaddingValue(PaddingValue);
// Get the Smart Pointer to the Filter Output
ImageType2Pointer outputImage = filter->GetOutput();
// Execute the filter
filter->Update();
filter->SetFunctor(filter->GetFunctor());
// Create an iterator for going through the image output
IteratorType2 it3(outputImage, outputImage->GetBufferedRegion());
it1.GoToBegin();
it2.GoToBegin();
it3.GoToBegin();
// Print the content of the result image
std::cout << " Result " << std::endl;
while( !it3.IsAtEnd() )
{
PixelType pixel1 = it1.Get();
PixelType pixel2 = it2.Get();
PixelType pixel3 = it3.Get();
//std::cout << static_cast<itk::NumericTraits<PixelType>::PrintType>(pixel3) << std::endl;
if (pixel1 != PaddingValue && pixel2 != PaddingValue)
{
if (pixel3 != 1)
return EXIT_FAILURE;
}
else
{
if (pixel3 != 0)
return EXIT_FAILURE;
}
++it1;
++it2;
++it3;
}
// All objects should be automatically destroyed at this point
std::cout << "Test PASSED !" << std::endl;
return EXIT_SUCCESS;
}
| 28.761111 | 97 | 0.667568 | NifTK |
a3373218aab35d814f71d62f46058c93cc88be5e | 1,058 | cc | C++ | aoj/1/1035.cc | eagletmt/procon | adbe503eb3c1bbcc1538b2ee8988aa353937e8d4 | [
"MIT"
] | 1 | 2015-04-17T09:54:23.000Z | 2015-04-17T09:54:23.000Z | aoj/1/1035.cc | eagletmt/procon | adbe503eb3c1bbcc1538b2ee8988aa353937e8d4 | [
"MIT"
] | null | null | null | aoj/1/1035.cc | eagletmt/procon | adbe503eb3c1bbcc1538b2ee8988aa353937e8d4 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
using namespace std;
int main()
{
int W, Q;
while (cin >> W >> Q && !(W == 0 && Q == 0)) {
vector<pair<int,int> > cats(Q);
vector<bool> used(W, false);
for (int i = 0; i < Q; i++) {
char sw;
int id;
cin >> sw >> id;
if (sw == 's') {
int w;
cin >> w;
int b = -1, c = 0;
for (int j = 0; j < W; j++) {
if (used[j]) {
c = 0;
} else {
c++;
if (c == w) {
b = j - w + 1;
break;
}
}
}
if (b == -1) {
cout << "impossible" << endl;
} else {
for (int j = 0; j < w; j++) {
used[b+j] = true;
}
cats[id] = make_pair(b, w);
cout << b << endl;
}
} else {
int b = cats[id].first;
int w = cats[id].second;
for (int j = 0; j < w; j++) {
used[b+j] = false;
}
}
}
cout << "END" << endl;
}
return 0;
}
| 20.346154 | 48 | 0.327977 | eagletmt |
a3376be423828b25c6eda6fff30a56578c7bbbe5 | 3,235 | cc | C++ | lite/backends/x86/jit/gen_base.cc | xw-github/Paddle-Lite | 3cbd1d375d89c4deb379d44cdbcdc32ee74634c5 | [
"Apache-2.0"
] | null | null | null | lite/backends/x86/jit/gen_base.cc | xw-github/Paddle-Lite | 3cbd1d375d89c4deb379d44cdbcdc32ee74634c5 | [
"Apache-2.0"
] | null | null | null | lite/backends/x86/jit/gen_base.cc | xw-github/Paddle-Lite | 3cbd1d375d89c4deb379d44cdbcdc32ee74634c5 | [
"Apache-2.0"
] | null | null | null | /* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License. */
#include "lite/backends/x86/jit/gen_base.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
// #include "paddle/fluid/memory/allocation/cpu_allocator.h" // for
// posix_memalign
#include "lite/backends/x86/cpu_info.h"
#include "lite/backends/x86/jit/macro.h"
#include "lite/utils/env.h"
#include "lite/utils/paddle_enforce.h"
#ifndef _WIN32
#define posix_memalign_free free
#endif
#ifdef _WIN32
#define posix_memalign_free _aligned_free
#define posix_memalign(p, a, s) \
(((*(p)) = _aligned_malloc((s), (a))), *(p) ? 0 : errno)
#endif
// DEFINE_bool(dump_jitcode, false, "Whether to dump the jitcode to file");
bool dump_jitcode = paddle::lite::GetBoolFromEnv("dump_jitcode");
namespace paddle {
namespace lite {
namespace jit {
// refer do not need CanBeUsed, it would be the last one.
void GenBase::dumpCode(const unsigned char* code) const {
if (code) {
static int counter = 0;
std::ostringstream filename;
filename << "paddle_jitcode_" << name() << "." << counter << ".bin";
counter++;
std::ofstream fout(filename.str(), std::ios::out);
if (fout.is_open()) {
fout.write(reinterpret_cast<const char*>(code), this->getSize());
fout.close();
}
}
}
void* GenBase::operator new(size_t size) {
void* ptr;
constexpr size_t alignment = 32ul;
#ifdef _WIN32
ptr = _aligned_malloc(size, alignment);
#else
PADDLE_ENFORCE_EQ(posix_memalign(&ptr, alignment, size),
0,
"GenBase Alloc %ld error!",
size);
#endif
PADDLE_ENFORCE(ptr, "Fail to allocate GenBase CPU memory: size = %d .", size);
return ptr;
}
void GenBase::operator delete(void* ptr) { posix_memalign_free(ptr); }
std::vector<int> packed_groups(int n, int k, int* block_out, int* rest_out) {
int block;
int max_num_regs;
if (x86::MayIUse(x86::avx512f)) {
block = ZMM_FLOAT_BLOCK;
max_num_regs = 32;
} else {
block = YMM_FLOAT_BLOCK;
max_num_regs = 16;
}
// one for x, one for y, others for z
const int max_used_regs_for_n = max_num_regs - 2;
const int aligned_n = n % block == 0 ? n : (n / block + 1) * block;
const int num_block = aligned_n / block;
const int num_groups = num_block / max_used_regs_for_n;
std::vector<int> groups(num_groups, max_used_regs_for_n);
int rest_num_regs = num_block % max_used_regs_for_n;
if (rest_num_regs != 0) {
groups.push_back(rest_num_regs);
}
if (block_out) {
*block_out = block;
}
if (rest_out) {
*rest_out = n % block;
}
return groups;
}
} // namespace jit
} // namespace lite
} // namespace paddle
| 29.953704 | 80 | 0.683153 | xw-github |
a3378b911f0c2f932dfab7d5bed7bed9b6617ebd | 336,513 | cpp | C++ | source/glbinding-aux/source/Meta_StringsByEnum.cpp | sagpant/glbinding | f27f5f2dd1650713db24efb300b7ae15c68c4d52 | [
"MIT"
] | null | null | null | source/glbinding-aux/source/Meta_StringsByEnum.cpp | sagpant/glbinding | f27f5f2dd1650713db24efb300b7ae15c68c4d52 | [
"MIT"
] | null | null | null | source/glbinding-aux/source/Meta_StringsByEnum.cpp | sagpant/glbinding | f27f5f2dd1650713db24efb300b7ae15c68c4d52 | [
"MIT"
] | 3 | 2020-05-22T00:27:45.000Z | 2020-06-17T15:19:02.000Z |
#include "Meta_Maps.h"
#include <glbinding/gl/enum.h>
using namespace gl;
namespace glbinding { namespace aux
{
const std::multimap<GLenum, std::string> Meta_StringsByEnum =
{
{ GLenum::GL_1PASS_EXT, "GL_1PASS_EXT" },
{ GLenum::GL_1PASS_SGIS, "GL_1PASS_SGIS" },
{ GLenum::GL_2_BYTES, "GL_2_BYTES" },
{ GLenum::GL_2_BYTES_NV, "GL_2_BYTES_NV" },
{ GLenum::GL_2D, "GL_2D" },
{ GLenum::GL_2PASS_0_EXT, "GL_2PASS_0_EXT" },
{ GLenum::GL_2PASS_0_SGIS, "GL_2PASS_0_SGIS" },
{ GLenum::GL_2PASS_1_EXT, "GL_2PASS_1_EXT" },
{ GLenum::GL_2PASS_1_SGIS, "GL_2PASS_1_SGIS" },
{ GLenum::GL_3_BYTES, "GL_3_BYTES" },
{ GLenum::GL_3_BYTES_NV, "GL_3_BYTES_NV" },
{ GLenum::GL_3D, "GL_3D" },
{ GLenum::GL_3D_COLOR, "GL_3D_COLOR" },
{ GLenum::GL_3D_COLOR_TEXTURE, "GL_3D_COLOR_TEXTURE" },
{ GLenum::GL_422_AVERAGE_EXT, "GL_422_AVERAGE_EXT" },
{ GLenum::GL_422_EXT, "GL_422_EXT" },
{ GLenum::GL_422_REV_AVERAGE_EXT, "GL_422_REV_AVERAGE_EXT" },
{ GLenum::GL_422_REV_EXT, "GL_422_REV_EXT" },
{ GLenum::GL_4_BYTES, "GL_4_BYTES" },
{ GLenum::GL_4_BYTES_NV, "GL_4_BYTES_NV" },
{ GLenum::GL_4D_COLOR_TEXTURE, "GL_4D_COLOR_TEXTURE" },
{ GLenum::GL_4PASS_0_EXT, "GL_4PASS_0_EXT" },
{ GLenum::GL_4PASS_0_SGIS, "GL_4PASS_0_SGIS" },
{ GLenum::GL_4PASS_1_EXT, "GL_4PASS_1_EXT" },
{ GLenum::GL_4PASS_1_SGIS, "GL_4PASS_1_SGIS" },
{ GLenum::GL_4PASS_2_EXT, "GL_4PASS_2_EXT" },
{ GLenum::GL_4PASS_2_SGIS, "GL_4PASS_2_SGIS" },
{ GLenum::GL_4PASS_3_EXT, "GL_4PASS_3_EXT" },
{ GLenum::GL_4PASS_3_SGIS, "GL_4PASS_3_SGIS" },
{ GLenum::GL_ABGR_EXT, "GL_ABGR_EXT" },
{ GLenum::GL_ACCUM, "GL_ACCUM" },
{ GLenum::GL_ACCUM_ADJACENT_PAIRS_NV, "GL_ACCUM_ADJACENT_PAIRS_NV" },
{ GLenum::GL_ACCUM_ALPHA_BITS, "GL_ACCUM_ALPHA_BITS" },
{ GLenum::GL_ACCUM_BLUE_BITS, "GL_ACCUM_BLUE_BITS" },
{ GLenum::GL_ACCUM_CLEAR_VALUE, "GL_ACCUM_CLEAR_VALUE" },
{ GLenum::GL_ACCUM_GREEN_BITS, "GL_ACCUM_GREEN_BITS" },
{ GLenum::GL_ACCUM_RED_BITS, "GL_ACCUM_RED_BITS" },
{ GLenum::GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH" },
{ GLenum::GL_ACTIVE_ATTRIBUTES, "GL_ACTIVE_ATTRIBUTES" },
{ GLenum::GL_ACTIVE_PROGRAM, "GL_ACTIVE_PROGRAM" },
{ GLenum::GL_ACTIVE_PROGRAM_EXT, "GL_ACTIVE_PROGRAM_EXT" },
{ GLenum::GL_ACTIVE_RESOURCES, "GL_ACTIVE_RESOURCES" },
{ GLenum::GL_ACTIVE_STENCIL_FACE_EXT, "GL_ACTIVE_STENCIL_FACE_EXT" },
{ GLenum::GL_ACTIVE_SUBROUTINE_MAX_LENGTH, "GL_ACTIVE_SUBROUTINE_MAX_LENGTH" },
{ GLenum::GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS" },
{ GLenum::GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH, "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH" },
{ GLenum::GL_ACTIVE_SUBROUTINE_UNIFORMS, "GL_ACTIVE_SUBROUTINE_UNIFORMS" },
{ GLenum::GL_ACTIVE_SUBROUTINES, "GL_ACTIVE_SUBROUTINES" },
{ GLenum::GL_ACTIVE_TEXTURE, "GL_ACTIVE_TEXTURE" },
{ GLenum::GL_ACTIVE_TEXTURE_ARB, "GL_ACTIVE_TEXTURE_ARB" },
{ GLenum::GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH" },
{ GLenum::GL_ACTIVE_UNIFORM_BLOCKS, "GL_ACTIVE_UNIFORM_BLOCKS" },
{ GLenum::GL_ACTIVE_UNIFORM_MAX_LENGTH, "GL_ACTIVE_UNIFORM_MAX_LENGTH" },
{ GLenum::GL_ACTIVE_UNIFORMS, "GL_ACTIVE_UNIFORMS" },
{ GLenum::GL_ACTIVE_VARIABLES, "GL_ACTIVE_VARIABLES" },
{ GLenum::GL_ACTIVE_VARYING_MAX_LENGTH_NV, "GL_ACTIVE_VARYING_MAX_LENGTH_NV" },
{ GLenum::GL_ACTIVE_VARYINGS_NV, "GL_ACTIVE_VARYINGS_NV" },
{ GLenum::GL_ACTIVE_VERTEX_UNITS_ARB, "GL_ACTIVE_VERTEX_UNITS_ARB" },
{ GLenum::GL_ADD, "GL_ADD" },
{ GLenum::GL_ADD_ATI, "GL_ADD_ATI" },
{ GLenum::GL_ADD_SIGNED, "GL_ADD_SIGNED" },
{ GLenum::GL_ADD_SIGNED_ARB, "GL_ADD_SIGNED_ARB" },
{ GLenum::GL_ADD_SIGNED_EXT, "GL_ADD_SIGNED_EXT" },
{ GLenum::GL_ADJACENT_PAIRS_NV, "GL_ADJACENT_PAIRS_NV" },
{ GLenum::GL_AFFINE_2D_NV, "GL_AFFINE_2D_NV" },
{ GLenum::GL_AFFINE_3D_NV, "GL_AFFINE_3D_NV" },
{ GLenum::GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE" },
{ GLenum::GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE" },
{ GLenum::GL_ALL_COMPLETED_NV, "GL_ALL_COMPLETED_NV" },
{ GLenum::GL_ALL_STATIC_DATA_IBM, "GL_ALL_STATIC_DATA_IBM" },
{ GLenum::GL_ALLOW_DRAW_FRG_HINT_PGI, "GL_ALLOW_DRAW_FRG_HINT_PGI" },
{ GLenum::GL_ALLOW_DRAW_MEM_HINT_PGI, "GL_ALLOW_DRAW_MEM_HINT_PGI" },
{ GLenum::GL_ALLOW_DRAW_OBJ_HINT_PGI, "GL_ALLOW_DRAW_OBJ_HINT_PGI" },
{ GLenum::GL_ALLOW_DRAW_WIN_HINT_PGI, "GL_ALLOW_DRAW_WIN_HINT_PGI" },
{ GLenum::GL_ALPHA, "GL_ALPHA" },
{ GLenum::GL_ALPHA12, "GL_ALPHA12" },
{ GLenum::GL_ALPHA12_EXT, "GL_ALPHA12_EXT" },
{ GLenum::GL_ALPHA16, "GL_ALPHA16" },
{ GLenum::GL_ALPHA16_EXT, "GL_ALPHA16_EXT" },
{ GLenum::GL_ALPHA16_SNORM, "GL_ALPHA16_SNORM" },
{ GLenum::GL_ALPHA16F_ARB, "GL_ALPHA16F_ARB" },
{ GLenum::GL_ALPHA16I_EXT, "GL_ALPHA16I_EXT" },
{ GLenum::GL_ALPHA16UI_EXT, "GL_ALPHA16UI_EXT" },
{ GLenum::GL_ALPHA32F_ARB, "GL_ALPHA32F_ARB" },
{ GLenum::GL_ALPHA32I_EXT, "GL_ALPHA32I_EXT" },
{ GLenum::GL_ALPHA32UI_EXT, "GL_ALPHA32UI_EXT" },
{ GLenum::GL_ALPHA4, "GL_ALPHA4" },
{ GLenum::GL_ALPHA4_EXT, "GL_ALPHA4_EXT" },
{ GLenum::GL_ALPHA8, "GL_ALPHA8" },
{ GLenum::GL_ALPHA8_EXT, "GL_ALPHA8_EXT" },
{ GLenum::GL_ALPHA8_SNORM, "GL_ALPHA8_SNORM" },
{ GLenum::GL_ALPHA8I_EXT, "GL_ALPHA8I_EXT" },
{ GLenum::GL_ALPHA8UI_EXT, "GL_ALPHA8UI_EXT" },
{ GLenum::GL_ALPHA_BIAS, "GL_ALPHA_BIAS" },
{ GLenum::GL_ALPHA_BITS, "GL_ALPHA_BITS" },
{ GLenum::GL_ALPHA_FLOAT16_APPLE, "GL_ALPHA_FLOAT16_APPLE" },
{ GLenum::GL_ALPHA_FLOAT16_ATI, "GL_ALPHA_FLOAT16_ATI" },
{ GLenum::GL_ALPHA_FLOAT32_APPLE, "GL_ALPHA_FLOAT32_APPLE" },
{ GLenum::GL_ALPHA_FLOAT32_ATI, "GL_ALPHA_FLOAT32_ATI" },
{ GLenum::GL_ALPHA_INTEGER, "GL_ALPHA_INTEGER" },
{ GLenum::GL_ALPHA_INTEGER_EXT, "GL_ALPHA_INTEGER_EXT" },
{ GLenum::GL_ALPHA_MAX_CLAMP_INGR, "GL_ALPHA_MAX_CLAMP_INGR" },
{ GLenum::GL_ALPHA_MAX_SGIX, "GL_ALPHA_MAX_SGIX" },
{ GLenum::GL_ALPHA_MIN_CLAMP_INGR, "GL_ALPHA_MIN_CLAMP_INGR" },
{ GLenum::GL_ALPHA_MIN_SGIX, "GL_ALPHA_MIN_SGIX" },
{ GLenum::GL_ALPHA_REF_COMMAND_NV, "GL_ALPHA_REF_COMMAND_NV" },
{ GLenum::GL_ALPHA_SCALE, "GL_ALPHA_SCALE" },
{ GLenum::GL_ALPHA_SNORM, "GL_ALPHA_SNORM" },
{ GLenum::GL_ALPHA_TEST, "GL_ALPHA_TEST" },
{ GLenum::GL_ALPHA_TEST_FUNC, "GL_ALPHA_TEST_FUNC" },
{ GLenum::GL_ALPHA_TEST_REF, "GL_ALPHA_TEST_REF" },
{ GLenum::GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV, "GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV" },
{ GLenum::GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV, "GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV" },
{ GLenum::GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV, "GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV" },
{ GLenum::GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV, "GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV" },
{ GLenum::GL_ALREADY_SIGNALED, "GL_ALREADY_SIGNALED" },
{ GLenum::GL_ALWAYS, "GL_ALWAYS" },
{ GLenum::GL_ALWAYS_FAST_HINT_PGI, "GL_ALWAYS_FAST_HINT_PGI" },
{ GLenum::GL_ALWAYS_SOFT_HINT_PGI, "GL_ALWAYS_SOFT_HINT_PGI" },
{ GLenum::GL_AMBIENT, "GL_AMBIENT" },
{ GLenum::GL_AMBIENT_AND_DIFFUSE, "GL_AMBIENT_AND_DIFFUSE" },
{ GLenum::GL_AND, "GL_AND" },
{ GLenum::GL_AND_INVERTED, "GL_AND_INVERTED" },
{ GLenum::GL_AND_REVERSE, "GL_AND_REVERSE" },
{ GLenum::GL_ANY_SAMPLES_PASSED, "GL_ANY_SAMPLES_PASSED" },
{ GLenum::GL_ANY_SAMPLES_PASSED_CONSERVATIVE, "GL_ANY_SAMPLES_PASSED_CONSERVATIVE" },
{ GLenum::GL_ARC_TO_NV, "GL_ARC_TO_NV" },
{ GLenum::GL_ARRAY_BUFFER, "GL_ARRAY_BUFFER" },
{ GLenum::GL_ARRAY_BUFFER_ARB, "GL_ARRAY_BUFFER_ARB" },
{ GLenum::GL_ARRAY_BUFFER_BINDING, "GL_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_ARRAY_BUFFER_BINDING_ARB, "GL_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT" },
{ GLenum::GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT" },
{ GLenum::GL_ARRAY_OBJECT_BUFFER_ATI, "GL_ARRAY_OBJECT_BUFFER_ATI" },
{ GLenum::GL_ARRAY_OBJECT_OFFSET_ATI, "GL_ARRAY_OBJECT_OFFSET_ATI" },
{ GLenum::GL_ARRAY_SIZE, "GL_ARRAY_SIZE" },
{ GLenum::GL_ARRAY_STRIDE, "GL_ARRAY_STRIDE" },
{ GLenum::GL_ASYNC_DRAW_PIXELS_SGIX, "GL_ASYNC_DRAW_PIXELS_SGIX" },
{ GLenum::GL_ASYNC_HISTOGRAM_SGIX, "GL_ASYNC_HISTOGRAM_SGIX" },
{ GLenum::GL_ASYNC_MARKER_SGIX, "GL_ASYNC_MARKER_SGIX" },
{ GLenum::GL_ASYNC_READ_PIXELS_SGIX, "GL_ASYNC_READ_PIXELS_SGIX" },
{ GLenum::GL_ASYNC_TEX_IMAGE_SGIX, "GL_ASYNC_TEX_IMAGE_SGIX" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER, "GL_ATOMIC_COUNTER_BUFFER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_BINDING, "GL_ATOMIC_COUNTER_BUFFER_BINDING" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE, "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_INDEX, "GL_ATOMIC_COUNTER_BUFFER_INDEX" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_SIZE, "GL_ATOMIC_COUNTER_BUFFER_SIZE" },
{ GLenum::GL_ATOMIC_COUNTER_BUFFER_START, "GL_ATOMIC_COUNTER_BUFFER_START" },
{ GLenum::GL_ATTACHED_MEMORY_OBJECT_NV, "GL_ATTACHED_MEMORY_OBJECT_NV" },
{ GLenum::GL_ATTACHED_MEMORY_OFFSET_NV, "GL_ATTACHED_MEMORY_OFFSET_NV" },
{ GLenum::GL_ATTACHED_SHADERS, "GL_ATTACHED_SHADERS" },
{ GLenum::GL_ATTENUATION_EXT, "GL_ATTENUATION_EXT" },
{ GLenum::GL_ATTRIB_ARRAY_POINTER_NV, "GL_ATTRIB_ARRAY_POINTER_NV" },
{ GLenum::GL_ATTRIB_ARRAY_SIZE_NV, "GL_ATTRIB_ARRAY_SIZE_NV" },
{ GLenum::GL_ATTRIB_ARRAY_STRIDE_NV, "GL_ATTRIB_ARRAY_STRIDE_NV" },
{ GLenum::GL_ATTRIB_ARRAY_TYPE_NV, "GL_ATTRIB_ARRAY_TYPE_NV" },
{ GLenum::GL_ATTRIB_STACK_DEPTH, "GL_ATTRIB_STACK_DEPTH" },
{ GLenum::GL_ATTRIBUTE_ADDRESS_COMMAND_NV, "GL_ATTRIBUTE_ADDRESS_COMMAND_NV" },
{ GLenum::GL_AUTO_GENERATE_MIPMAP, "GL_AUTO_GENERATE_MIPMAP" },
{ GLenum::GL_AUTO_NORMAL, "GL_AUTO_NORMAL" },
{ GLenum::GL_AUX0, "GL_AUX0" },
{ GLenum::GL_AUX1, "GL_AUX1" },
{ GLenum::GL_AUX2, "GL_AUX2" },
{ GLenum::GL_AUX3, "GL_AUX3" },
{ GLenum::GL_AUX_BUFFERS, "GL_AUX_BUFFERS" },
{ GLenum::GL_AUX_DEPTH_STENCIL_APPLE, "GL_AUX_DEPTH_STENCIL_APPLE" },
{ GLenum::GL_AVERAGE_EXT, "GL_AVERAGE_EXT" },
{ GLenum::GL_AVERAGE_HP, "GL_AVERAGE_HP" },
{ GLenum::GL_BACK, "GL_BACK" },
{ GLenum::GL_BACK_LEFT, "GL_BACK_LEFT" },
{ GLenum::GL_BACK_NORMALS_HINT_PGI, "GL_BACK_NORMALS_HINT_PGI" },
{ GLenum::GL_BACK_PRIMARY_COLOR_NV, "GL_BACK_PRIMARY_COLOR_NV" },
{ GLenum::GL_BACK_RIGHT, "GL_BACK_RIGHT" },
{ GLenum::GL_BACK_SECONDARY_COLOR_NV, "GL_BACK_SECONDARY_COLOR_NV" },
{ GLenum::GL_BEVEL_NV, "GL_BEVEL_NV" },
{ GLenum::GL_BGR, "GL_BGR" },
{ GLenum::GL_BGR_EXT, "GL_BGR_EXT" },
{ GLenum::GL_BGR_INTEGER, "GL_BGR_INTEGER" },
{ GLenum::GL_BGR_INTEGER_EXT, "GL_BGR_INTEGER_EXT" },
{ GLenum::GL_BGRA, "GL_BGRA" },
{ GLenum::GL_BGRA_EXT, "GL_BGRA_EXT" },
{ GLenum::GL_BGRA_INTEGER, "GL_BGRA_INTEGER" },
{ GLenum::GL_BGRA_INTEGER_EXT, "GL_BGRA_INTEGER_EXT" },
{ GLenum::GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, "GL_BIAS_BY_NEGATIVE_ONE_HALF_NV" },
{ GLenum::GL_BINORMAL_ARRAY_EXT, "GL_BINORMAL_ARRAY_EXT" },
{ GLenum::GL_BINORMAL_ARRAY_POINTER_EXT, "GL_BINORMAL_ARRAY_POINTER_EXT" },
{ GLenum::GL_BINORMAL_ARRAY_STRIDE_EXT, "GL_BINORMAL_ARRAY_STRIDE_EXT" },
{ GLenum::GL_BINORMAL_ARRAY_TYPE_EXT, "GL_BINORMAL_ARRAY_TYPE_EXT" },
{ GLenum::GL_BITMAP, "GL_BITMAP" },
{ GLenum::GL_BITMAP_TOKEN, "GL_BITMAP_TOKEN" },
{ GLenum::GL_BLACKHOLE_RENDER_INTEL, "GL_BLACKHOLE_RENDER_INTEL" },
{ GLenum::GL_BLEND, "GL_BLEND" },
{ GLenum::GL_BLEND_ADVANCED_COHERENT_KHR, "GL_BLEND_ADVANCED_COHERENT_KHR" },
{ GLenum::GL_BLEND_ADVANCED_COHERENT_NV, "GL_BLEND_ADVANCED_COHERENT_NV" },
{ GLenum::GL_BLEND_COLOR, "GL_BLEND_COLOR" },
{ GLenum::GL_BLEND_COLOR_COMMAND_NV, "GL_BLEND_COLOR_COMMAND_NV" },
{ GLenum::GL_BLEND_COLOR_EXT, "GL_BLEND_COLOR_EXT" },
{ GLenum::GL_BLEND_DST, "GL_BLEND_DST" },
{ GLenum::GL_BLEND_DST_ALPHA, "GL_BLEND_DST_ALPHA" },
{ GLenum::GL_BLEND_DST_ALPHA_EXT, "GL_BLEND_DST_ALPHA_EXT" },
{ GLenum::GL_BLEND_DST_RGB, "GL_BLEND_DST_RGB" },
{ GLenum::GL_BLEND_DST_RGB_EXT, "GL_BLEND_DST_RGB_EXT" },
{ GLenum::GL_BLEND_EQUATION, "GL_BLEND_EQUATION" },
{ GLenum::GL_BLEND_EQUATION_ALPHA, "GL_BLEND_EQUATION_ALPHA" },
{ GLenum::GL_BLEND_EQUATION_ALPHA_EXT, "GL_BLEND_EQUATION_ALPHA_EXT" },
{ GLenum::GL_BLEND_EQUATION_EXT, "GL_BLEND_EQUATION_EXT" },
{ GLenum::GL_BLEND_EQUATION_RGB, "GL_BLEND_EQUATION_RGB" },
{ GLenum::GL_BLEND_EQUATION_RGB_EXT, "GL_BLEND_EQUATION_RGB_EXT" },
{ GLenum::GL_BLEND_OVERLAP_NV, "GL_BLEND_OVERLAP_NV" },
{ GLenum::GL_BLEND_PREMULTIPLIED_SRC_NV, "GL_BLEND_PREMULTIPLIED_SRC_NV" },
{ GLenum::GL_BLEND_SRC, "GL_BLEND_SRC" },
{ GLenum::GL_BLEND_SRC_ALPHA, "GL_BLEND_SRC_ALPHA" },
{ GLenum::GL_BLEND_SRC_ALPHA_EXT, "GL_BLEND_SRC_ALPHA_EXT" },
{ GLenum::GL_BLEND_SRC_RGB, "GL_BLEND_SRC_RGB" },
{ GLenum::GL_BLEND_SRC_RGB_EXT, "GL_BLEND_SRC_RGB_EXT" },
{ GLenum::GL_BLOCK_INDEX, "GL_BLOCK_INDEX" },
{ GLenum::GL_BLUE, "GL_BLUE" },
{ GLenum::GL_BLUE_BIAS, "GL_BLUE_BIAS" },
{ GLenum::GL_BLUE_BITS, "GL_BLUE_BITS" },
{ GLenum::GL_BLUE_INTEGER, "GL_BLUE_INTEGER" },
{ GLenum::GL_BLUE_INTEGER_EXT, "GL_BLUE_INTEGER_EXT" },
{ GLenum::GL_BLUE_MAX_CLAMP_INGR, "GL_BLUE_MAX_CLAMP_INGR" },
{ GLenum::GL_BLUE_MIN_CLAMP_INGR, "GL_BLUE_MIN_CLAMP_INGR" },
{ GLenum::GL_BLUE_NV, "GL_BLUE_NV" },
{ GLenum::GL_BLUE_SCALE, "GL_BLUE_SCALE" },
{ GLenum::GL_BOOL, "GL_BOOL" },
{ GLenum::GL_BOOL_ARB, "GL_BOOL_ARB" },
{ GLenum::GL_BOOL_VEC2, "GL_BOOL_VEC2" },
{ GLenum::GL_BOOL_VEC2_ARB, "GL_BOOL_VEC2_ARB" },
{ GLenum::GL_BOOL_VEC3, "GL_BOOL_VEC3" },
{ GLenum::GL_BOOL_VEC3_ARB, "GL_BOOL_VEC3_ARB" },
{ GLenum::GL_BOOL_VEC4, "GL_BOOL_VEC4" },
{ GLenum::GL_BOOL_VEC4_ARB, "GL_BOOL_VEC4_ARB" },
{ GLenum::GL_BOUNDING_BOX_NV, "GL_BOUNDING_BOX_NV" },
{ GLenum::GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV, "GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV" },
{ GLenum::GL_BUFFER, "GL_BUFFER" },
{ GLenum::GL_BUFFER_ACCESS, "GL_BUFFER_ACCESS" },
{ GLenum::GL_BUFFER_ACCESS_ARB, "GL_BUFFER_ACCESS_ARB" },
{ GLenum::GL_BUFFER_ACCESS_FLAGS, "GL_BUFFER_ACCESS_FLAGS" },
{ GLenum::GL_BUFFER_BINDING, "GL_BUFFER_BINDING" },
{ GLenum::GL_BUFFER_DATA_SIZE, "GL_BUFFER_DATA_SIZE" },
{ GLenum::GL_BUFFER_FLUSHING_UNMAP_APPLE, "GL_BUFFER_FLUSHING_UNMAP_APPLE" },
{ GLenum::GL_BUFFER_GPU_ADDRESS_NV, "GL_BUFFER_GPU_ADDRESS_NV" },
{ GLenum::GL_BUFFER_IMMUTABLE_STORAGE, "GL_BUFFER_IMMUTABLE_STORAGE" },
{ GLenum::GL_BUFFER_KHR, "GL_BUFFER_KHR" },
{ GLenum::GL_BUFFER_MAP_LENGTH, "GL_BUFFER_MAP_LENGTH" },
{ GLenum::GL_BUFFER_MAP_OFFSET, "GL_BUFFER_MAP_OFFSET" },
{ GLenum::GL_BUFFER_MAP_POINTER, "GL_BUFFER_MAP_POINTER" },
{ GLenum::GL_BUFFER_MAP_POINTER_ARB, "GL_BUFFER_MAP_POINTER_ARB" },
{ GLenum::GL_BUFFER_MAPPED, "GL_BUFFER_MAPPED" },
{ GLenum::GL_BUFFER_MAPPED_ARB, "GL_BUFFER_MAPPED_ARB" },
{ GLenum::GL_BUFFER_OBJECT_APPLE, "GL_BUFFER_OBJECT_APPLE" },
{ GLenum::GL_BUFFER_OBJECT_EXT, "GL_BUFFER_OBJECT_EXT" },
{ GLenum::GL_BUFFER_SERIALIZED_MODIFY_APPLE, "GL_BUFFER_SERIALIZED_MODIFY_APPLE" },
{ GLenum::GL_BUFFER_SIZE, "GL_BUFFER_SIZE" },
{ GLenum::GL_BUFFER_SIZE_ARB, "GL_BUFFER_SIZE_ARB" },
{ GLenum::GL_BUFFER_STORAGE_FLAGS, "GL_BUFFER_STORAGE_FLAGS" },
{ GLenum::GL_BUFFER_USAGE, "GL_BUFFER_USAGE" },
{ GLenum::GL_BUFFER_USAGE_ARB, "GL_BUFFER_USAGE_ARB" },
{ GLenum::GL_BUFFER_VARIABLE, "GL_BUFFER_VARIABLE" },
{ GLenum::GL_BUMP_ENVMAP_ATI, "GL_BUMP_ENVMAP_ATI" },
{ GLenum::GL_BUMP_NUM_TEX_UNITS_ATI, "GL_BUMP_NUM_TEX_UNITS_ATI" },
{ GLenum::GL_BUMP_ROT_MATRIX_ATI, "GL_BUMP_ROT_MATRIX_ATI" },
{ GLenum::GL_BUMP_ROT_MATRIX_SIZE_ATI, "GL_BUMP_ROT_MATRIX_SIZE_ATI" },
{ GLenum::GL_BUMP_TARGET_ATI, "GL_BUMP_TARGET_ATI" },
{ GLenum::GL_BUMP_TEX_UNITS_ATI, "GL_BUMP_TEX_UNITS_ATI" },
{ GLenum::GL_BYTE, "GL_BYTE" },
{ GLenum::GL_C3F_V3F, "GL_C3F_V3F" },
{ GLenum::GL_C4F_N3F_V3F, "GL_C4F_N3F_V3F" },
{ GLenum::GL_C4UB_V2F, "GL_C4UB_V2F" },
{ GLenum::GL_C4UB_V3F, "GL_C4UB_V3F" },
{ GLenum::GL_CALLIGRAPHIC_FRAGMENT_SGIX, "GL_CALLIGRAPHIC_FRAGMENT_SGIX" },
{ GLenum::GL_CAVEAT_SUPPORT, "GL_CAVEAT_SUPPORT" },
{ GLenum::GL_CCW, "GL_CCW" },
{ GLenum::GL_CIRCULAR_CCW_ARC_TO_NV, "GL_CIRCULAR_CCW_ARC_TO_NV" },
{ GLenum::GL_CIRCULAR_CW_ARC_TO_NV, "GL_CIRCULAR_CW_ARC_TO_NV" },
{ GLenum::GL_CIRCULAR_TANGENT_ARC_TO_NV, "GL_CIRCULAR_TANGENT_ARC_TO_NV" },
{ GLenum::GL_CLAMP, "GL_CLAMP" },
{ GLenum::GL_CLAMP_FRAGMENT_COLOR, "GL_CLAMP_FRAGMENT_COLOR" },
{ GLenum::GL_CLAMP_FRAGMENT_COLOR_ARB, "GL_CLAMP_FRAGMENT_COLOR_ARB" },
{ GLenum::GL_CLAMP_READ_COLOR, "GL_CLAMP_READ_COLOR" },
{ GLenum::GL_CLAMP_READ_COLOR_ARB, "GL_CLAMP_READ_COLOR_ARB" },
{ GLenum::GL_CLAMP_TO_BORDER, "GL_CLAMP_TO_BORDER" },
{ GLenum::GL_CLAMP_TO_BORDER_ARB, "GL_CLAMP_TO_BORDER_ARB" },
{ GLenum::GL_CLAMP_TO_BORDER_SGIS, "GL_CLAMP_TO_BORDER_SGIS" },
{ GLenum::GL_CLAMP_TO_EDGE, "GL_CLAMP_TO_EDGE" },
{ GLenum::GL_CLAMP_TO_EDGE_SGIS, "GL_CLAMP_TO_EDGE_SGIS" },
{ GLenum::GL_CLAMP_VERTEX_COLOR, "GL_CLAMP_VERTEX_COLOR" },
{ GLenum::GL_CLAMP_VERTEX_COLOR_ARB, "GL_CLAMP_VERTEX_COLOR_ARB" },
{ GLenum::GL_CLEAR, "GL_CLEAR" },
{ GLenum::GL_CLEAR_BUFFER, "GL_CLEAR_BUFFER" },
{ GLenum::GL_CLEAR_TEXTURE, "GL_CLEAR_TEXTURE" },
{ GLenum::GL_CLIENT_ACTIVE_TEXTURE, "GL_CLIENT_ACTIVE_TEXTURE" },
{ GLenum::GL_CLIENT_ACTIVE_TEXTURE_ARB, "GL_CLIENT_ACTIVE_TEXTURE_ARB" },
{ GLenum::GL_CLIENT_ATTRIB_STACK_DEPTH, "GL_CLIENT_ATTRIB_STACK_DEPTH" },
{ GLenum::GL_CLIP_DEPTH_MODE, "GL_CLIP_DEPTH_MODE" },
{ GLenum::GL_CLIP_DISTANCE0, "GL_CLIP_DISTANCE0" },
{ GLenum::GL_CLIP_DISTANCE1, "GL_CLIP_DISTANCE1" },
{ GLenum::GL_CLIP_DISTANCE2, "GL_CLIP_DISTANCE2" },
{ GLenum::GL_CLIP_DISTANCE3, "GL_CLIP_DISTANCE3" },
{ GLenum::GL_CLIP_DISTANCE4, "GL_CLIP_DISTANCE4" },
{ GLenum::GL_CLIP_DISTANCE5, "GL_CLIP_DISTANCE5" },
{ GLenum::GL_CLIP_DISTANCE6, "GL_CLIP_DISTANCE6" },
{ GLenum::GL_CLIP_DISTANCE7, "GL_CLIP_DISTANCE7" },
{ GLenum::GL_CLIP_DISTANCE_NV, "GL_CLIP_DISTANCE_NV" },
{ GLenum::GL_CLIP_FAR_HINT_PGI, "GL_CLIP_FAR_HINT_PGI" },
{ GLenum::GL_CLIP_NEAR_HINT_PGI, "GL_CLIP_NEAR_HINT_PGI" },
{ GLenum::GL_CLIP_ORIGIN, "GL_CLIP_ORIGIN" },
{ GLenum::GL_CLIP_PLANE0, "GL_CLIP_PLANE0" },
{ GLenum::GL_CLIP_PLANE1, "GL_CLIP_PLANE1" },
{ GLenum::GL_CLIP_PLANE2, "GL_CLIP_PLANE2" },
{ GLenum::GL_CLIP_PLANE3, "GL_CLIP_PLANE3" },
{ GLenum::GL_CLIP_PLANE4, "GL_CLIP_PLANE4" },
{ GLenum::GL_CLIP_PLANE5, "GL_CLIP_PLANE5" },
{ GLenum::GL_CLIP_VOLUME_CLIPPING_HINT_EXT, "GL_CLIP_VOLUME_CLIPPING_HINT_EXT" },
{ GLenum::GL_CLIPPING_INPUT_PRIMITIVES, "GL_CLIPPING_INPUT_PRIMITIVES" },
{ GLenum::GL_CLIPPING_INPUT_PRIMITIVES_ARB, "GL_CLIPPING_INPUT_PRIMITIVES_ARB" },
{ GLenum::GL_CLIPPING_OUTPUT_PRIMITIVES, "GL_CLIPPING_OUTPUT_PRIMITIVES" },
{ GLenum::GL_CLIPPING_OUTPUT_PRIMITIVES_ARB, "GL_CLIPPING_OUTPUT_PRIMITIVES_ARB" },
{ GLenum::GL_CLOSE_PATH_NV, "GL_CLOSE_PATH_NV" },
{ GLenum::GL_CMYK_EXT, "GL_CMYK_EXT" },
{ GLenum::GL_CMYKA_EXT, "GL_CMYKA_EXT" },
{ GLenum::GL_CND0_ATI, "GL_CND0_ATI" },
{ GLenum::GL_CND_ATI, "GL_CND_ATI" },
{ GLenum::GL_COEFF, "GL_COEFF" },
{ GLenum::GL_COLOR, "GL_COLOR" },
{ GLenum::GL_COLOR_ALPHA_PAIRING_ATI, "GL_COLOR_ALPHA_PAIRING_ATI" },
{ GLenum::GL_COLOR_ARRAY, "GL_COLOR_ARRAY" },
{ GLenum::GL_COLOR_ARRAY_ADDRESS_NV, "GL_COLOR_ARRAY_ADDRESS_NV" },
{ GLenum::GL_COLOR_ARRAY_BUFFER_BINDING, "GL_COLOR_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_COLOR_ARRAY_BUFFER_BINDING_ARB, "GL_COLOR_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_COLOR_ARRAY_COUNT_EXT, "GL_COLOR_ARRAY_COUNT_EXT" },
{ GLenum::GL_COLOR_ARRAY_EXT, "GL_COLOR_ARRAY_EXT" },
{ GLenum::GL_COLOR_ARRAY_LENGTH_NV, "GL_COLOR_ARRAY_LENGTH_NV" },
{ GLenum::GL_COLOR_ARRAY_LIST_IBM, "GL_COLOR_ARRAY_LIST_IBM" },
{ GLenum::GL_COLOR_ARRAY_LIST_STRIDE_IBM, "GL_COLOR_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL, "GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL" },
{ GLenum::GL_COLOR_ARRAY_POINTER, "GL_COLOR_ARRAY_POINTER" },
{ GLenum::GL_COLOR_ARRAY_POINTER_EXT, "GL_COLOR_ARRAY_POINTER_EXT" },
{ GLenum::GL_COLOR_ARRAY_SIZE, "GL_COLOR_ARRAY_SIZE" },
{ GLenum::GL_COLOR_ARRAY_SIZE_EXT, "GL_COLOR_ARRAY_SIZE_EXT" },
{ GLenum::GL_COLOR_ARRAY_STRIDE, "GL_COLOR_ARRAY_STRIDE" },
{ GLenum::GL_COLOR_ARRAY_STRIDE_EXT, "GL_COLOR_ARRAY_STRIDE_EXT" },
{ GLenum::GL_COLOR_ARRAY_TYPE, "GL_COLOR_ARRAY_TYPE" },
{ GLenum::GL_COLOR_ARRAY_TYPE_EXT, "GL_COLOR_ARRAY_TYPE_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT0, "GL_COLOR_ATTACHMENT0" },
{ GLenum::GL_COLOR_ATTACHMENT0_EXT, "GL_COLOR_ATTACHMENT0_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT1, "GL_COLOR_ATTACHMENT1" },
{ GLenum::GL_COLOR_ATTACHMENT10, "GL_COLOR_ATTACHMENT10" },
{ GLenum::GL_COLOR_ATTACHMENT10_EXT, "GL_COLOR_ATTACHMENT10_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT11, "GL_COLOR_ATTACHMENT11" },
{ GLenum::GL_COLOR_ATTACHMENT11_EXT, "GL_COLOR_ATTACHMENT11_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT12, "GL_COLOR_ATTACHMENT12" },
{ GLenum::GL_COLOR_ATTACHMENT12_EXT, "GL_COLOR_ATTACHMENT12_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT13, "GL_COLOR_ATTACHMENT13" },
{ GLenum::GL_COLOR_ATTACHMENT13_EXT, "GL_COLOR_ATTACHMENT13_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT14, "GL_COLOR_ATTACHMENT14" },
{ GLenum::GL_COLOR_ATTACHMENT14_EXT, "GL_COLOR_ATTACHMENT14_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT15, "GL_COLOR_ATTACHMENT15" },
{ GLenum::GL_COLOR_ATTACHMENT15_EXT, "GL_COLOR_ATTACHMENT15_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT16, "GL_COLOR_ATTACHMENT16" },
{ GLenum::GL_COLOR_ATTACHMENT17, "GL_COLOR_ATTACHMENT17" },
{ GLenum::GL_COLOR_ATTACHMENT18, "GL_COLOR_ATTACHMENT18" },
{ GLenum::GL_COLOR_ATTACHMENT19, "GL_COLOR_ATTACHMENT19" },
{ GLenum::GL_COLOR_ATTACHMENT1_EXT, "GL_COLOR_ATTACHMENT1_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT2, "GL_COLOR_ATTACHMENT2" },
{ GLenum::GL_COLOR_ATTACHMENT20, "GL_COLOR_ATTACHMENT20" },
{ GLenum::GL_COLOR_ATTACHMENT21, "GL_COLOR_ATTACHMENT21" },
{ GLenum::GL_COLOR_ATTACHMENT22, "GL_COLOR_ATTACHMENT22" },
{ GLenum::GL_COLOR_ATTACHMENT23, "GL_COLOR_ATTACHMENT23" },
{ GLenum::GL_COLOR_ATTACHMENT24, "GL_COLOR_ATTACHMENT24" },
{ GLenum::GL_COLOR_ATTACHMENT25, "GL_COLOR_ATTACHMENT25" },
{ GLenum::GL_COLOR_ATTACHMENT26, "GL_COLOR_ATTACHMENT26" },
{ GLenum::GL_COLOR_ATTACHMENT27, "GL_COLOR_ATTACHMENT27" },
{ GLenum::GL_COLOR_ATTACHMENT28, "GL_COLOR_ATTACHMENT28" },
{ GLenum::GL_COLOR_ATTACHMENT29, "GL_COLOR_ATTACHMENT29" },
{ GLenum::GL_COLOR_ATTACHMENT2_EXT, "GL_COLOR_ATTACHMENT2_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT3, "GL_COLOR_ATTACHMENT3" },
{ GLenum::GL_COLOR_ATTACHMENT30, "GL_COLOR_ATTACHMENT30" },
{ GLenum::GL_COLOR_ATTACHMENT31, "GL_COLOR_ATTACHMENT31" },
{ GLenum::GL_COLOR_ATTACHMENT3_EXT, "GL_COLOR_ATTACHMENT3_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT4, "GL_COLOR_ATTACHMENT4" },
{ GLenum::GL_COLOR_ATTACHMENT4_EXT, "GL_COLOR_ATTACHMENT4_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT5, "GL_COLOR_ATTACHMENT5" },
{ GLenum::GL_COLOR_ATTACHMENT5_EXT, "GL_COLOR_ATTACHMENT5_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT6, "GL_COLOR_ATTACHMENT6" },
{ GLenum::GL_COLOR_ATTACHMENT6_EXT, "GL_COLOR_ATTACHMENT6_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT7, "GL_COLOR_ATTACHMENT7" },
{ GLenum::GL_COLOR_ATTACHMENT7_EXT, "GL_COLOR_ATTACHMENT7_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT8, "GL_COLOR_ATTACHMENT8" },
{ GLenum::GL_COLOR_ATTACHMENT8_EXT, "GL_COLOR_ATTACHMENT8_EXT" },
{ GLenum::GL_COLOR_ATTACHMENT9, "GL_COLOR_ATTACHMENT9" },
{ GLenum::GL_COLOR_ATTACHMENT9_EXT, "GL_COLOR_ATTACHMENT9_EXT" },
{ GLenum::GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI, "GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI" },
{ GLenum::GL_COLOR_CLEAR_VALUE, "GL_COLOR_CLEAR_VALUE" },
{ GLenum::GL_COLOR_COMPONENTS, "GL_COLOR_COMPONENTS" },
{ GLenum::GL_COLOR_ENCODING, "GL_COLOR_ENCODING" },
{ GLenum::GL_COLOR_FLOAT_APPLE, "GL_COLOR_FLOAT_APPLE" },
{ GLenum::GL_COLOR_INDEX, "GL_COLOR_INDEX" },
{ GLenum::GL_COLOR_INDEX12_EXT, "GL_COLOR_INDEX12_EXT" },
{ GLenum::GL_COLOR_INDEX16_EXT, "GL_COLOR_INDEX16_EXT" },
{ GLenum::GL_COLOR_INDEX1_EXT, "GL_COLOR_INDEX1_EXT" },
{ GLenum::GL_COLOR_INDEX2_EXT, "GL_COLOR_INDEX2_EXT" },
{ GLenum::GL_COLOR_INDEX4_EXT, "GL_COLOR_INDEX4_EXT" },
{ GLenum::GL_COLOR_INDEX8_EXT, "GL_COLOR_INDEX8_EXT" },
{ GLenum::GL_COLOR_INDEXES, "GL_COLOR_INDEXES" },
{ GLenum::GL_COLOR_LOGIC_OP, "GL_COLOR_LOGIC_OP" },
{ GLenum::GL_COLOR_MATERIAL, "GL_COLOR_MATERIAL" },
{ GLenum::GL_COLOR_MATERIAL_FACE, "GL_COLOR_MATERIAL_FACE" },
{ GLenum::GL_COLOR_MATERIAL_PARAMETER, "GL_COLOR_MATERIAL_PARAMETER" },
{ GLenum::GL_COLOR_MATRIX, "GL_COLOR_MATRIX" },
{ GLenum::GL_COLOR_MATRIX_SGI, "GL_COLOR_MATRIX_SGI" },
{ GLenum::GL_COLOR_MATRIX_STACK_DEPTH, "GL_COLOR_MATRIX_STACK_DEPTH" },
{ GLenum::GL_COLOR_MATRIX_STACK_DEPTH_SGI, "GL_COLOR_MATRIX_STACK_DEPTH_SGI" },
{ GLenum::GL_COLOR_RENDERABLE, "GL_COLOR_RENDERABLE" },
{ GLenum::GL_COLOR_SAMPLES_NV, "GL_COLOR_SAMPLES_NV" },
{ GLenum::GL_COLOR_SUM, "GL_COLOR_SUM" },
{ GLenum::GL_COLOR_SUM_ARB, "GL_COLOR_SUM_ARB" },
{ GLenum::GL_COLOR_SUM_CLAMP_NV, "GL_COLOR_SUM_CLAMP_NV" },
{ GLenum::GL_COLOR_SUM_EXT, "GL_COLOR_SUM_EXT" },
{ GLenum::GL_COLOR_TABLE, "GL_COLOR_TABLE" },
{ GLenum::GL_COLOR_TABLE_ALPHA_SIZE, "GL_COLOR_TABLE_ALPHA_SIZE" },
{ GLenum::GL_COLOR_TABLE_ALPHA_SIZE_SGI, "GL_COLOR_TABLE_ALPHA_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_BIAS, "GL_COLOR_TABLE_BIAS" },
{ GLenum::GL_COLOR_TABLE_BIAS_SGI, "GL_COLOR_TABLE_BIAS_SGI" },
{ GLenum::GL_COLOR_TABLE_BLUE_SIZE, "GL_COLOR_TABLE_BLUE_SIZE" },
{ GLenum::GL_COLOR_TABLE_BLUE_SIZE_SGI, "GL_COLOR_TABLE_BLUE_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_FORMAT, "GL_COLOR_TABLE_FORMAT" },
{ GLenum::GL_COLOR_TABLE_FORMAT_SGI, "GL_COLOR_TABLE_FORMAT_SGI" },
{ GLenum::GL_COLOR_TABLE_GREEN_SIZE, "GL_COLOR_TABLE_GREEN_SIZE" },
{ GLenum::GL_COLOR_TABLE_GREEN_SIZE_SGI, "GL_COLOR_TABLE_GREEN_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_INTENSITY_SIZE, "GL_COLOR_TABLE_INTENSITY_SIZE" },
{ GLenum::GL_COLOR_TABLE_INTENSITY_SIZE_SGI, "GL_COLOR_TABLE_INTENSITY_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_LUMINANCE_SIZE, "GL_COLOR_TABLE_LUMINANCE_SIZE" },
{ GLenum::GL_COLOR_TABLE_LUMINANCE_SIZE_SGI, "GL_COLOR_TABLE_LUMINANCE_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_RED_SIZE, "GL_COLOR_TABLE_RED_SIZE" },
{ GLenum::GL_COLOR_TABLE_RED_SIZE_SGI, "GL_COLOR_TABLE_RED_SIZE_SGI" },
{ GLenum::GL_COLOR_TABLE_SCALE, "GL_COLOR_TABLE_SCALE" },
{ GLenum::GL_COLOR_TABLE_SCALE_SGI, "GL_COLOR_TABLE_SCALE_SGI" },
{ GLenum::GL_COLOR_TABLE_SGI, "GL_COLOR_TABLE_SGI" },
{ GLenum::GL_COLOR_TABLE_WIDTH, "GL_COLOR_TABLE_WIDTH" },
{ GLenum::GL_COLOR_TABLE_WIDTH_SGI, "GL_COLOR_TABLE_WIDTH_SGI" },
{ GLenum::GL_COLOR_WRITEMASK, "GL_COLOR_WRITEMASK" },
{ GLenum::GL_COLORBURN_KHR, "GL_COLORBURN_KHR" },
{ GLenum::GL_COLORBURN_NV, "GL_COLORBURN_NV" },
{ GLenum::GL_COLORDODGE_KHR, "GL_COLORDODGE_KHR" },
{ GLenum::GL_COLORDODGE_NV, "GL_COLORDODGE_NV" },
{ GLenum::GL_COMBINE, "GL_COMBINE" },
{ GLenum::GL_COMBINE4_NV, "GL_COMBINE4_NV" },
{ GLenum::GL_COMBINE_ALPHA, "GL_COMBINE_ALPHA" },
{ GLenum::GL_COMBINE_ALPHA_ARB, "GL_COMBINE_ALPHA_ARB" },
{ GLenum::GL_COMBINE_ALPHA_EXT, "GL_COMBINE_ALPHA_EXT" },
{ GLenum::GL_COMBINE_ARB, "GL_COMBINE_ARB" },
{ GLenum::GL_COMBINE_EXT, "GL_COMBINE_EXT" },
{ GLenum::GL_COMBINE_RGB, "GL_COMBINE_RGB" },
{ GLenum::GL_COMBINE_RGB_ARB, "GL_COMBINE_RGB_ARB" },
{ GLenum::GL_COMBINE_RGB_EXT, "GL_COMBINE_RGB_EXT" },
{ GLenum::GL_COMBINER0_NV, "GL_COMBINER0_NV" },
{ GLenum::GL_COMBINER1_NV, "GL_COMBINER1_NV" },
{ GLenum::GL_COMBINER2_NV, "GL_COMBINER2_NV" },
{ GLenum::GL_COMBINER3_NV, "GL_COMBINER3_NV" },
{ GLenum::GL_COMBINER4_NV, "GL_COMBINER4_NV" },
{ GLenum::GL_COMBINER5_NV, "GL_COMBINER5_NV" },
{ GLenum::GL_COMBINER6_NV, "GL_COMBINER6_NV" },
{ GLenum::GL_COMBINER7_NV, "GL_COMBINER7_NV" },
{ GLenum::GL_COMBINER_AB_DOT_PRODUCT_NV, "GL_COMBINER_AB_DOT_PRODUCT_NV" },
{ GLenum::GL_COMBINER_AB_OUTPUT_NV, "GL_COMBINER_AB_OUTPUT_NV" },
{ GLenum::GL_COMBINER_BIAS_NV, "GL_COMBINER_BIAS_NV" },
{ GLenum::GL_COMBINER_CD_DOT_PRODUCT_NV, "GL_COMBINER_CD_DOT_PRODUCT_NV" },
{ GLenum::GL_COMBINER_CD_OUTPUT_NV, "GL_COMBINER_CD_OUTPUT_NV" },
{ GLenum::GL_COMBINER_COMPONENT_USAGE_NV, "GL_COMBINER_COMPONENT_USAGE_NV" },
{ GLenum::GL_COMBINER_INPUT_NV, "GL_COMBINER_INPUT_NV" },
{ GLenum::GL_COMBINER_MAPPING_NV, "GL_COMBINER_MAPPING_NV" },
{ GLenum::GL_COMBINER_MUX_SUM_NV, "GL_COMBINER_MUX_SUM_NV" },
{ GLenum::GL_COMBINER_SCALE_NV, "GL_COMBINER_SCALE_NV" },
{ GLenum::GL_COMBINER_SUM_OUTPUT_NV, "GL_COMBINER_SUM_OUTPUT_NV" },
{ GLenum::GL_COMPARE_R_TO_TEXTURE, "GL_COMPARE_R_TO_TEXTURE" },
{ GLenum::GL_COMPARE_R_TO_TEXTURE_ARB, "GL_COMPARE_R_TO_TEXTURE_ARB" },
{ GLenum::GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT, "GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT" },
{ GLenum::GL_COMPARE_REF_TO_TEXTURE, "GL_COMPARE_REF_TO_TEXTURE" },
{ GLenum::GL_COMPATIBLE_SUBROUTINES, "GL_COMPATIBLE_SUBROUTINES" },
{ GLenum::GL_COMPILE, "GL_COMPILE" },
{ GLenum::GL_COMPILE_AND_EXECUTE, "GL_COMPILE_AND_EXECUTE" },
{ GLenum::GL_COMPILE_STATUS, "GL_COMPILE_STATUS" },
{ GLenum::GL_COMPLETION_STATUS_ARB, "GL_COMPLETION_STATUS_ARB" },
{ GLenum::GL_COMPLETION_STATUS_KHR, "GL_COMPLETION_STATUS_KHR" },
{ GLenum::GL_COMPRESSED_ALPHA, "GL_COMPRESSED_ALPHA" },
{ GLenum::GL_COMPRESSED_ALPHA_ARB, "GL_COMPRESSED_ALPHA_ARB" },
{ GLenum::GL_COMPRESSED_INTENSITY, "GL_COMPRESSED_INTENSITY" },
{ GLenum::GL_COMPRESSED_INTENSITY_ARB, "GL_COMPRESSED_INTENSITY_ARB" },
{ GLenum::GL_COMPRESSED_LUMINANCE, "GL_COMPRESSED_LUMINANCE" },
{ GLenum::GL_COMPRESSED_LUMINANCE_ALPHA, "GL_COMPRESSED_LUMINANCE_ALPHA" },
{ GLenum::GL_COMPRESSED_LUMINANCE_ALPHA_ARB, "GL_COMPRESSED_LUMINANCE_ALPHA_ARB" },
{ GLenum::GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT" },
{ GLenum::GL_COMPRESSED_LUMINANCE_ARB, "GL_COMPRESSED_LUMINANCE_ARB" },
{ GLenum::GL_COMPRESSED_LUMINANCE_LATC1_EXT, "GL_COMPRESSED_LUMINANCE_LATC1_EXT" },
{ GLenum::GL_COMPRESSED_R11_EAC, "GL_COMPRESSED_R11_EAC" },
{ GLenum::GL_COMPRESSED_RED, "GL_COMPRESSED_RED" },
{ GLenum::GL_COMPRESSED_RED_GREEN_RGTC2_EXT, "GL_COMPRESSED_RED_GREEN_RGTC2_EXT" },
{ GLenum::GL_COMPRESSED_RED_RGTC1, "GL_COMPRESSED_RED_RGTC1" },
{ GLenum::GL_COMPRESSED_RED_RGTC1_EXT, "GL_COMPRESSED_RED_RGTC1_EXT" },
{ GLenum::GL_COMPRESSED_RG, "GL_COMPRESSED_RG" },
{ GLenum::GL_COMPRESSED_RG11_EAC, "GL_COMPRESSED_RG11_EAC" },
{ GLenum::GL_COMPRESSED_RG_RGTC2, "GL_COMPRESSED_RG_RGTC2" },
{ GLenum::GL_COMPRESSED_RGB, "GL_COMPRESSED_RGB" },
{ GLenum::GL_COMPRESSED_RGB8_ETC2, "GL_COMPRESSED_RGB8_ETC2" },
{ GLenum::GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2" },
{ GLenum::GL_COMPRESSED_RGB_ARB, "GL_COMPRESSED_RGB_ARB" },
{ GLenum::GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT" },
{ GLenum::GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB" },
{ GLenum::GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT" },
{ GLenum::GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB" },
{ GLenum::GL_COMPRESSED_RGB_FXT1_3DFX, "GL_COMPRESSED_RGB_FXT1_3DFX" },
{ GLenum::GL_COMPRESSED_RGB_S3TC_DXT1_EXT, "GL_COMPRESSED_RGB_S3TC_DXT1_EXT" },
{ GLenum::GL_COMPRESSED_RGBA, "GL_COMPRESSED_RGBA" },
{ GLenum::GL_COMPRESSED_RGBA8_ETC2_EAC, "GL_COMPRESSED_RGBA8_ETC2_EAC" },
{ GLenum::GL_COMPRESSED_RGBA_ARB, "GL_COMPRESSED_RGBA_ARB" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_10x10_KHR, "GL_COMPRESSED_RGBA_ASTC_10x10_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_10x5_KHR, "GL_COMPRESSED_RGBA_ASTC_10x5_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_10x6_KHR, "GL_COMPRESSED_RGBA_ASTC_10x6_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_10x8_KHR, "GL_COMPRESSED_RGBA_ASTC_10x8_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_12x10_KHR, "GL_COMPRESSED_RGBA_ASTC_12x10_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_12x12_KHR, "GL_COMPRESSED_RGBA_ASTC_12x12_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_4x4_KHR, "GL_COMPRESSED_RGBA_ASTC_4x4_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_5x4_KHR, "GL_COMPRESSED_RGBA_ASTC_5x4_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_5x5_KHR, "GL_COMPRESSED_RGBA_ASTC_5x5_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_6x5_KHR, "GL_COMPRESSED_RGBA_ASTC_6x5_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_6x6_KHR, "GL_COMPRESSED_RGBA_ASTC_6x6_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_8x5_KHR, "GL_COMPRESSED_RGBA_ASTC_8x5_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_8x6_KHR, "GL_COMPRESSED_RGBA_ASTC_8x6_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_ASTC_8x8_KHR, "GL_COMPRESSED_RGBA_ASTC_8x8_KHR" },
{ GLenum::GL_COMPRESSED_RGBA_BPTC_UNORM, "GL_COMPRESSED_RGBA_BPTC_UNORM" },
{ GLenum::GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB" },
{ GLenum::GL_COMPRESSED_RGBA_FXT1_3DFX, "GL_COMPRESSED_RGBA_FXT1_3DFX" },
{ GLenum::GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT" },
{ GLenum::GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT" },
{ GLenum::GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT" },
{ GLenum::GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT" },
{ GLenum::GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT" },
{ GLenum::GL_COMPRESSED_SIGNED_R11_EAC, "GL_COMPRESSED_SIGNED_R11_EAC" },
{ GLenum::GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT" },
{ GLenum::GL_COMPRESSED_SIGNED_RED_RGTC1, "GL_COMPRESSED_SIGNED_RED_RGTC1" },
{ GLenum::GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT" },
{ GLenum::GL_COMPRESSED_SIGNED_RG11_EAC, "GL_COMPRESSED_SIGNED_RG11_EAC" },
{ GLenum::GL_COMPRESSED_SIGNED_RG_RGTC2, "GL_COMPRESSED_SIGNED_RG_RGTC2" },
{ GLenum::GL_COMPRESSED_SLUMINANCE, "GL_COMPRESSED_SLUMINANCE" },
{ GLenum::GL_COMPRESSED_SLUMINANCE_ALPHA, "GL_COMPRESSED_SLUMINANCE_ALPHA" },
{ GLenum::GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, "GL_COMPRESSED_SLUMINANCE_ALPHA_EXT" },
{ GLenum::GL_COMPRESSED_SLUMINANCE_EXT, "GL_COMPRESSED_SLUMINANCE_EXT" },
{ GLenum::GL_COMPRESSED_SRGB, "GL_COMPRESSED_SRGB" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR" },
{ GLenum::GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC" },
{ GLenum::GL_COMPRESSED_SRGB8_ETC2, "GL_COMPRESSED_SRGB8_ETC2" },
{ GLenum::GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA, "GL_COMPRESSED_SRGB_ALPHA" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_EXT, "GL_COMPRESSED_SRGB_ALPHA_EXT" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT" },
{ GLenum::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT" },
{ GLenum::GL_COMPRESSED_SRGB_EXT, "GL_COMPRESSED_SRGB_EXT" },
{ GLenum::GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT" },
{ GLenum::GL_COMPRESSED_TEXTURE_FORMATS, "GL_COMPRESSED_TEXTURE_FORMATS" },
{ GLenum::GL_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_COMPRESSED_TEXTURE_FORMATS_ARB" },
{ GLenum::GL_COMPUTE_PROGRAM_NV, "GL_COMPUTE_PROGRAM_NV" },
{ GLenum::GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV, "GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_COMPUTE_SHADER, "GL_COMPUTE_SHADER" },
{ GLenum::GL_COMPUTE_SHADER_INVOCATIONS, "GL_COMPUTE_SHADER_INVOCATIONS" },
{ GLenum::GL_COMPUTE_SHADER_INVOCATIONS_ARB, "GL_COMPUTE_SHADER_INVOCATIONS_ARB" },
{ GLenum::GL_COMPUTE_SUBROUTINE, "GL_COMPUTE_SUBROUTINE" },
{ GLenum::GL_COMPUTE_SUBROUTINE_UNIFORM, "GL_COMPUTE_SUBROUTINE_UNIFORM" },
{ GLenum::GL_COMPUTE_TEXTURE, "GL_COMPUTE_TEXTURE" },
{ GLenum::GL_COMPUTE_WORK_GROUP_SIZE, "GL_COMPUTE_WORK_GROUP_SIZE" },
{ GLenum::GL_CON_0_ATI, "GL_CON_0_ATI" },
{ GLenum::GL_CON_10_ATI, "GL_CON_10_ATI" },
{ GLenum::GL_CON_11_ATI, "GL_CON_11_ATI" },
{ GLenum::GL_CON_12_ATI, "GL_CON_12_ATI" },
{ GLenum::GL_CON_13_ATI, "GL_CON_13_ATI" },
{ GLenum::GL_CON_14_ATI, "GL_CON_14_ATI" },
{ GLenum::GL_CON_15_ATI, "GL_CON_15_ATI" },
{ GLenum::GL_CON_16_ATI, "GL_CON_16_ATI" },
{ GLenum::GL_CON_17_ATI, "GL_CON_17_ATI" },
{ GLenum::GL_CON_18_ATI, "GL_CON_18_ATI" },
{ GLenum::GL_CON_19_ATI, "GL_CON_19_ATI" },
{ GLenum::GL_CON_1_ATI, "GL_CON_1_ATI" },
{ GLenum::GL_CON_20_ATI, "GL_CON_20_ATI" },
{ GLenum::GL_CON_21_ATI, "GL_CON_21_ATI" },
{ GLenum::GL_CON_22_ATI, "GL_CON_22_ATI" },
{ GLenum::GL_CON_23_ATI, "GL_CON_23_ATI" },
{ GLenum::GL_CON_24_ATI, "GL_CON_24_ATI" },
{ GLenum::GL_CON_25_ATI, "GL_CON_25_ATI" },
{ GLenum::GL_CON_26_ATI, "GL_CON_26_ATI" },
{ GLenum::GL_CON_27_ATI, "GL_CON_27_ATI" },
{ GLenum::GL_CON_28_ATI, "GL_CON_28_ATI" },
{ GLenum::GL_CON_29_ATI, "GL_CON_29_ATI" },
{ GLenum::GL_CON_2_ATI, "GL_CON_2_ATI" },
{ GLenum::GL_CON_30_ATI, "GL_CON_30_ATI" },
{ GLenum::GL_CON_31_ATI, "GL_CON_31_ATI" },
{ GLenum::GL_CON_3_ATI, "GL_CON_3_ATI" },
{ GLenum::GL_CON_4_ATI, "GL_CON_4_ATI" },
{ GLenum::GL_CON_5_ATI, "GL_CON_5_ATI" },
{ GLenum::GL_CON_6_ATI, "GL_CON_6_ATI" },
{ GLenum::GL_CON_7_ATI, "GL_CON_7_ATI" },
{ GLenum::GL_CON_8_ATI, "GL_CON_8_ATI" },
{ GLenum::GL_CON_9_ATI, "GL_CON_9_ATI" },
{ GLenum::GL_CONDITION_SATISFIED, "GL_CONDITION_SATISFIED" },
{ GLenum::GL_CONFORMANT_NV, "GL_CONFORMANT_NV" },
{ GLenum::GL_CONIC_CURVE_TO_NV, "GL_CONIC_CURVE_TO_NV" },
{ GLenum::GL_CONJOINT_NV, "GL_CONJOINT_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV, "GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_DILATE_NV, "GL_CONSERVATIVE_RASTER_DILATE_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV, "GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_MODE_NV, "GL_CONSERVATIVE_RASTER_MODE_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV, "GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV, "GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV" },
{ GLenum::GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV, "GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV" },
{ GLenum::GL_CONSERVATIVE_RASTERIZATION_INTEL, "GL_CONSERVATIVE_RASTERIZATION_INTEL" },
{ GLenum::GL_CONSERVATIVE_RASTERIZATION_NV, "GL_CONSERVATIVE_RASTERIZATION_NV" },
{ GLenum::GL_CONSERVE_MEMORY_HINT_PGI, "GL_CONSERVE_MEMORY_HINT_PGI" },
{ GLenum::GL_CONST_EYE_NV, "GL_CONST_EYE_NV" },
{ GLenum::GL_CONSTANT, "GL_CONSTANT" },
{ GLenum::GL_CONSTANT_ALPHA, "GL_CONSTANT_ALPHA" },
{ GLenum::GL_CONSTANT_ALPHA_EXT, "GL_CONSTANT_ALPHA_EXT" },
{ GLenum::GL_CONSTANT_ARB, "GL_CONSTANT_ARB" },
{ GLenum::GL_CONSTANT_ATTENUATION, "GL_CONSTANT_ATTENUATION" },
{ GLenum::GL_CONSTANT_BORDER, "GL_CONSTANT_BORDER" },
{ GLenum::GL_CONSTANT_BORDER_HP, "GL_CONSTANT_BORDER_HP" },
{ GLenum::GL_CONSTANT_COLOR, "GL_CONSTANT_COLOR" },
{ GLenum::GL_CONSTANT_COLOR0_NV, "GL_CONSTANT_COLOR0_NV" },
{ GLenum::GL_CONSTANT_COLOR1_NV, "GL_CONSTANT_COLOR1_NV" },
{ GLenum::GL_CONSTANT_COLOR_EXT, "GL_CONSTANT_COLOR_EXT" },
{ GLenum::GL_CONSTANT_EXT, "GL_CONSTANT_EXT" },
{ GLenum::GL_CONSTANT_NV, "GL_CONSTANT_NV" },
{ GLenum::GL_CONTEXT_FLAGS, "GL_CONTEXT_FLAGS" },
{ GLenum::GL_CONTEXT_LOST, "GL_CONTEXT_LOST" },
{ GLenum::GL_CONTEXT_LOST_KHR, "GL_CONTEXT_LOST_KHR" },
{ GLenum::GL_CONTEXT_PROFILE_MASK, "GL_CONTEXT_PROFILE_MASK" },
{ GLenum::GL_CONTEXT_RELEASE_BEHAVIOR, "GL_CONTEXT_RELEASE_BEHAVIOR" },
{ GLenum::GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH, "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH" },
{ GLenum::GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR, "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR" },
{ GLenum::GL_CONTEXT_RELEASE_BEHAVIOR_KHR, "GL_CONTEXT_RELEASE_BEHAVIOR_KHR" },
{ GLenum::GL_CONTEXT_ROBUST_ACCESS, "GL_CONTEXT_ROBUST_ACCESS" },
{ GLenum::GL_CONTEXT_ROBUST_ACCESS_KHR, "GL_CONTEXT_ROBUST_ACCESS_KHR" },
{ GLenum::GL_CONTINUOUS_AMD, "GL_CONTINUOUS_AMD" },
{ GLenum::GL_CONTRAST_NV, "GL_CONTRAST_NV" },
{ GLenum::GL_CONVEX_HULL_NV, "GL_CONVEX_HULL_NV" },
{ GLenum::GL_CONVOLUTION_1D, "GL_CONVOLUTION_1D" },
{ GLenum::GL_CONVOLUTION_1D_EXT, "GL_CONVOLUTION_1D_EXT" },
{ GLenum::GL_CONVOLUTION_2D, "GL_CONVOLUTION_2D" },
{ GLenum::GL_CONVOLUTION_2D_EXT, "GL_CONVOLUTION_2D_EXT" },
{ GLenum::GL_CONVOLUTION_BORDER_COLOR, "GL_CONVOLUTION_BORDER_COLOR" },
{ GLenum::GL_CONVOLUTION_BORDER_COLOR_HP, "GL_CONVOLUTION_BORDER_COLOR_HP" },
{ GLenum::GL_CONVOLUTION_BORDER_MODE, "GL_CONVOLUTION_BORDER_MODE" },
{ GLenum::GL_CONVOLUTION_BORDER_MODE_EXT, "GL_CONVOLUTION_BORDER_MODE_EXT" },
{ GLenum::GL_CONVOLUTION_FILTER_BIAS, "GL_CONVOLUTION_FILTER_BIAS" },
{ GLenum::GL_CONVOLUTION_FILTER_BIAS_EXT, "GL_CONVOLUTION_FILTER_BIAS_EXT" },
{ GLenum::GL_CONVOLUTION_FILTER_SCALE, "GL_CONVOLUTION_FILTER_SCALE" },
{ GLenum::GL_CONVOLUTION_FILTER_SCALE_EXT, "GL_CONVOLUTION_FILTER_SCALE_EXT" },
{ GLenum::GL_CONVOLUTION_FORMAT, "GL_CONVOLUTION_FORMAT" },
{ GLenum::GL_CONVOLUTION_FORMAT_EXT, "GL_CONVOLUTION_FORMAT_EXT" },
{ GLenum::GL_CONVOLUTION_HEIGHT, "GL_CONVOLUTION_HEIGHT" },
{ GLenum::GL_CONVOLUTION_HEIGHT_EXT, "GL_CONVOLUTION_HEIGHT_EXT" },
{ GLenum::GL_CONVOLUTION_HINT_SGIX, "GL_CONVOLUTION_HINT_SGIX" },
{ GLenum::GL_CONVOLUTION_WIDTH, "GL_CONVOLUTION_WIDTH" },
{ GLenum::GL_CONVOLUTION_WIDTH_EXT, "GL_CONVOLUTION_WIDTH_EXT" },
{ GLenum::GL_COORD_REPLACE, "GL_COORD_REPLACE" },
{ GLenum::GL_COORD_REPLACE_ARB, "GL_COORD_REPLACE_ARB" },
{ GLenum::GL_COORD_REPLACE_NV, "GL_COORD_REPLACE_NV" },
{ GLenum::GL_COPY, "GL_COPY" },
{ GLenum::GL_COPY_INVERTED, "GL_COPY_INVERTED" },
{ GLenum::GL_COPY_PIXEL_TOKEN, "GL_COPY_PIXEL_TOKEN" },
{ GLenum::GL_COPY_READ_BUFFER, "GL_COPY_READ_BUFFER" },
{ GLenum::GL_COPY_READ_BUFFER_BINDING, "GL_COPY_READ_BUFFER_BINDING" },
{ GLenum::GL_COPY_WRITE_BUFFER, "GL_COPY_WRITE_BUFFER" },
{ GLenum::GL_COPY_WRITE_BUFFER_BINDING, "GL_COPY_WRITE_BUFFER_BINDING" },
{ GLenum::GL_COUNT_DOWN_NV, "GL_COUNT_DOWN_NV" },
{ GLenum::GL_COUNT_UP_NV, "GL_COUNT_UP_NV" },
{ GLenum::GL_COUNTER_RANGE_AMD, "GL_COUNTER_RANGE_AMD" },
{ GLenum::GL_COUNTER_TYPE_AMD, "GL_COUNTER_TYPE_AMD" },
{ GLenum::GL_COVERAGE_MODULATION_NV, "GL_COVERAGE_MODULATION_NV" },
{ GLenum::GL_COVERAGE_MODULATION_TABLE_NV, "GL_COVERAGE_MODULATION_TABLE_NV" },
{ GLenum::GL_COVERAGE_MODULATION_TABLE_SIZE_NV, "GL_COVERAGE_MODULATION_TABLE_SIZE_NV" },
{ GLenum::GL_CUBIC_CURVE_TO_NV, "GL_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_CUBIC_EXT, "GL_CUBIC_EXT" },
{ GLenum::GL_CUBIC_HP, "GL_CUBIC_HP" },
{ GLenum::GL_CULL_FACE, "GL_CULL_FACE" },
{ GLenum::GL_CULL_FACE_MODE, "GL_CULL_FACE_MODE" },
{ GLenum::GL_CULL_FRAGMENT_NV, "GL_CULL_FRAGMENT_NV" },
{ GLenum::GL_CULL_MODES_NV, "GL_CULL_MODES_NV" },
{ GLenum::GL_CULL_VERTEX_EXT, "GL_CULL_VERTEX_EXT" },
{ GLenum::GL_CULL_VERTEX_EYE_POSITION_EXT, "GL_CULL_VERTEX_EYE_POSITION_EXT" },
{ GLenum::GL_CULL_VERTEX_IBM, "GL_CULL_VERTEX_IBM" },
{ GLenum::GL_CULL_VERTEX_OBJECT_POSITION_EXT, "GL_CULL_VERTEX_OBJECT_POSITION_EXT" },
{ GLenum::GL_CURRENT_ATTRIB_NV, "GL_CURRENT_ATTRIB_NV" },
{ GLenum::GL_CURRENT_BINORMAL_EXT, "GL_CURRENT_BINORMAL_EXT" },
{ GLenum::GL_CURRENT_COLOR, "GL_CURRENT_COLOR" },
{ GLenum::GL_CURRENT_FOG_COORD, "GL_CURRENT_FOG_COORD" },
{ GLenum::GL_CURRENT_FOG_COORDINATE, "GL_CURRENT_FOG_COORDINATE" },
{ GLenum::GL_CURRENT_FOG_COORDINATE_EXT, "GL_CURRENT_FOG_COORDINATE_EXT" },
{ GLenum::GL_CURRENT_INDEX, "GL_CURRENT_INDEX" },
{ GLenum::GL_CURRENT_MATRIX_ARB, "GL_CURRENT_MATRIX_ARB" },
{ GLenum::GL_CURRENT_MATRIX_INDEX_ARB, "GL_CURRENT_MATRIX_INDEX_ARB" },
{ GLenum::GL_CURRENT_MATRIX_NV, "GL_CURRENT_MATRIX_NV" },
{ GLenum::GL_CURRENT_MATRIX_STACK_DEPTH_ARB, "GL_CURRENT_MATRIX_STACK_DEPTH_ARB" },
{ GLenum::GL_CURRENT_MATRIX_STACK_DEPTH_NV, "GL_CURRENT_MATRIX_STACK_DEPTH_NV" },
{ GLenum::GL_CURRENT_NORMAL, "GL_CURRENT_NORMAL" },
{ GLenum::GL_CURRENT_OCCLUSION_QUERY_ID_NV, "GL_CURRENT_OCCLUSION_QUERY_ID_NV" },
{ GLenum::GL_CURRENT_PALETTE_MATRIX_ARB, "GL_CURRENT_PALETTE_MATRIX_ARB" },
{ GLenum::GL_CURRENT_PROGRAM, "GL_CURRENT_PROGRAM" },
{ GLenum::GL_CURRENT_QUERY, "GL_CURRENT_QUERY" },
{ GLenum::GL_CURRENT_QUERY_ARB, "GL_CURRENT_QUERY_ARB" },
{ GLenum::GL_CURRENT_RASTER_COLOR, "GL_CURRENT_RASTER_COLOR" },
{ GLenum::GL_CURRENT_RASTER_DISTANCE, "GL_CURRENT_RASTER_DISTANCE" },
{ GLenum::GL_CURRENT_RASTER_INDEX, "GL_CURRENT_RASTER_INDEX" },
{ GLenum::GL_CURRENT_RASTER_NORMAL_SGIX, "GL_CURRENT_RASTER_NORMAL_SGIX" },
{ GLenum::GL_CURRENT_RASTER_POSITION, "GL_CURRENT_RASTER_POSITION" },
{ GLenum::GL_CURRENT_RASTER_POSITION_VALID, "GL_CURRENT_RASTER_POSITION_VALID" },
{ GLenum::GL_CURRENT_RASTER_SECONDARY_COLOR, "GL_CURRENT_RASTER_SECONDARY_COLOR" },
{ GLenum::GL_CURRENT_RASTER_TEXTURE_COORDS, "GL_CURRENT_RASTER_TEXTURE_COORDS" },
{ GLenum::GL_CURRENT_SECONDARY_COLOR, "GL_CURRENT_SECONDARY_COLOR" },
{ GLenum::GL_CURRENT_SECONDARY_COLOR_EXT, "GL_CURRENT_SECONDARY_COLOR_EXT" },
{ GLenum::GL_CURRENT_TANGENT_EXT, "GL_CURRENT_TANGENT_EXT" },
{ GLenum::GL_CURRENT_TEXTURE_COORDS, "GL_CURRENT_TEXTURE_COORDS" },
{ GLenum::GL_CURRENT_TIME_NV, "GL_CURRENT_TIME_NV" },
{ GLenum::GL_CURRENT_VERTEX_ATTRIB, "GL_CURRENT_VERTEX_ATTRIB" },
{ GLenum::GL_CURRENT_VERTEX_ATTRIB_ARB, "GL_CURRENT_VERTEX_ATTRIB_ARB" },
{ GLenum::GL_CURRENT_VERTEX_EXT, "GL_CURRENT_VERTEX_EXT" },
{ GLenum::GL_CURRENT_VERTEX_WEIGHT_EXT, "GL_CURRENT_VERTEX_WEIGHT_EXT" },
{ GLenum::GL_CURRENT_WEIGHT_ARB, "GL_CURRENT_WEIGHT_ARB" },
{ GLenum::GL_CW, "GL_CW" },
{ GLenum::GL_D3D12_FENCE_VALUE_EXT, "GL_D3D12_FENCE_VALUE_EXT" },
{ GLenum::GL_DARKEN_KHR, "GL_DARKEN_KHR" },
{ GLenum::GL_DARKEN_NV, "GL_DARKEN_NV" },
{ GLenum::GL_DATA_BUFFER_AMD, "GL_DATA_BUFFER_AMD" },
{ GLenum::GL_DEBUG_CALLBACK_FUNCTION, "GL_DEBUG_CALLBACK_FUNCTION" },
{ GLenum::GL_DEBUG_CALLBACK_FUNCTION_ARB, "GL_DEBUG_CALLBACK_FUNCTION_ARB" },
{ GLenum::GL_DEBUG_CALLBACK_FUNCTION_KHR, "GL_DEBUG_CALLBACK_FUNCTION_KHR" },
{ GLenum::GL_DEBUG_CALLBACK_USER_PARAM, "GL_DEBUG_CALLBACK_USER_PARAM" },
{ GLenum::GL_DEBUG_CALLBACK_USER_PARAM_ARB, "GL_DEBUG_CALLBACK_USER_PARAM_ARB" },
{ GLenum::GL_DEBUG_CALLBACK_USER_PARAM_KHR, "GL_DEBUG_CALLBACK_USER_PARAM_KHR" },
{ GLenum::GL_DEBUG_CATEGORY_API_ERROR_AMD, "GL_DEBUG_CATEGORY_API_ERROR_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_APPLICATION_AMD, "GL_DEBUG_CATEGORY_APPLICATION_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_DEPRECATION_AMD, "GL_DEBUG_CATEGORY_DEPRECATION_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_OTHER_AMD, "GL_DEBUG_CATEGORY_OTHER_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_PERFORMANCE_AMD, "GL_DEBUG_CATEGORY_PERFORMANCE_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD, "GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD, "GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD" },
{ GLenum::GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD, "GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD" },
{ GLenum::GL_DEBUG_GROUP_STACK_DEPTH, "GL_DEBUG_GROUP_STACK_DEPTH" },
{ GLenum::GL_DEBUG_GROUP_STACK_DEPTH_KHR, "GL_DEBUG_GROUP_STACK_DEPTH_KHR" },
{ GLenum::GL_DEBUG_LOGGED_MESSAGES, "GL_DEBUG_LOGGED_MESSAGES" },
{ GLenum::GL_DEBUG_LOGGED_MESSAGES_AMD, "GL_DEBUG_LOGGED_MESSAGES_AMD" },
{ GLenum::GL_DEBUG_LOGGED_MESSAGES_ARB, "GL_DEBUG_LOGGED_MESSAGES_ARB" },
{ GLenum::GL_DEBUG_LOGGED_MESSAGES_KHR, "GL_DEBUG_LOGGED_MESSAGES_KHR" },
{ GLenum::GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH" },
{ GLenum::GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB" },
{ GLenum::GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR" },
{ GLenum::GL_DEBUG_OUTPUT, "GL_DEBUG_OUTPUT" },
{ GLenum::GL_DEBUG_OUTPUT_KHR, "GL_DEBUG_OUTPUT_KHR" },
{ GLenum::GL_DEBUG_OUTPUT_SYNCHRONOUS, "GL_DEBUG_OUTPUT_SYNCHRONOUS" },
{ GLenum::GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB, "GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB" },
{ GLenum::GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR, "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR" },
{ GLenum::GL_DEBUG_SEVERITY_HIGH, "GL_DEBUG_SEVERITY_HIGH" },
{ GLenum::GL_DEBUG_SEVERITY_HIGH_AMD, "GL_DEBUG_SEVERITY_HIGH_AMD" },
{ GLenum::GL_DEBUG_SEVERITY_HIGH_ARB, "GL_DEBUG_SEVERITY_HIGH_ARB" },
{ GLenum::GL_DEBUG_SEVERITY_HIGH_KHR, "GL_DEBUG_SEVERITY_HIGH_KHR" },
{ GLenum::GL_DEBUG_SEVERITY_LOW, "GL_DEBUG_SEVERITY_LOW" },
{ GLenum::GL_DEBUG_SEVERITY_LOW_AMD, "GL_DEBUG_SEVERITY_LOW_AMD" },
{ GLenum::GL_DEBUG_SEVERITY_LOW_ARB, "GL_DEBUG_SEVERITY_LOW_ARB" },
{ GLenum::GL_DEBUG_SEVERITY_LOW_KHR, "GL_DEBUG_SEVERITY_LOW_KHR" },
{ GLenum::GL_DEBUG_SEVERITY_MEDIUM, "GL_DEBUG_SEVERITY_MEDIUM" },
{ GLenum::GL_DEBUG_SEVERITY_MEDIUM_AMD, "GL_DEBUG_SEVERITY_MEDIUM_AMD" },
{ GLenum::GL_DEBUG_SEVERITY_MEDIUM_ARB, "GL_DEBUG_SEVERITY_MEDIUM_ARB" },
{ GLenum::GL_DEBUG_SEVERITY_MEDIUM_KHR, "GL_DEBUG_SEVERITY_MEDIUM_KHR" },
{ GLenum::GL_DEBUG_SEVERITY_NOTIFICATION, "GL_DEBUG_SEVERITY_NOTIFICATION" },
{ GLenum::GL_DEBUG_SEVERITY_NOTIFICATION_KHR, "GL_DEBUG_SEVERITY_NOTIFICATION_KHR" },
{ GLenum::GL_DEBUG_SOURCE_API, "GL_DEBUG_SOURCE_API" },
{ GLenum::GL_DEBUG_SOURCE_API_ARB, "GL_DEBUG_SOURCE_API_ARB" },
{ GLenum::GL_DEBUG_SOURCE_API_KHR, "GL_DEBUG_SOURCE_API_KHR" },
{ GLenum::GL_DEBUG_SOURCE_APPLICATION, "GL_DEBUG_SOURCE_APPLICATION" },
{ GLenum::GL_DEBUG_SOURCE_APPLICATION_ARB, "GL_DEBUG_SOURCE_APPLICATION_ARB" },
{ GLenum::GL_DEBUG_SOURCE_APPLICATION_KHR, "GL_DEBUG_SOURCE_APPLICATION_KHR" },
{ GLenum::GL_DEBUG_SOURCE_OTHER, "GL_DEBUG_SOURCE_OTHER" },
{ GLenum::GL_DEBUG_SOURCE_OTHER_ARB, "GL_DEBUG_SOURCE_OTHER_ARB" },
{ GLenum::GL_DEBUG_SOURCE_OTHER_KHR, "GL_DEBUG_SOURCE_OTHER_KHR" },
{ GLenum::GL_DEBUG_SOURCE_SHADER_COMPILER, "GL_DEBUG_SOURCE_SHADER_COMPILER" },
{ GLenum::GL_DEBUG_SOURCE_SHADER_COMPILER_ARB, "GL_DEBUG_SOURCE_SHADER_COMPILER_ARB" },
{ GLenum::GL_DEBUG_SOURCE_SHADER_COMPILER_KHR, "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR" },
{ GLenum::GL_DEBUG_SOURCE_THIRD_PARTY, "GL_DEBUG_SOURCE_THIRD_PARTY" },
{ GLenum::GL_DEBUG_SOURCE_THIRD_PARTY_ARB, "GL_DEBUG_SOURCE_THIRD_PARTY_ARB" },
{ GLenum::GL_DEBUG_SOURCE_THIRD_PARTY_KHR, "GL_DEBUG_SOURCE_THIRD_PARTY_KHR" },
{ GLenum::GL_DEBUG_SOURCE_WINDOW_SYSTEM, "GL_DEBUG_SOURCE_WINDOW_SYSTEM" },
{ GLenum::GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB, "GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB" },
{ GLenum::GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR, "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR" },
{ GLenum::GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR" },
{ GLenum::GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB" },
{ GLenum::GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR" },
{ GLenum::GL_DEBUG_TYPE_ERROR, "GL_DEBUG_TYPE_ERROR" },
{ GLenum::GL_DEBUG_TYPE_ERROR_ARB, "GL_DEBUG_TYPE_ERROR_ARB" },
{ GLenum::GL_DEBUG_TYPE_ERROR_KHR, "GL_DEBUG_TYPE_ERROR_KHR" },
{ GLenum::GL_DEBUG_TYPE_MARKER, "GL_DEBUG_TYPE_MARKER" },
{ GLenum::GL_DEBUG_TYPE_MARKER_KHR, "GL_DEBUG_TYPE_MARKER_KHR" },
{ GLenum::GL_DEBUG_TYPE_OTHER, "GL_DEBUG_TYPE_OTHER" },
{ GLenum::GL_DEBUG_TYPE_OTHER_ARB, "GL_DEBUG_TYPE_OTHER_ARB" },
{ GLenum::GL_DEBUG_TYPE_OTHER_KHR, "GL_DEBUG_TYPE_OTHER_KHR" },
{ GLenum::GL_DEBUG_TYPE_PERFORMANCE, "GL_DEBUG_TYPE_PERFORMANCE" },
{ GLenum::GL_DEBUG_TYPE_PERFORMANCE_ARB, "GL_DEBUG_TYPE_PERFORMANCE_ARB" },
{ GLenum::GL_DEBUG_TYPE_PERFORMANCE_KHR, "GL_DEBUG_TYPE_PERFORMANCE_KHR" },
{ GLenum::GL_DEBUG_TYPE_POP_GROUP, "GL_DEBUG_TYPE_POP_GROUP" },
{ GLenum::GL_DEBUG_TYPE_POP_GROUP_KHR, "GL_DEBUG_TYPE_POP_GROUP_KHR" },
{ GLenum::GL_DEBUG_TYPE_PORTABILITY, "GL_DEBUG_TYPE_PORTABILITY" },
{ GLenum::GL_DEBUG_TYPE_PORTABILITY_ARB, "GL_DEBUG_TYPE_PORTABILITY_ARB" },
{ GLenum::GL_DEBUG_TYPE_PORTABILITY_KHR, "GL_DEBUG_TYPE_PORTABILITY_KHR" },
{ GLenum::GL_DEBUG_TYPE_PUSH_GROUP, "GL_DEBUG_TYPE_PUSH_GROUP" },
{ GLenum::GL_DEBUG_TYPE_PUSH_GROUP_KHR, "GL_DEBUG_TYPE_PUSH_GROUP_KHR" },
{ GLenum::GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR" },
{ GLenum::GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB" },
{ GLenum::GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR" },
{ GLenum::GL_DECAL, "GL_DECAL" },
{ GLenum::GL_DECODE_EXT, "GL_DECODE_EXT" },
{ GLenum::GL_DECR, "GL_DECR" },
{ GLenum::GL_DECR_WRAP, "GL_DECR_WRAP" },
{ GLenum::GL_DECR_WRAP_EXT, "GL_DECR_WRAP_EXT" },
{ GLenum::GL_DEDICATED_MEMORY_OBJECT_EXT, "GL_DEDICATED_MEMORY_OBJECT_EXT" },
{ GLenum::GL_DEFORMATIONS_MASK_SGIX, "GL_DEFORMATIONS_MASK_SGIX" },
{ GLenum::GL_DELETE_STATUS, "GL_DELETE_STATUS" },
{ GLenum::GL_DEPENDENT_AR_TEXTURE_2D_NV, "GL_DEPENDENT_AR_TEXTURE_2D_NV" },
{ GLenum::GL_DEPENDENT_GB_TEXTURE_2D_NV, "GL_DEPENDENT_GB_TEXTURE_2D_NV" },
{ GLenum::GL_DEPENDENT_HILO_TEXTURE_2D_NV, "GL_DEPENDENT_HILO_TEXTURE_2D_NV" },
{ GLenum::GL_DEPENDENT_RGB_TEXTURE_3D_NV, "GL_DEPENDENT_RGB_TEXTURE_3D_NV" },
{ GLenum::GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV, "GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV" },
{ GLenum::GL_DEPTH, "GL_DEPTH" },
{ GLenum::GL_DEPTH24_STENCIL8, "GL_DEPTH24_STENCIL8" },
{ GLenum::GL_DEPTH24_STENCIL8_EXT, "GL_DEPTH24_STENCIL8_EXT" },
{ GLenum::GL_DEPTH32F_STENCIL8, "GL_DEPTH32F_STENCIL8" },
{ GLenum::GL_DEPTH32F_STENCIL8_NV, "GL_DEPTH32F_STENCIL8_NV" },
{ GLenum::GL_DEPTH_ATTACHMENT, "GL_DEPTH_ATTACHMENT" },
{ GLenum::GL_DEPTH_ATTACHMENT_EXT, "GL_DEPTH_ATTACHMENT_EXT" },
{ GLenum::GL_DEPTH_BIAS, "GL_DEPTH_BIAS" },
{ GLenum::GL_DEPTH_BITS, "GL_DEPTH_BITS" },
{ GLenum::GL_DEPTH_BOUNDS_EXT, "GL_DEPTH_BOUNDS_EXT" },
{ GLenum::GL_DEPTH_BOUNDS_TEST_EXT, "GL_DEPTH_BOUNDS_TEST_EXT" },
{ GLenum::GL_DEPTH_BUFFER_FLOAT_MODE_NV, "GL_DEPTH_BUFFER_FLOAT_MODE_NV" },
{ GLenum::GL_DEPTH_CLAMP, "GL_DEPTH_CLAMP" },
{ GLenum::GL_DEPTH_CLAMP_FAR_AMD, "GL_DEPTH_CLAMP_FAR_AMD" },
{ GLenum::GL_DEPTH_CLAMP_NEAR_AMD, "GL_DEPTH_CLAMP_NEAR_AMD" },
{ GLenum::GL_DEPTH_CLAMP_NV, "GL_DEPTH_CLAMP_NV" },
{ GLenum::GL_DEPTH_CLEAR_VALUE, "GL_DEPTH_CLEAR_VALUE" },
{ GLenum::GL_DEPTH_COMPONENT, "GL_DEPTH_COMPONENT" },
{ GLenum::GL_DEPTH_COMPONENT16, "GL_DEPTH_COMPONENT16" },
{ GLenum::GL_DEPTH_COMPONENT16_ARB, "GL_DEPTH_COMPONENT16_ARB" },
{ GLenum::GL_DEPTH_COMPONENT16_SGIX, "GL_DEPTH_COMPONENT16_SGIX" },
{ GLenum::GL_DEPTH_COMPONENT24, "GL_DEPTH_COMPONENT24" },
{ GLenum::GL_DEPTH_COMPONENT24_ARB, "GL_DEPTH_COMPONENT24_ARB" },
{ GLenum::GL_DEPTH_COMPONENT24_SGIX, "GL_DEPTH_COMPONENT24_SGIX" },
{ GLenum::GL_DEPTH_COMPONENT32, "GL_DEPTH_COMPONENT32" },
{ GLenum::GL_DEPTH_COMPONENT32_ARB, "GL_DEPTH_COMPONENT32_ARB" },
{ GLenum::GL_DEPTH_COMPONENT32_SGIX, "GL_DEPTH_COMPONENT32_SGIX" },
{ GLenum::GL_DEPTH_COMPONENT32F, "GL_DEPTH_COMPONENT32F" },
{ GLenum::GL_DEPTH_COMPONENT32F_NV, "GL_DEPTH_COMPONENT32F_NV" },
{ GLenum::GL_DEPTH_COMPONENTS, "GL_DEPTH_COMPONENTS" },
{ GLenum::GL_DEPTH_FUNC, "GL_DEPTH_FUNC" },
{ GLenum::GL_DEPTH_RANGE, "GL_DEPTH_RANGE" },
{ GLenum::GL_DEPTH_RENDERABLE, "GL_DEPTH_RENDERABLE" },
{ GLenum::GL_DEPTH_SAMPLES_NV, "GL_DEPTH_SAMPLES_NV" },
{ GLenum::GL_DEPTH_SCALE, "GL_DEPTH_SCALE" },
{ GLenum::GL_DEPTH_STENCIL, "GL_DEPTH_STENCIL" },
{ GLenum::GL_DEPTH_STENCIL_ATTACHMENT, "GL_DEPTH_STENCIL_ATTACHMENT" },
{ GLenum::GL_DEPTH_STENCIL_EXT, "GL_DEPTH_STENCIL_EXT" },
{ GLenum::GL_DEPTH_STENCIL_NV, "GL_DEPTH_STENCIL_NV" },
{ GLenum::GL_DEPTH_STENCIL_TEXTURE_MODE, "GL_DEPTH_STENCIL_TEXTURE_MODE" },
{ GLenum::GL_DEPTH_STENCIL_TO_BGRA_NV, "GL_DEPTH_STENCIL_TO_BGRA_NV" },
{ GLenum::GL_DEPTH_STENCIL_TO_RGBA_NV, "GL_DEPTH_STENCIL_TO_RGBA_NV" },
{ GLenum::GL_DEPTH_TEST, "GL_DEPTH_TEST" },
{ GLenum::GL_DEPTH_TEXTURE_MODE, "GL_DEPTH_TEXTURE_MODE" },
{ GLenum::GL_DEPTH_TEXTURE_MODE_ARB, "GL_DEPTH_TEXTURE_MODE_ARB" },
{ GLenum::GL_DEPTH_WRITEMASK, "GL_DEPTH_WRITEMASK" },
{ GLenum::GL_DETACHED_BUFFERS_NV, "GL_DETACHED_BUFFERS_NV" },
{ GLenum::GL_DETACHED_MEMORY_INCARNATION_NV, "GL_DETACHED_MEMORY_INCARNATION_NV" },
{ GLenum::GL_DETACHED_TEXTURES_NV, "GL_DETACHED_TEXTURES_NV" },
{ GLenum::GL_DETAIL_TEXTURE_2D_BINDING_SGIS, "GL_DETAIL_TEXTURE_2D_BINDING_SGIS" },
{ GLenum::GL_DETAIL_TEXTURE_2D_SGIS, "GL_DETAIL_TEXTURE_2D_SGIS" },
{ GLenum::GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS, "GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS" },
{ GLenum::GL_DETAIL_TEXTURE_LEVEL_SGIS, "GL_DETAIL_TEXTURE_LEVEL_SGIS" },
{ GLenum::GL_DETAIL_TEXTURE_MODE_SGIS, "GL_DETAIL_TEXTURE_MODE_SGIS" },
{ GLenum::GL_DEVICE_LUID_EXT, "GL_DEVICE_LUID_EXT" },
{ GLenum::GL_DEVICE_NODE_MASK_EXT, "GL_DEVICE_NODE_MASK_EXT" },
{ GLenum::GL_DEVICE_UUID_EXT, "GL_DEVICE_UUID_EXT" },
{ GLenum::GL_DIFFERENCE_KHR, "GL_DIFFERENCE_KHR" },
{ GLenum::GL_DIFFERENCE_NV, "GL_DIFFERENCE_NV" },
{ GLenum::GL_DIFFUSE, "GL_DIFFUSE" },
{ GLenum::GL_DISCARD_ATI, "GL_DISCARD_ATI" },
{ GLenum::GL_DISCARD_NV, "GL_DISCARD_NV" },
{ GLenum::GL_DISCRETE_AMD, "GL_DISCRETE_AMD" },
{ GLenum::GL_DISJOINT_NV, "GL_DISJOINT_NV" },
{ GLenum::GL_DISPATCH_INDIRECT_BUFFER, "GL_DISPATCH_INDIRECT_BUFFER" },
{ GLenum::GL_DISPATCH_INDIRECT_BUFFER_BINDING, "GL_DISPATCH_INDIRECT_BUFFER_BINDING" },
{ GLenum::GL_DISPLAY_LIST, "GL_DISPLAY_LIST" },
{ GLenum::GL_DISTANCE_ATTENUATION_EXT, "GL_DISTANCE_ATTENUATION_EXT" },
{ GLenum::GL_DISTANCE_ATTENUATION_SGIS, "GL_DISTANCE_ATTENUATION_SGIS" },
{ GLenum::GL_DITHER, "GL_DITHER" },
{ GLenum::GL_DOMAIN, "GL_DOMAIN" },
{ GLenum::GL_DONT_CARE, "GL_DONT_CARE" },
{ GLenum::GL_DOT2_ADD_ATI, "GL_DOT2_ADD_ATI" },
{ GLenum::GL_DOT3_ATI, "GL_DOT3_ATI" },
{ GLenum::GL_DOT3_RGB, "GL_DOT3_RGB" },
{ GLenum::GL_DOT3_RGB_ARB, "GL_DOT3_RGB_ARB" },
{ GLenum::GL_DOT3_RGB_EXT, "GL_DOT3_RGB_EXT" },
{ GLenum::GL_DOT3_RGBA, "GL_DOT3_RGBA" },
{ GLenum::GL_DOT3_RGBA_ARB, "GL_DOT3_RGBA_ARB" },
{ GLenum::GL_DOT3_RGBA_EXT, "GL_DOT3_RGBA_EXT" },
{ GLenum::GL_DOT4_ATI, "GL_DOT4_ATI" },
{ GLenum::GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV, "GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV" },
{ GLenum::GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV, "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV" },
{ GLenum::GL_DOT_PRODUCT_DEPTH_REPLACE_NV, "GL_DOT_PRODUCT_DEPTH_REPLACE_NV" },
{ GLenum::GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV" },
{ GLenum::GL_DOT_PRODUCT_NV, "GL_DOT_PRODUCT_NV" },
{ GLenum::GL_DOT_PRODUCT_PASS_THROUGH_NV, "GL_DOT_PRODUCT_PASS_THROUGH_NV" },
{ GLenum::GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV, "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV" },
{ GLenum::GL_DOT_PRODUCT_TEXTURE_1D_NV, "GL_DOT_PRODUCT_TEXTURE_1D_NV" },
{ GLenum::GL_DOT_PRODUCT_TEXTURE_2D_NV, "GL_DOT_PRODUCT_TEXTURE_2D_NV" },
{ GLenum::GL_DOT_PRODUCT_TEXTURE_3D_NV, "GL_DOT_PRODUCT_TEXTURE_3D_NV" },
{ GLenum::GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV" },
{ GLenum::GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV, "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_DOUBLE, "GL_DOUBLE" },
{ GLenum::GL_DOUBLE_MAT2, "GL_DOUBLE_MAT2" },
{ GLenum::GL_DOUBLE_MAT2_EXT, "GL_DOUBLE_MAT2_EXT" },
{ GLenum::GL_DOUBLE_MAT2x3, "GL_DOUBLE_MAT2x3" },
{ GLenum::GL_DOUBLE_MAT2x3_EXT, "GL_DOUBLE_MAT2x3_EXT" },
{ GLenum::GL_DOUBLE_MAT2x4, "GL_DOUBLE_MAT2x4" },
{ GLenum::GL_DOUBLE_MAT2x4_EXT, "GL_DOUBLE_MAT2x4_EXT" },
{ GLenum::GL_DOUBLE_MAT3, "GL_DOUBLE_MAT3" },
{ GLenum::GL_DOUBLE_MAT3_EXT, "GL_DOUBLE_MAT3_EXT" },
{ GLenum::GL_DOUBLE_MAT3x2, "GL_DOUBLE_MAT3x2" },
{ GLenum::GL_DOUBLE_MAT3x2_EXT, "GL_DOUBLE_MAT3x2_EXT" },
{ GLenum::GL_DOUBLE_MAT3x4, "GL_DOUBLE_MAT3x4" },
{ GLenum::GL_DOUBLE_MAT3x4_EXT, "GL_DOUBLE_MAT3x4_EXT" },
{ GLenum::GL_DOUBLE_MAT4, "GL_DOUBLE_MAT4" },
{ GLenum::GL_DOUBLE_MAT4_EXT, "GL_DOUBLE_MAT4_EXT" },
{ GLenum::GL_DOUBLE_MAT4x2, "GL_DOUBLE_MAT4x2" },
{ GLenum::GL_DOUBLE_MAT4x2_EXT, "GL_DOUBLE_MAT4x2_EXT" },
{ GLenum::GL_DOUBLE_MAT4x3, "GL_DOUBLE_MAT4x3" },
{ GLenum::GL_DOUBLE_MAT4x3_EXT, "GL_DOUBLE_MAT4x3_EXT" },
{ GLenum::GL_DOUBLE_VEC2, "GL_DOUBLE_VEC2" },
{ GLenum::GL_DOUBLE_VEC2_EXT, "GL_DOUBLE_VEC2_EXT" },
{ GLenum::GL_DOUBLE_VEC3, "GL_DOUBLE_VEC3" },
{ GLenum::GL_DOUBLE_VEC3_EXT, "GL_DOUBLE_VEC3_EXT" },
{ GLenum::GL_DOUBLE_VEC4, "GL_DOUBLE_VEC4" },
{ GLenum::GL_DOUBLE_VEC4_EXT, "GL_DOUBLE_VEC4_EXT" },
{ GLenum::GL_DOUBLEBUFFER, "GL_DOUBLEBUFFER" },
{ GLenum::GL_DRAW_ARRAYS_COMMAND_NV, "GL_DRAW_ARRAYS_COMMAND_NV" },
{ GLenum::GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV, "GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV" },
{ GLenum::GL_DRAW_ARRAYS_STRIP_COMMAND_NV, "GL_DRAW_ARRAYS_STRIP_COMMAND_NV" },
{ GLenum::GL_DRAW_BUFFER, "GL_DRAW_BUFFER" },
{ GLenum::GL_DRAW_BUFFER0, "GL_DRAW_BUFFER0" },
{ GLenum::GL_DRAW_BUFFER0_ARB, "GL_DRAW_BUFFER0_ARB" },
{ GLenum::GL_DRAW_BUFFER0_ATI, "GL_DRAW_BUFFER0_ATI" },
{ GLenum::GL_DRAW_BUFFER1, "GL_DRAW_BUFFER1" },
{ GLenum::GL_DRAW_BUFFER10, "GL_DRAW_BUFFER10" },
{ GLenum::GL_DRAW_BUFFER10_ARB, "GL_DRAW_BUFFER10_ARB" },
{ GLenum::GL_DRAW_BUFFER10_ATI, "GL_DRAW_BUFFER10_ATI" },
{ GLenum::GL_DRAW_BUFFER11, "GL_DRAW_BUFFER11" },
{ GLenum::GL_DRAW_BUFFER11_ARB, "GL_DRAW_BUFFER11_ARB" },
{ GLenum::GL_DRAW_BUFFER11_ATI, "GL_DRAW_BUFFER11_ATI" },
{ GLenum::GL_DRAW_BUFFER12, "GL_DRAW_BUFFER12" },
{ GLenum::GL_DRAW_BUFFER12_ARB, "GL_DRAW_BUFFER12_ARB" },
{ GLenum::GL_DRAW_BUFFER12_ATI, "GL_DRAW_BUFFER12_ATI" },
{ GLenum::GL_DRAW_BUFFER13, "GL_DRAW_BUFFER13" },
{ GLenum::GL_DRAW_BUFFER13_ARB, "GL_DRAW_BUFFER13_ARB" },
{ GLenum::GL_DRAW_BUFFER13_ATI, "GL_DRAW_BUFFER13_ATI" },
{ GLenum::GL_DRAW_BUFFER14, "GL_DRAW_BUFFER14" },
{ GLenum::GL_DRAW_BUFFER14_ARB, "GL_DRAW_BUFFER14_ARB" },
{ GLenum::GL_DRAW_BUFFER14_ATI, "GL_DRAW_BUFFER14_ATI" },
{ GLenum::GL_DRAW_BUFFER15, "GL_DRAW_BUFFER15" },
{ GLenum::GL_DRAW_BUFFER15_ARB, "GL_DRAW_BUFFER15_ARB" },
{ GLenum::GL_DRAW_BUFFER15_ATI, "GL_DRAW_BUFFER15_ATI" },
{ GLenum::GL_DRAW_BUFFER1_ARB, "GL_DRAW_BUFFER1_ARB" },
{ GLenum::GL_DRAW_BUFFER1_ATI, "GL_DRAW_BUFFER1_ATI" },
{ GLenum::GL_DRAW_BUFFER2, "GL_DRAW_BUFFER2" },
{ GLenum::GL_DRAW_BUFFER2_ARB, "GL_DRAW_BUFFER2_ARB" },
{ GLenum::GL_DRAW_BUFFER2_ATI, "GL_DRAW_BUFFER2_ATI" },
{ GLenum::GL_DRAW_BUFFER3, "GL_DRAW_BUFFER3" },
{ GLenum::GL_DRAW_BUFFER3_ARB, "GL_DRAW_BUFFER3_ARB" },
{ GLenum::GL_DRAW_BUFFER3_ATI, "GL_DRAW_BUFFER3_ATI" },
{ GLenum::GL_DRAW_BUFFER4, "GL_DRAW_BUFFER4" },
{ GLenum::GL_DRAW_BUFFER4_ARB, "GL_DRAW_BUFFER4_ARB" },
{ GLenum::GL_DRAW_BUFFER4_ATI, "GL_DRAW_BUFFER4_ATI" },
{ GLenum::GL_DRAW_BUFFER5, "GL_DRAW_BUFFER5" },
{ GLenum::GL_DRAW_BUFFER5_ARB, "GL_DRAW_BUFFER5_ARB" },
{ GLenum::GL_DRAW_BUFFER5_ATI, "GL_DRAW_BUFFER5_ATI" },
{ GLenum::GL_DRAW_BUFFER6, "GL_DRAW_BUFFER6" },
{ GLenum::GL_DRAW_BUFFER6_ARB, "GL_DRAW_BUFFER6_ARB" },
{ GLenum::GL_DRAW_BUFFER6_ATI, "GL_DRAW_BUFFER6_ATI" },
{ GLenum::GL_DRAW_BUFFER7, "GL_DRAW_BUFFER7" },
{ GLenum::GL_DRAW_BUFFER7_ARB, "GL_DRAW_BUFFER7_ARB" },
{ GLenum::GL_DRAW_BUFFER7_ATI, "GL_DRAW_BUFFER7_ATI" },
{ GLenum::GL_DRAW_BUFFER8, "GL_DRAW_BUFFER8" },
{ GLenum::GL_DRAW_BUFFER8_ARB, "GL_DRAW_BUFFER8_ARB" },
{ GLenum::GL_DRAW_BUFFER8_ATI, "GL_DRAW_BUFFER8_ATI" },
{ GLenum::GL_DRAW_BUFFER9, "GL_DRAW_BUFFER9" },
{ GLenum::GL_DRAW_BUFFER9_ARB, "GL_DRAW_BUFFER9_ARB" },
{ GLenum::GL_DRAW_BUFFER9_ATI, "GL_DRAW_BUFFER9_ATI" },
{ GLenum::GL_DRAW_ELEMENTS_COMMAND_NV, "GL_DRAW_ELEMENTS_COMMAND_NV" },
{ GLenum::GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV, "GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV" },
{ GLenum::GL_DRAW_ELEMENTS_STRIP_COMMAND_NV, "GL_DRAW_ELEMENTS_STRIP_COMMAND_NV" },
{ GLenum::GL_DRAW_FRAMEBUFFER, "GL_DRAW_FRAMEBUFFER" },
{ GLenum::GL_DRAW_FRAMEBUFFER_BINDING, "GL_DRAW_FRAMEBUFFER_BINDING" },
{ GLenum::GL_DRAW_FRAMEBUFFER_BINDING_EXT, "GL_DRAW_FRAMEBUFFER_BINDING_EXT" },
{ GLenum::GL_DRAW_FRAMEBUFFER_EXT, "GL_DRAW_FRAMEBUFFER_EXT" },
{ GLenum::GL_DRAW_INDIRECT_ADDRESS_NV, "GL_DRAW_INDIRECT_ADDRESS_NV" },
{ GLenum::GL_DRAW_INDIRECT_BUFFER, "GL_DRAW_INDIRECT_BUFFER" },
{ GLenum::GL_DRAW_INDIRECT_BUFFER_BINDING, "GL_DRAW_INDIRECT_BUFFER_BINDING" },
{ GLenum::GL_DRAW_INDIRECT_LENGTH_NV, "GL_DRAW_INDIRECT_LENGTH_NV" },
{ GLenum::GL_DRAW_INDIRECT_UNIFIED_NV, "GL_DRAW_INDIRECT_UNIFIED_NV" },
{ GLenum::GL_DRAW_PIXEL_TOKEN, "GL_DRAW_PIXEL_TOKEN" },
{ GLenum::GL_DRAW_PIXELS_APPLE, "GL_DRAW_PIXELS_APPLE" },
{ GLenum::GL_DRIVER_UUID_EXT, "GL_DRIVER_UUID_EXT" },
{ GLenum::GL_DS_BIAS_NV, "GL_DS_BIAS_NV" },
{ GLenum::GL_DS_SCALE_NV, "GL_DS_SCALE_NV" },
{ GLenum::GL_DSDT8_MAG8_INTENSITY8_NV, "GL_DSDT8_MAG8_INTENSITY8_NV" },
{ GLenum::GL_DSDT8_MAG8_NV, "GL_DSDT8_MAG8_NV" },
{ GLenum::GL_DSDT8_NV, "GL_DSDT8_NV" },
{ GLenum::GL_DSDT_MAG_INTENSITY_NV, "GL_DSDT_MAG_INTENSITY_NV" },
{ GLenum::GL_DSDT_MAG_NV, "GL_DSDT_MAG_NV" },
{ GLenum::GL_DSDT_MAG_VIB_NV, "GL_DSDT_MAG_VIB_NV" },
{ GLenum::GL_DSDT_NV, "GL_DSDT_NV" },
{ GLenum::GL_DST_ALPHA, "GL_DST_ALPHA" },
{ GLenum::GL_DST_ATOP_NV, "GL_DST_ATOP_NV" },
{ GLenum::GL_DST_COLOR, "GL_DST_COLOR" },
{ GLenum::GL_DST_IN_NV, "GL_DST_IN_NV" },
{ GLenum::GL_DST_NV, "GL_DST_NV" },
{ GLenum::GL_DST_OUT_NV, "GL_DST_OUT_NV" },
{ GLenum::GL_DST_OVER_NV, "GL_DST_OVER_NV" },
{ GLenum::GL_DT_BIAS_NV, "GL_DT_BIAS_NV" },
{ GLenum::GL_DT_SCALE_NV, "GL_DT_SCALE_NV" },
{ GLenum::GL_DU8DV8_ATI, "GL_DU8DV8_ATI" },
{ GLenum::GL_DUAL_ALPHA12_SGIS, "GL_DUAL_ALPHA12_SGIS" },
{ GLenum::GL_DUAL_ALPHA16_SGIS, "GL_DUAL_ALPHA16_SGIS" },
{ GLenum::GL_DUAL_ALPHA4_SGIS, "GL_DUAL_ALPHA4_SGIS" },
{ GLenum::GL_DUAL_ALPHA8_SGIS, "GL_DUAL_ALPHA8_SGIS" },
{ GLenum::GL_DUAL_INTENSITY12_SGIS, "GL_DUAL_INTENSITY12_SGIS" },
{ GLenum::GL_DUAL_INTENSITY16_SGIS, "GL_DUAL_INTENSITY16_SGIS" },
{ GLenum::GL_DUAL_INTENSITY4_SGIS, "GL_DUAL_INTENSITY4_SGIS" },
{ GLenum::GL_DUAL_INTENSITY8_SGIS, "GL_DUAL_INTENSITY8_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE12_SGIS, "GL_DUAL_LUMINANCE12_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE16_SGIS, "GL_DUAL_LUMINANCE16_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE4_SGIS, "GL_DUAL_LUMINANCE4_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE8_SGIS, "GL_DUAL_LUMINANCE8_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE_ALPHA4_SGIS, "GL_DUAL_LUMINANCE_ALPHA4_SGIS" },
{ GLenum::GL_DUAL_LUMINANCE_ALPHA8_SGIS, "GL_DUAL_LUMINANCE_ALPHA8_SGIS" },
{ GLenum::GL_DUAL_TEXTURE_SELECT_SGIS, "GL_DUAL_TEXTURE_SELECT_SGIS" },
{ GLenum::GL_DUDV_ATI, "GL_DUDV_ATI" },
{ GLenum::GL_DUP_FIRST_CUBIC_CURVE_TO_NV, "GL_DUP_FIRST_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_DUP_LAST_CUBIC_CURVE_TO_NV, "GL_DUP_LAST_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_DYNAMIC_ATI, "GL_DYNAMIC_ATI" },
{ GLenum::GL_DYNAMIC_COPY, "GL_DYNAMIC_COPY" },
{ GLenum::GL_DYNAMIC_COPY_ARB, "GL_DYNAMIC_COPY_ARB" },
{ GLenum::GL_DYNAMIC_DRAW, "GL_DYNAMIC_DRAW" },
{ GLenum::GL_DYNAMIC_DRAW_ARB, "GL_DYNAMIC_DRAW_ARB" },
{ GLenum::GL_DYNAMIC_READ, "GL_DYNAMIC_READ" },
{ GLenum::GL_DYNAMIC_READ_ARB, "GL_DYNAMIC_READ_ARB" },
{ GLenum::GL_E_TIMES_F_NV, "GL_E_TIMES_F_NV" },
{ GLenum::GL_EDGE_FLAG, "GL_EDGE_FLAG" },
{ GLenum::GL_EDGE_FLAG_ARRAY, "GL_EDGE_FLAG_ARRAY" },
{ GLenum::GL_EDGE_FLAG_ARRAY_ADDRESS_NV, "GL_EDGE_FLAG_ARRAY_ADDRESS_NV" },
{ GLenum::GL_EDGE_FLAG_ARRAY_BUFFER_BINDING, "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_EDGE_FLAG_ARRAY_COUNT_EXT, "GL_EDGE_FLAG_ARRAY_COUNT_EXT" },
{ GLenum::GL_EDGE_FLAG_ARRAY_EXT, "GL_EDGE_FLAG_ARRAY_EXT" },
{ GLenum::GL_EDGE_FLAG_ARRAY_LENGTH_NV, "GL_EDGE_FLAG_ARRAY_LENGTH_NV" },
{ GLenum::GL_EDGE_FLAG_ARRAY_LIST_IBM, "GL_EDGE_FLAG_ARRAY_LIST_IBM" },
{ GLenum::GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM, "GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_EDGE_FLAG_ARRAY_POINTER, "GL_EDGE_FLAG_ARRAY_POINTER" },
{ GLenum::GL_EDGE_FLAG_ARRAY_POINTER_EXT, "GL_EDGE_FLAG_ARRAY_POINTER_EXT" },
{ GLenum::GL_EDGE_FLAG_ARRAY_STRIDE, "GL_EDGE_FLAG_ARRAY_STRIDE" },
{ GLenum::GL_EDGE_FLAG_ARRAY_STRIDE_EXT, "GL_EDGE_FLAG_ARRAY_STRIDE_EXT" },
{ GLenum::GL_EFFECTIVE_RASTER_SAMPLES_EXT, "GL_EFFECTIVE_RASTER_SAMPLES_EXT" },
{ GLenum::GL_ELEMENT_ADDRESS_COMMAND_NV, "GL_ELEMENT_ADDRESS_COMMAND_NV" },
{ GLenum::GL_ELEMENT_ARRAY_ADDRESS_NV, "GL_ELEMENT_ARRAY_ADDRESS_NV" },
{ GLenum::GL_ELEMENT_ARRAY_APPLE, "GL_ELEMENT_ARRAY_APPLE" },
{ GLenum::GL_ELEMENT_ARRAY_ATI, "GL_ELEMENT_ARRAY_ATI" },
{ GLenum::GL_ELEMENT_ARRAY_BUFFER, "GL_ELEMENT_ARRAY_BUFFER" },
{ GLenum::GL_ELEMENT_ARRAY_BUFFER_ARB, "GL_ELEMENT_ARRAY_BUFFER_ARB" },
{ GLenum::GL_ELEMENT_ARRAY_BUFFER_BINDING, "GL_ELEMENT_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_ELEMENT_ARRAY_LENGTH_NV, "GL_ELEMENT_ARRAY_LENGTH_NV" },
{ GLenum::GL_ELEMENT_ARRAY_POINTER_APPLE, "GL_ELEMENT_ARRAY_POINTER_APPLE" },
{ GLenum::GL_ELEMENT_ARRAY_POINTER_ATI, "GL_ELEMENT_ARRAY_POINTER_ATI" },
{ GLenum::GL_ELEMENT_ARRAY_TYPE_APPLE, "GL_ELEMENT_ARRAY_TYPE_APPLE" },
{ GLenum::GL_ELEMENT_ARRAY_TYPE_ATI, "GL_ELEMENT_ARRAY_TYPE_ATI" },
{ GLenum::GL_ELEMENT_ARRAY_UNIFIED_NV, "GL_ELEMENT_ARRAY_UNIFIED_NV" },
{ GLenum::GL_EMBOSS_CONSTANT_NV, "GL_EMBOSS_CONSTANT_NV" },
{ GLenum::GL_EMBOSS_LIGHT_NV, "GL_EMBOSS_LIGHT_NV" },
{ GLenum::GL_EMBOSS_MAP_NV, "GL_EMBOSS_MAP_NV" },
{ GLenum::GL_EMISSION, "GL_EMISSION" },
{ GLenum::GL_EQUAL, "GL_EQUAL" },
{ GLenum::GL_EQUIV, "GL_EQUIV" },
{ GLenum::GL_EVAL_2D_NV, "GL_EVAL_2D_NV" },
{ GLenum::GL_EVAL_FRACTIONAL_TESSELLATION_NV, "GL_EVAL_FRACTIONAL_TESSELLATION_NV" },
{ GLenum::GL_EVAL_TRIANGULAR_2D_NV, "GL_EVAL_TRIANGULAR_2D_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB0_NV, "GL_EVAL_VERTEX_ATTRIB0_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB10_NV, "GL_EVAL_VERTEX_ATTRIB10_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB11_NV, "GL_EVAL_VERTEX_ATTRIB11_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB12_NV, "GL_EVAL_VERTEX_ATTRIB12_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB13_NV, "GL_EVAL_VERTEX_ATTRIB13_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB14_NV, "GL_EVAL_VERTEX_ATTRIB14_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB15_NV, "GL_EVAL_VERTEX_ATTRIB15_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB1_NV, "GL_EVAL_VERTEX_ATTRIB1_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB2_NV, "GL_EVAL_VERTEX_ATTRIB2_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB3_NV, "GL_EVAL_VERTEX_ATTRIB3_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB4_NV, "GL_EVAL_VERTEX_ATTRIB4_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB5_NV, "GL_EVAL_VERTEX_ATTRIB5_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB6_NV, "GL_EVAL_VERTEX_ATTRIB6_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB7_NV, "GL_EVAL_VERTEX_ATTRIB7_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB8_NV, "GL_EVAL_VERTEX_ATTRIB8_NV" },
{ GLenum::GL_EVAL_VERTEX_ATTRIB9_NV, "GL_EVAL_VERTEX_ATTRIB9_NV" },
{ GLenum::GL_EXCLUSION_KHR, "GL_EXCLUSION_KHR" },
{ GLenum::GL_EXCLUSION_NV, "GL_EXCLUSION_NV" },
{ GLenum::GL_EXCLUSIVE_EXT, "GL_EXCLUSIVE_EXT" },
{ GLenum::GL_EXP, "GL_EXP" },
{ GLenum::GL_EXP2, "GL_EXP2" },
{ GLenum::GL_EXPAND_NEGATE_NV, "GL_EXPAND_NEGATE_NV" },
{ GLenum::GL_EXPAND_NORMAL_NV, "GL_EXPAND_NORMAL_NV" },
{ GLenum::GL_EXTENSIONS, "GL_EXTENSIONS" },
{ GLenum::GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, "GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD" },
{ GLenum::GL_EYE_DISTANCE_TO_LINE_SGIS, "GL_EYE_DISTANCE_TO_LINE_SGIS" },
{ GLenum::GL_EYE_DISTANCE_TO_POINT_SGIS, "GL_EYE_DISTANCE_TO_POINT_SGIS" },
{ GLenum::GL_EYE_LINE_SGIS, "GL_EYE_LINE_SGIS" },
{ GLenum::GL_EYE_LINEAR, "GL_EYE_LINEAR" },
{ GLenum::GL_EYE_LINEAR_NV, "GL_EYE_LINEAR_NV" },
{ GLenum::GL_EYE_PLANE, "GL_EYE_PLANE" },
{ GLenum::GL_EYE_PLANE_ABSOLUTE_NV, "GL_EYE_PLANE_ABSOLUTE_NV" },
{ GLenum::GL_EYE_POINT_SGIS, "GL_EYE_POINT_SGIS" },
{ GLenum::GL_EYE_RADIAL_NV, "GL_EYE_RADIAL_NV" },
{ GLenum::GL_FACTOR_MAX_AMD, "GL_FACTOR_MAX_AMD" },
{ GLenum::GL_FACTOR_MIN_AMD, "GL_FACTOR_MIN_AMD" },
{ GLenum::GL_FAILURE_NV, "GL_FAILURE_NV" },
{ GLenum::GL_FASTEST, "GL_FASTEST" },
{ GLenum::GL_FEEDBACK, "GL_FEEDBACK" },
{ GLenum::GL_FEEDBACK_BUFFER_POINTER, "GL_FEEDBACK_BUFFER_POINTER" },
{ GLenum::GL_FEEDBACK_BUFFER_SIZE, "GL_FEEDBACK_BUFFER_SIZE" },
{ GLenum::GL_FEEDBACK_BUFFER_TYPE, "GL_FEEDBACK_BUFFER_TYPE" },
{ GLenum::GL_FENCE_APPLE, "GL_FENCE_APPLE" },
{ GLenum::GL_FENCE_CONDITION_NV, "GL_FENCE_CONDITION_NV" },
{ GLenum::GL_FENCE_STATUS_NV, "GL_FENCE_STATUS_NV" },
{ GLenum::GL_FIELD_LOWER_NV, "GL_FIELD_LOWER_NV" },
{ GLenum::GL_FIELD_UPPER_NV, "GL_FIELD_UPPER_NV" },
{ GLenum::GL_FIELDS_NV, "GL_FIELDS_NV" },
{ GLenum::GL_FILE_NAME_NV, "GL_FILE_NAME_NV" },
{ GLenum::GL_FILL, "GL_FILL" },
{ GLenum::GL_FILL_RECTANGLE_NV, "GL_FILL_RECTANGLE_NV" },
{ GLenum::GL_FILTER, "GL_FILTER" },
{ GLenum::GL_FILTER4_SGIS, "GL_FILTER4_SGIS" },
{ GLenum::GL_FIRST_TO_REST_NV, "GL_FIRST_TO_REST_NV" },
{ GLenum::GL_FIRST_VERTEX_CONVENTION, "GL_FIRST_VERTEX_CONVENTION" },
{ GLenum::GL_FIRST_VERTEX_CONVENTION_EXT, "GL_FIRST_VERTEX_CONVENTION_EXT" },
{ GLenum::GL_FIXED, "GL_FIXED" },
{ GLenum::GL_FIXED_OES, "GL_FIXED_OES" },
{ GLenum::GL_FIXED_ONLY, "GL_FIXED_ONLY" },
{ GLenum::GL_FIXED_ONLY_ARB, "GL_FIXED_ONLY_ARB" },
{ GLenum::GL_FLAT, "GL_FLAT" },
{ GLenum::GL_FLOAT, "GL_FLOAT" },
{ GLenum::GL_FLOAT16_MAT2_AMD, "GL_FLOAT16_MAT2_AMD" },
{ GLenum::GL_FLOAT16_MAT2x3_AMD, "GL_FLOAT16_MAT2x3_AMD" },
{ GLenum::GL_FLOAT16_MAT2x4_AMD, "GL_FLOAT16_MAT2x4_AMD" },
{ GLenum::GL_FLOAT16_MAT3_AMD, "GL_FLOAT16_MAT3_AMD" },
{ GLenum::GL_FLOAT16_MAT3x2_AMD, "GL_FLOAT16_MAT3x2_AMD" },
{ GLenum::GL_FLOAT16_MAT3x4_AMD, "GL_FLOAT16_MAT3x4_AMD" },
{ GLenum::GL_FLOAT16_MAT4_AMD, "GL_FLOAT16_MAT4_AMD" },
{ GLenum::GL_FLOAT16_MAT4x2_AMD, "GL_FLOAT16_MAT4x2_AMD" },
{ GLenum::GL_FLOAT16_MAT4x3_AMD, "GL_FLOAT16_MAT4x3_AMD" },
{ GLenum::GL_FLOAT16_NV, "GL_FLOAT16_NV" },
{ GLenum::GL_FLOAT16_VEC2_NV, "GL_FLOAT16_VEC2_NV" },
{ GLenum::GL_FLOAT16_VEC3_NV, "GL_FLOAT16_VEC3_NV" },
{ GLenum::GL_FLOAT16_VEC4_NV, "GL_FLOAT16_VEC4_NV" },
{ GLenum::GL_FLOAT_32_UNSIGNED_INT_24_8_REV, "GL_FLOAT_32_UNSIGNED_INT_24_8_REV" },
{ GLenum::GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV, "GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV" },
{ GLenum::GL_FLOAT_CLEAR_COLOR_VALUE_NV, "GL_FLOAT_CLEAR_COLOR_VALUE_NV" },
{ GLenum::GL_FLOAT_MAT2, "GL_FLOAT_MAT2" },
{ GLenum::GL_FLOAT_MAT2_ARB, "GL_FLOAT_MAT2_ARB" },
{ GLenum::GL_FLOAT_MAT2x3, "GL_FLOAT_MAT2x3" },
{ GLenum::GL_FLOAT_MAT2x4, "GL_FLOAT_MAT2x4" },
{ GLenum::GL_FLOAT_MAT3, "GL_FLOAT_MAT3" },
{ GLenum::GL_FLOAT_MAT3_ARB, "GL_FLOAT_MAT3_ARB" },
{ GLenum::GL_FLOAT_MAT3x2, "GL_FLOAT_MAT3x2" },
{ GLenum::GL_FLOAT_MAT3x4, "GL_FLOAT_MAT3x4" },
{ GLenum::GL_FLOAT_MAT4, "GL_FLOAT_MAT4" },
{ GLenum::GL_FLOAT_MAT4_ARB, "GL_FLOAT_MAT4_ARB" },
{ GLenum::GL_FLOAT_MAT4x2, "GL_FLOAT_MAT4x2" },
{ GLenum::GL_FLOAT_MAT4x3, "GL_FLOAT_MAT4x3" },
{ GLenum::GL_FLOAT_R16_NV, "GL_FLOAT_R16_NV" },
{ GLenum::GL_FLOAT_R32_NV, "GL_FLOAT_R32_NV" },
{ GLenum::GL_FLOAT_R_NV, "GL_FLOAT_R_NV" },
{ GLenum::GL_FLOAT_RG16_NV, "GL_FLOAT_RG16_NV" },
{ GLenum::GL_FLOAT_RG32_NV, "GL_FLOAT_RG32_NV" },
{ GLenum::GL_FLOAT_RG_NV, "GL_FLOAT_RG_NV" },
{ GLenum::GL_FLOAT_RGB16_NV, "GL_FLOAT_RGB16_NV" },
{ GLenum::GL_FLOAT_RGB32_NV, "GL_FLOAT_RGB32_NV" },
{ GLenum::GL_FLOAT_RGB_NV, "GL_FLOAT_RGB_NV" },
{ GLenum::GL_FLOAT_RGBA16_NV, "GL_FLOAT_RGBA16_NV" },
{ GLenum::GL_FLOAT_RGBA32_NV, "GL_FLOAT_RGBA32_NV" },
{ GLenum::GL_FLOAT_RGBA_MODE_NV, "GL_FLOAT_RGBA_MODE_NV" },
{ GLenum::GL_FLOAT_RGBA_NV, "GL_FLOAT_RGBA_NV" },
{ GLenum::GL_FLOAT_VEC2, "GL_FLOAT_VEC2" },
{ GLenum::GL_FLOAT_VEC2_ARB, "GL_FLOAT_VEC2_ARB" },
{ GLenum::GL_FLOAT_VEC3, "GL_FLOAT_VEC3" },
{ GLenum::GL_FLOAT_VEC3_ARB, "GL_FLOAT_VEC3_ARB" },
{ GLenum::GL_FLOAT_VEC4, "GL_FLOAT_VEC4" },
{ GLenum::GL_FLOAT_VEC4_ARB, "GL_FLOAT_VEC4_ARB" },
{ GLenum::GL_FOG, "GL_FOG" },
{ GLenum::GL_FOG_COLOR, "GL_FOG_COLOR" },
{ GLenum::GL_FOG_COORD, "GL_FOG_COORD" },
{ GLenum::GL_FOG_COORD_ARRAY, "GL_FOG_COORD_ARRAY" },
{ GLenum::GL_FOG_COORD_ARRAY_ADDRESS_NV, "GL_FOG_COORD_ARRAY_ADDRESS_NV" },
{ GLenum::GL_FOG_COORD_ARRAY_BUFFER_BINDING, "GL_FOG_COORD_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_FOG_COORD_ARRAY_LENGTH_NV, "GL_FOG_COORD_ARRAY_LENGTH_NV" },
{ GLenum::GL_FOG_COORD_ARRAY_POINTER, "GL_FOG_COORD_ARRAY_POINTER" },
{ GLenum::GL_FOG_COORD_ARRAY_STRIDE, "GL_FOG_COORD_ARRAY_STRIDE" },
{ GLenum::GL_FOG_COORD_ARRAY_TYPE, "GL_FOG_COORD_ARRAY_TYPE" },
{ GLenum::GL_FOG_COORD_SRC, "GL_FOG_COORD_SRC" },
{ GLenum::GL_FOG_COORDINATE, "GL_FOG_COORDINATE" },
{ GLenum::GL_FOG_COORDINATE_ARRAY, "GL_FOG_COORDINATE_ARRAY" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING, "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_EXT, "GL_FOG_COORDINATE_ARRAY_EXT" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_LIST_IBM, "GL_FOG_COORDINATE_ARRAY_LIST_IBM" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM, "GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_POINTER, "GL_FOG_COORDINATE_ARRAY_POINTER" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_POINTER_EXT, "GL_FOG_COORDINATE_ARRAY_POINTER_EXT" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_STRIDE, "GL_FOG_COORDINATE_ARRAY_STRIDE" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, "GL_FOG_COORDINATE_ARRAY_STRIDE_EXT" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_TYPE, "GL_FOG_COORDINATE_ARRAY_TYPE" },
{ GLenum::GL_FOG_COORDINATE_ARRAY_TYPE_EXT, "GL_FOG_COORDINATE_ARRAY_TYPE_EXT" },
{ GLenum::GL_FOG_COORDINATE_EXT, "GL_FOG_COORDINATE_EXT" },
{ GLenum::GL_FOG_COORDINATE_SOURCE, "GL_FOG_COORDINATE_SOURCE" },
{ GLenum::GL_FOG_COORDINATE_SOURCE_EXT, "GL_FOG_COORDINATE_SOURCE_EXT" },
{ GLenum::GL_FOG_DENSITY, "GL_FOG_DENSITY" },
{ GLenum::GL_FOG_DISTANCE_MODE_NV, "GL_FOG_DISTANCE_MODE_NV" },
{ GLenum::GL_FOG_END, "GL_FOG_END" },
{ GLenum::GL_FOG_FUNC_POINTS_SGIS, "GL_FOG_FUNC_POINTS_SGIS" },
{ GLenum::GL_FOG_FUNC_SGIS, "GL_FOG_FUNC_SGIS" },
{ GLenum::GL_FOG_HINT, "GL_FOG_HINT" },
{ GLenum::GL_FOG_INDEX, "GL_FOG_INDEX" },
{ GLenum::GL_FOG_MODE, "GL_FOG_MODE" },
{ GLenum::GL_FOG_OFFSET_SGIX, "GL_FOG_OFFSET_SGIX" },
{ GLenum::GL_FOG_OFFSET_VALUE_SGIX, "GL_FOG_OFFSET_VALUE_SGIX" },
{ GLenum::GL_FOG_SPECULAR_TEXTURE_WIN, "GL_FOG_SPECULAR_TEXTURE_WIN" },
{ GLenum::GL_FOG_START, "GL_FOG_START" },
{ GLenum::GL_FONT_GLYPHS_AVAILABLE_NV, "GL_FONT_GLYPHS_AVAILABLE_NV" },
{ GLenum::GL_FONT_TARGET_UNAVAILABLE_NV, "GL_FONT_TARGET_UNAVAILABLE_NV" },
{ GLenum::GL_FONT_UNAVAILABLE_NV, "GL_FONT_UNAVAILABLE_NV" },
{ GLenum::GL_FONT_UNINTELLIGIBLE_NV, "GL_FONT_UNINTELLIGIBLE_NV" },
{ GLenum::GL_FORCE_BLUE_TO_ONE_NV, "GL_FORCE_BLUE_TO_ONE_NV" },
{ GLenum::GL_FORMAT_SUBSAMPLE_244_244_OML, "GL_FORMAT_SUBSAMPLE_244_244_OML" },
{ GLenum::GL_FORMAT_SUBSAMPLE_24_24_OML, "GL_FORMAT_SUBSAMPLE_24_24_OML" },
{ GLenum::GL_FRACTIONAL_EVEN, "GL_FRACTIONAL_EVEN" },
{ GLenum::GL_FRACTIONAL_ODD, "GL_FRACTIONAL_ODD" },
{ GLenum::GL_FRAGMENT_COLOR_EXT, "GL_FRAGMENT_COLOR_EXT" },
{ GLenum::GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX, "GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX" },
{ GLenum::GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX, "GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX" },
{ GLenum::GL_FRAGMENT_COLOR_MATERIAL_SGIX, "GL_FRAGMENT_COLOR_MATERIAL_SGIX" },
{ GLenum::GL_FRAGMENT_COVERAGE_COLOR_NV, "GL_FRAGMENT_COVERAGE_COLOR_NV" },
{ GLenum::GL_FRAGMENT_COVERAGE_TO_COLOR_NV, "GL_FRAGMENT_COVERAGE_TO_COLOR_NV" },
{ GLenum::GL_FRAGMENT_DEPTH, "GL_FRAGMENT_DEPTH" },
{ GLenum::GL_FRAGMENT_DEPTH_EXT, "GL_FRAGMENT_DEPTH_EXT" },
{ GLenum::GL_FRAGMENT_INPUT_NV, "GL_FRAGMENT_INPUT_NV" },
{ GLenum::GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS" },
{ GLenum::GL_FRAGMENT_LIGHT0_SGIX, "GL_FRAGMENT_LIGHT0_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT1_SGIX, "GL_FRAGMENT_LIGHT1_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT2_SGIX, "GL_FRAGMENT_LIGHT2_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT3_SGIX, "GL_FRAGMENT_LIGHT3_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT4_SGIX, "GL_FRAGMENT_LIGHT4_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT5_SGIX, "GL_FRAGMENT_LIGHT5_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT6_SGIX, "GL_FRAGMENT_LIGHT6_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT7_SGIX, "GL_FRAGMENT_LIGHT7_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX, "GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, "GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX, "GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX, "GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX" },
{ GLenum::GL_FRAGMENT_LIGHTING_SGIX, "GL_FRAGMENT_LIGHTING_SGIX" },
{ GLenum::GL_FRAGMENT_MATERIAL_EXT, "GL_FRAGMENT_MATERIAL_EXT" },
{ GLenum::GL_FRAGMENT_NORMAL_EXT, "GL_FRAGMENT_NORMAL_EXT" },
{ GLenum::GL_FRAGMENT_PROGRAM_ARB, "GL_FRAGMENT_PROGRAM_ARB" },
{ GLenum::GL_FRAGMENT_PROGRAM_BINDING_NV, "GL_FRAGMENT_PROGRAM_BINDING_NV" },
{ GLenum::GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV, "GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV" },
{ GLenum::GL_FRAGMENT_PROGRAM_NV, "GL_FRAGMENT_PROGRAM_NV" },
{ GLenum::GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV, "GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_FRAGMENT_SHADER, "GL_FRAGMENT_SHADER" },
{ GLenum::GL_FRAGMENT_SHADER_ARB, "GL_FRAGMENT_SHADER_ARB" },
{ GLenum::GL_FRAGMENT_SHADER_ATI, "GL_FRAGMENT_SHADER_ATI" },
{ GLenum::GL_FRAGMENT_SHADER_DERIVATIVE_HINT, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT" },
{ GLenum::GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB" },
{ GLenum::GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT, "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT" },
{ GLenum::GL_FRAGMENT_SHADER_INVOCATIONS, "GL_FRAGMENT_SHADER_INVOCATIONS" },
{ GLenum::GL_FRAGMENT_SHADER_INVOCATIONS_ARB, "GL_FRAGMENT_SHADER_INVOCATIONS_ARB" },
{ GLenum::GL_FRAGMENT_SUBROUTINE, "GL_FRAGMENT_SUBROUTINE" },
{ GLenum::GL_FRAGMENT_SUBROUTINE_UNIFORM, "GL_FRAGMENT_SUBROUTINE_UNIFORM" },
{ GLenum::GL_FRAGMENT_TEXTURE, "GL_FRAGMENT_TEXTURE" },
{ GLenum::GL_FRAME_NV, "GL_FRAME_NV" },
{ GLenum::GL_FRAMEBUFFER, "GL_FRAMEBUFFER" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_LAYERED, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT" },
{ GLenum::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR" },
{ GLenum::GL_FRAMEBUFFER_BINDING, "GL_FRAMEBUFFER_BINDING" },
{ GLenum::GL_FRAMEBUFFER_BINDING_EXT, "GL_FRAMEBUFFER_BINDING_EXT" },
{ GLenum::GL_FRAMEBUFFER_BLEND, "GL_FRAMEBUFFER_BLEND" },
{ GLenum::GL_FRAMEBUFFER_COMPLETE, "GL_FRAMEBUFFER_COMPLETE" },
{ GLenum::GL_FRAMEBUFFER_COMPLETE_EXT, "GL_FRAMEBUFFER_COMPLETE_EXT" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT, "GL_FRAMEBUFFER_DEFAULT" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS, "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT_HEIGHT, "GL_FRAMEBUFFER_DEFAULT_HEIGHT" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT_LAYERS, "GL_FRAMEBUFFER_DEFAULT_LAYERS" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT_SAMPLES, "GL_FRAMEBUFFER_DEFAULT_SAMPLES" },
{ GLenum::GL_FRAMEBUFFER_DEFAULT_WIDTH, "GL_FRAMEBUFFER_DEFAULT_WIDTH" },
{ GLenum::GL_FRAMEBUFFER_EXT, "GL_FRAMEBUFFER_EXT" },
{ GLenum::GL_FRAMEBUFFER_FLIP_Y_MESA, "GL_FRAMEBUFFER_FLIP_Y_MESA" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT, "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" },
{ GLenum::GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR, "GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR" },
{ GLenum::GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB, "GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB" },
{ GLenum::GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV, "GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV" },
{ GLenum::GL_FRAMEBUFFER_RENDERABLE, "GL_FRAMEBUFFER_RENDERABLE" },
{ GLenum::GL_FRAMEBUFFER_RENDERABLE_LAYERED, "GL_FRAMEBUFFER_RENDERABLE_LAYERED" },
{ GLenum::GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB, "GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB" },
{ GLenum::GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV, "GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV" },
{ GLenum::GL_FRAMEBUFFER_SRGB, "GL_FRAMEBUFFER_SRGB" },
{ GLenum::GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, "GL_FRAMEBUFFER_SRGB_CAPABLE_EXT" },
{ GLenum::GL_FRAMEBUFFER_SRGB_EXT, "GL_FRAMEBUFFER_SRGB_EXT" },
{ GLenum::GL_FRAMEBUFFER_UNDEFINED, "GL_FRAMEBUFFER_UNDEFINED" },
{ GLenum::GL_FRAMEBUFFER_UNSUPPORTED, "GL_FRAMEBUFFER_UNSUPPORTED" },
{ GLenum::GL_FRAMEBUFFER_UNSUPPORTED_EXT, "GL_FRAMEBUFFER_UNSUPPORTED_EXT" },
{ GLenum::GL_FRAMEZOOM_FACTOR_SGIX, "GL_FRAMEZOOM_FACTOR_SGIX" },
{ GLenum::GL_FRAMEZOOM_SGIX, "GL_FRAMEZOOM_SGIX" },
{ GLenum::GL_FRONT, "GL_FRONT" },
{ GLenum::GL_FRONT_AND_BACK, "GL_FRONT_AND_BACK" },
{ GLenum::GL_FRONT_FACE, "GL_FRONT_FACE" },
{ GLenum::GL_FRONT_FACE_COMMAND_NV, "GL_FRONT_FACE_COMMAND_NV" },
{ GLenum::GL_FRONT_LEFT, "GL_FRONT_LEFT" },
{ GLenum::GL_FRONT_RIGHT, "GL_FRONT_RIGHT" },
{ GLenum::GL_FULL_RANGE_EXT, "GL_FULL_RANGE_EXT" },
{ GLenum::GL_FULL_STIPPLE_HINT_PGI, "GL_FULL_STIPPLE_HINT_PGI" },
{ GLenum::GL_FULL_SUPPORT, "GL_FULL_SUPPORT" },
{ GLenum::GL_FUNC_ADD, "GL_FUNC_ADD" },
{ GLenum::GL_FUNC_ADD_EXT, "GL_FUNC_ADD_EXT" },
{ GLenum::GL_FUNC_REVERSE_SUBTRACT, "GL_FUNC_REVERSE_SUBTRACT" },
{ GLenum::GL_FUNC_REVERSE_SUBTRACT_EXT, "GL_FUNC_REVERSE_SUBTRACT_EXT" },
{ GLenum::GL_FUNC_SUBTRACT, "GL_FUNC_SUBTRACT" },
{ GLenum::GL_FUNC_SUBTRACT_EXT, "GL_FUNC_SUBTRACT_EXT" },
{ GLenum::GL_GENERATE_MIPMAP, "GL_GENERATE_MIPMAP" },
{ GLenum::GL_GENERATE_MIPMAP_HINT, "GL_GENERATE_MIPMAP_HINT" },
{ GLenum::GL_GENERATE_MIPMAP_HINT_SGIS, "GL_GENERATE_MIPMAP_HINT_SGIS" },
{ GLenum::GL_GENERATE_MIPMAP_SGIS, "GL_GENERATE_MIPMAP_SGIS" },
{ GLenum::GL_GENERIC_ATTRIB_NV, "GL_GENERIC_ATTRIB_NV" },
{ GLenum::GL_GEOMETRY_DEFORMATION_SGIX, "GL_GEOMETRY_DEFORMATION_SGIX" },
{ GLenum::GL_GEOMETRY_INPUT_TYPE, "GL_GEOMETRY_INPUT_TYPE" },
{ GLenum::GL_GEOMETRY_INPUT_TYPE_ARB, "GL_GEOMETRY_INPUT_TYPE_ARB" },
{ GLenum::GL_GEOMETRY_INPUT_TYPE_EXT, "GL_GEOMETRY_INPUT_TYPE_EXT" },
{ GLenum::GL_GEOMETRY_OUTPUT_TYPE, "GL_GEOMETRY_OUTPUT_TYPE" },
{ GLenum::GL_GEOMETRY_OUTPUT_TYPE_ARB, "GL_GEOMETRY_OUTPUT_TYPE_ARB" },
{ GLenum::GL_GEOMETRY_OUTPUT_TYPE_EXT, "GL_GEOMETRY_OUTPUT_TYPE_EXT" },
{ GLenum::GL_GEOMETRY_PROGRAM_NV, "GL_GEOMETRY_PROGRAM_NV" },
{ GLenum::GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, "GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_GEOMETRY_SHADER, "GL_GEOMETRY_SHADER" },
{ GLenum::GL_GEOMETRY_SHADER_ARB, "GL_GEOMETRY_SHADER_ARB" },
{ GLenum::GL_GEOMETRY_SHADER_EXT, "GL_GEOMETRY_SHADER_EXT" },
{ GLenum::GL_GEOMETRY_SHADER_INVOCATIONS, "GL_GEOMETRY_SHADER_INVOCATIONS" },
{ GLenum::GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED, "GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED" },
{ GLenum::GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB, "GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB" },
{ GLenum::GL_GEOMETRY_SUBROUTINE, "GL_GEOMETRY_SUBROUTINE" },
{ GLenum::GL_GEOMETRY_SUBROUTINE_UNIFORM, "GL_GEOMETRY_SUBROUTINE_UNIFORM" },
{ GLenum::GL_GEOMETRY_TEXTURE, "GL_GEOMETRY_TEXTURE" },
{ GLenum::GL_GEOMETRY_VERTICES_OUT, "GL_GEOMETRY_VERTICES_OUT" },
{ GLenum::GL_GEOMETRY_VERTICES_OUT_ARB, "GL_GEOMETRY_VERTICES_OUT_ARB" },
{ GLenum::GL_GEOMETRY_VERTICES_OUT_EXT, "GL_GEOMETRY_VERTICES_OUT_EXT" },
{ GLenum::GL_GEQUAL, "GL_GEQUAL" },
{ GLenum::GL_GET_TEXTURE_IMAGE_FORMAT, "GL_GET_TEXTURE_IMAGE_FORMAT" },
{ GLenum::GL_GET_TEXTURE_IMAGE_TYPE, "GL_GET_TEXTURE_IMAGE_TYPE" },
{ GLenum::GL_GLOBAL_ALPHA_FACTOR_SUN, "GL_GLOBAL_ALPHA_FACTOR_SUN" },
{ GLenum::GL_GLOBAL_ALPHA_SUN, "GL_GLOBAL_ALPHA_SUN" },
{ GLenum::GL_GPU_ADDRESS_NV, "GL_GPU_ADDRESS_NV" },
{ GLenum::GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, "GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX" },
{ GLenum::GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX" },
{ GLenum::GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX, "GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX" },
{ GLenum::GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX, "GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX" },
{ GLenum::GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX" },
{ GLenum::GL_GREATER, "GL_GREATER" },
{ GLenum::GL_GREEN, "GL_GREEN" },
{ GLenum::GL_GREEN_BIAS, "GL_GREEN_BIAS" },
{ GLenum::GL_GREEN_BITS, "GL_GREEN_BITS" },
{ GLenum::GL_GREEN_INTEGER, "GL_GREEN_INTEGER" },
{ GLenum::GL_GREEN_INTEGER_EXT, "GL_GREEN_INTEGER_EXT" },
{ GLenum::GL_GREEN_MAX_CLAMP_INGR, "GL_GREEN_MAX_CLAMP_INGR" },
{ GLenum::GL_GREEN_MIN_CLAMP_INGR, "GL_GREEN_MIN_CLAMP_INGR" },
{ GLenum::GL_GREEN_NV, "GL_GREEN_NV" },
{ GLenum::GL_GREEN_SCALE, "GL_GREEN_SCALE" },
{ GLenum::GL_GUILTY_CONTEXT_RESET, "GL_GUILTY_CONTEXT_RESET" },
{ GLenum::GL_GUILTY_CONTEXT_RESET_ARB, "GL_GUILTY_CONTEXT_RESET_ARB" },
{ GLenum::GL_GUILTY_CONTEXT_RESET_KHR, "GL_GUILTY_CONTEXT_RESET_KHR" },
{ GLenum::GL_HALF_APPLE, "GL_HALF_APPLE" },
{ GLenum::GL_HALF_BIAS_NEGATE_NV, "GL_HALF_BIAS_NEGATE_NV" },
{ GLenum::GL_HALF_BIAS_NORMAL_NV, "GL_HALF_BIAS_NORMAL_NV" },
{ GLenum::GL_HALF_FLOAT, "GL_HALF_FLOAT" },
{ GLenum::GL_HALF_FLOAT_ARB, "GL_HALF_FLOAT_ARB" },
{ GLenum::GL_HALF_FLOAT_NV, "GL_HALF_FLOAT_NV" },
{ GLenum::GL_HANDLE_TYPE_D3D11_IMAGE_EXT, "GL_HANDLE_TYPE_D3D11_IMAGE_EXT" },
{ GLenum::GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT, "GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT" },
{ GLenum::GL_HANDLE_TYPE_D3D12_FENCE_EXT, "GL_HANDLE_TYPE_D3D12_FENCE_EXT" },
{ GLenum::GL_HANDLE_TYPE_D3D12_RESOURCE_EXT, "GL_HANDLE_TYPE_D3D12_RESOURCE_EXT" },
{ GLenum::GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT, "GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT" },
{ GLenum::GL_HANDLE_TYPE_OPAQUE_FD_EXT, "GL_HANDLE_TYPE_OPAQUE_FD_EXT" },
{ GLenum::GL_HANDLE_TYPE_OPAQUE_WIN32_EXT, "GL_HANDLE_TYPE_OPAQUE_WIN32_EXT" },
{ GLenum::GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT, "GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT" },
{ GLenum::GL_HARDLIGHT_KHR, "GL_HARDLIGHT_KHR" },
{ GLenum::GL_HARDLIGHT_NV, "GL_HARDLIGHT_NV" },
{ GLenum::GL_HARDMIX_NV, "GL_HARDMIX_NV" },
{ GLenum::GL_HI_BIAS_NV, "GL_HI_BIAS_NV" },
{ GLenum::GL_HI_SCALE_NV, "GL_HI_SCALE_NV" },
{ GLenum::GL_HIGH_FLOAT, "GL_HIGH_FLOAT" },
{ GLenum::GL_HIGH_INT, "GL_HIGH_INT" },
{ GLenum::GL_HILO16_NV, "GL_HILO16_NV" },
{ GLenum::GL_HILO8_NV, "GL_HILO8_NV" },
{ GLenum::GL_HILO_NV, "GL_HILO_NV" },
{ GLenum::GL_HISTOGRAM, "GL_HISTOGRAM" },
{ GLenum::GL_HISTOGRAM_ALPHA_SIZE, "GL_HISTOGRAM_ALPHA_SIZE" },
{ GLenum::GL_HISTOGRAM_ALPHA_SIZE_EXT, "GL_HISTOGRAM_ALPHA_SIZE_EXT" },
{ GLenum::GL_HISTOGRAM_BLUE_SIZE, "GL_HISTOGRAM_BLUE_SIZE" },
{ GLenum::GL_HISTOGRAM_BLUE_SIZE_EXT, "GL_HISTOGRAM_BLUE_SIZE_EXT" },
{ GLenum::GL_HISTOGRAM_EXT, "GL_HISTOGRAM_EXT" },
{ GLenum::GL_HISTOGRAM_FORMAT, "GL_HISTOGRAM_FORMAT" },
{ GLenum::GL_HISTOGRAM_FORMAT_EXT, "GL_HISTOGRAM_FORMAT_EXT" },
{ GLenum::GL_HISTOGRAM_GREEN_SIZE, "GL_HISTOGRAM_GREEN_SIZE" },
{ GLenum::GL_HISTOGRAM_GREEN_SIZE_EXT, "GL_HISTOGRAM_GREEN_SIZE_EXT" },
{ GLenum::GL_HISTOGRAM_LUMINANCE_SIZE, "GL_HISTOGRAM_LUMINANCE_SIZE" },
{ GLenum::GL_HISTOGRAM_LUMINANCE_SIZE_EXT, "GL_HISTOGRAM_LUMINANCE_SIZE_EXT" },
{ GLenum::GL_HISTOGRAM_RED_SIZE, "GL_HISTOGRAM_RED_SIZE" },
{ GLenum::GL_HISTOGRAM_RED_SIZE_EXT, "GL_HISTOGRAM_RED_SIZE_EXT" },
{ GLenum::GL_HISTOGRAM_SINK, "GL_HISTOGRAM_SINK" },
{ GLenum::GL_HISTOGRAM_SINK_EXT, "GL_HISTOGRAM_SINK_EXT" },
{ GLenum::GL_HISTOGRAM_WIDTH, "GL_HISTOGRAM_WIDTH" },
{ GLenum::GL_HISTOGRAM_WIDTH_EXT, "GL_HISTOGRAM_WIDTH_EXT" },
{ GLenum::GL_HORIZONTAL_LINE_TO_NV, "GL_HORIZONTAL_LINE_TO_NV" },
{ GLenum::GL_HSL_COLOR_KHR, "GL_HSL_COLOR_KHR" },
{ GLenum::GL_HSL_COLOR_NV, "GL_HSL_COLOR_NV" },
{ GLenum::GL_HSL_HUE_KHR, "GL_HSL_HUE_KHR" },
{ GLenum::GL_HSL_HUE_NV, "GL_HSL_HUE_NV" },
{ GLenum::GL_HSL_LUMINOSITY_KHR, "GL_HSL_LUMINOSITY_KHR" },
{ GLenum::GL_HSL_LUMINOSITY_NV, "GL_HSL_LUMINOSITY_NV" },
{ GLenum::GL_HSL_SATURATION_KHR, "GL_HSL_SATURATION_KHR" },
{ GLenum::GL_HSL_SATURATION_NV, "GL_HSL_SATURATION_NV" },
{ GLenum::GL_IDENTITY_NV, "GL_IDENTITY_NV" },
{ GLenum::GL_IGNORE_BORDER_HP, "GL_IGNORE_BORDER_HP" },
{ GLenum::GL_IMAGE_1D, "GL_IMAGE_1D" },
{ GLenum::GL_IMAGE_1D_ARRAY, "GL_IMAGE_1D_ARRAY" },
{ GLenum::GL_IMAGE_1D_ARRAY_EXT, "GL_IMAGE_1D_ARRAY_EXT" },
{ GLenum::GL_IMAGE_1D_EXT, "GL_IMAGE_1D_EXT" },
{ GLenum::GL_IMAGE_2D, "GL_IMAGE_2D" },
{ GLenum::GL_IMAGE_2D_ARRAY, "GL_IMAGE_2D_ARRAY" },
{ GLenum::GL_IMAGE_2D_ARRAY_EXT, "GL_IMAGE_2D_ARRAY_EXT" },
{ GLenum::GL_IMAGE_2D_EXT, "GL_IMAGE_2D_EXT" },
{ GLenum::GL_IMAGE_2D_MULTISAMPLE, "GL_IMAGE_2D_MULTISAMPLE" },
{ GLenum::GL_IMAGE_2D_MULTISAMPLE_ARRAY, "GL_IMAGE_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT, "GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT" },
{ GLenum::GL_IMAGE_2D_MULTISAMPLE_EXT, "GL_IMAGE_2D_MULTISAMPLE_EXT" },
{ GLenum::GL_IMAGE_2D_RECT, "GL_IMAGE_2D_RECT" },
{ GLenum::GL_IMAGE_2D_RECT_EXT, "GL_IMAGE_2D_RECT_EXT" },
{ GLenum::GL_IMAGE_3D, "GL_IMAGE_3D" },
{ GLenum::GL_IMAGE_3D_EXT, "GL_IMAGE_3D_EXT" },
{ GLenum::GL_IMAGE_BINDING_ACCESS, "GL_IMAGE_BINDING_ACCESS" },
{ GLenum::GL_IMAGE_BINDING_ACCESS_EXT, "GL_IMAGE_BINDING_ACCESS_EXT" },
{ GLenum::GL_IMAGE_BINDING_FORMAT, "GL_IMAGE_BINDING_FORMAT" },
{ GLenum::GL_IMAGE_BINDING_FORMAT_EXT, "GL_IMAGE_BINDING_FORMAT_EXT" },
{ GLenum::GL_IMAGE_BINDING_LAYER, "GL_IMAGE_BINDING_LAYER" },
{ GLenum::GL_IMAGE_BINDING_LAYER_EXT, "GL_IMAGE_BINDING_LAYER_EXT" },
{ GLenum::GL_IMAGE_BINDING_LAYERED, "GL_IMAGE_BINDING_LAYERED" },
{ GLenum::GL_IMAGE_BINDING_LAYERED_EXT, "GL_IMAGE_BINDING_LAYERED_EXT" },
{ GLenum::GL_IMAGE_BINDING_LEVEL, "GL_IMAGE_BINDING_LEVEL" },
{ GLenum::GL_IMAGE_BINDING_LEVEL_EXT, "GL_IMAGE_BINDING_LEVEL_EXT" },
{ GLenum::GL_IMAGE_BINDING_NAME, "GL_IMAGE_BINDING_NAME" },
{ GLenum::GL_IMAGE_BINDING_NAME_EXT, "GL_IMAGE_BINDING_NAME_EXT" },
{ GLenum::GL_IMAGE_BUFFER, "GL_IMAGE_BUFFER" },
{ GLenum::GL_IMAGE_BUFFER_EXT, "GL_IMAGE_BUFFER_EXT" },
{ GLenum::GL_IMAGE_CLASS_10_10_10_2, "GL_IMAGE_CLASS_10_10_10_2" },
{ GLenum::GL_IMAGE_CLASS_11_11_10, "GL_IMAGE_CLASS_11_11_10" },
{ GLenum::GL_IMAGE_CLASS_1_X_16, "GL_IMAGE_CLASS_1_X_16" },
{ GLenum::GL_IMAGE_CLASS_1_X_32, "GL_IMAGE_CLASS_1_X_32" },
{ GLenum::GL_IMAGE_CLASS_1_X_8, "GL_IMAGE_CLASS_1_X_8" },
{ GLenum::GL_IMAGE_CLASS_2_X_16, "GL_IMAGE_CLASS_2_X_16" },
{ GLenum::GL_IMAGE_CLASS_2_X_32, "GL_IMAGE_CLASS_2_X_32" },
{ GLenum::GL_IMAGE_CLASS_2_X_8, "GL_IMAGE_CLASS_2_X_8" },
{ GLenum::GL_IMAGE_CLASS_4_X_16, "GL_IMAGE_CLASS_4_X_16" },
{ GLenum::GL_IMAGE_CLASS_4_X_32, "GL_IMAGE_CLASS_4_X_32" },
{ GLenum::GL_IMAGE_CLASS_4_X_8, "GL_IMAGE_CLASS_4_X_8" },
{ GLenum::GL_IMAGE_COMPATIBILITY_CLASS, "GL_IMAGE_COMPATIBILITY_CLASS" },
{ GLenum::GL_IMAGE_CUBE, "GL_IMAGE_CUBE" },
{ GLenum::GL_IMAGE_CUBE_EXT, "GL_IMAGE_CUBE_EXT" },
{ GLenum::GL_IMAGE_CUBE_MAP_ARRAY, "GL_IMAGE_CUBE_MAP_ARRAY" },
{ GLenum::GL_IMAGE_CUBE_MAP_ARRAY_EXT, "GL_IMAGE_CUBE_MAP_ARRAY_EXT" },
{ GLenum::GL_IMAGE_CUBIC_WEIGHT_HP, "GL_IMAGE_CUBIC_WEIGHT_HP" },
{ GLenum::GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS" },
{ GLenum::GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE" },
{ GLenum::GL_IMAGE_FORMAT_COMPATIBILITY_TYPE, "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE" },
{ GLenum::GL_IMAGE_MAG_FILTER_HP, "GL_IMAGE_MAG_FILTER_HP" },
{ GLenum::GL_IMAGE_MIN_FILTER_HP, "GL_IMAGE_MIN_FILTER_HP" },
{ GLenum::GL_IMAGE_PIXEL_FORMAT, "GL_IMAGE_PIXEL_FORMAT" },
{ GLenum::GL_IMAGE_PIXEL_TYPE, "GL_IMAGE_PIXEL_TYPE" },
{ GLenum::GL_IMAGE_ROTATE_ANGLE_HP, "GL_IMAGE_ROTATE_ANGLE_HP" },
{ GLenum::GL_IMAGE_ROTATE_ORIGIN_X_HP, "GL_IMAGE_ROTATE_ORIGIN_X_HP" },
{ GLenum::GL_IMAGE_ROTATE_ORIGIN_Y_HP, "GL_IMAGE_ROTATE_ORIGIN_Y_HP" },
{ GLenum::GL_IMAGE_SCALE_X_HP, "GL_IMAGE_SCALE_X_HP" },
{ GLenum::GL_IMAGE_SCALE_Y_HP, "GL_IMAGE_SCALE_Y_HP" },
{ GLenum::GL_IMAGE_TEXEL_SIZE, "GL_IMAGE_TEXEL_SIZE" },
{ GLenum::GL_IMAGE_TRANSFORM_2D_HP, "GL_IMAGE_TRANSFORM_2D_HP" },
{ GLenum::GL_IMAGE_TRANSLATE_X_HP, "GL_IMAGE_TRANSLATE_X_HP" },
{ GLenum::GL_IMAGE_TRANSLATE_Y_HP, "GL_IMAGE_TRANSLATE_Y_HP" },
{ GLenum::GL_IMPLEMENTATION_COLOR_READ_FORMAT, "GL_IMPLEMENTATION_COLOR_READ_FORMAT" },
{ GLenum::GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES" },
{ GLenum::GL_IMPLEMENTATION_COLOR_READ_TYPE, "GL_IMPLEMENTATION_COLOR_READ_TYPE" },
{ GLenum::GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES" },
{ GLenum::GL_INCLUSIVE_EXT, "GL_INCLUSIVE_EXT" },
{ GLenum::GL_INCR, "GL_INCR" },
{ GLenum::GL_INCR_WRAP, "GL_INCR_WRAP" },
{ GLenum::GL_INCR_WRAP_EXT, "GL_INCR_WRAP_EXT" },
{ GLenum::GL_INDEX, "GL_INDEX" },
{ GLenum::GL_INDEX_ARRAY, "GL_INDEX_ARRAY" },
{ GLenum::GL_INDEX_ARRAY_ADDRESS_NV, "GL_INDEX_ARRAY_ADDRESS_NV" },
{ GLenum::GL_INDEX_ARRAY_BUFFER_BINDING, "GL_INDEX_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_INDEX_ARRAY_BUFFER_BINDING_ARB, "GL_INDEX_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_INDEX_ARRAY_COUNT_EXT, "GL_INDEX_ARRAY_COUNT_EXT" },
{ GLenum::GL_INDEX_ARRAY_EXT, "GL_INDEX_ARRAY_EXT" },
{ GLenum::GL_INDEX_ARRAY_LENGTH_NV, "GL_INDEX_ARRAY_LENGTH_NV" },
{ GLenum::GL_INDEX_ARRAY_LIST_IBM, "GL_INDEX_ARRAY_LIST_IBM" },
{ GLenum::GL_INDEX_ARRAY_LIST_STRIDE_IBM, "GL_INDEX_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_INDEX_ARRAY_POINTER, "GL_INDEX_ARRAY_POINTER" },
{ GLenum::GL_INDEX_ARRAY_POINTER_EXT, "GL_INDEX_ARRAY_POINTER_EXT" },
{ GLenum::GL_INDEX_ARRAY_STRIDE, "GL_INDEX_ARRAY_STRIDE" },
{ GLenum::GL_INDEX_ARRAY_STRIDE_EXT, "GL_INDEX_ARRAY_STRIDE_EXT" },
{ GLenum::GL_INDEX_ARRAY_TYPE, "GL_INDEX_ARRAY_TYPE" },
{ GLenum::GL_INDEX_ARRAY_TYPE_EXT, "GL_INDEX_ARRAY_TYPE_EXT" },
{ GLenum::GL_INDEX_BITS, "GL_INDEX_BITS" },
{ GLenum::GL_INDEX_CLEAR_VALUE, "GL_INDEX_CLEAR_VALUE" },
{ GLenum::GL_INDEX_LOGIC_OP, "GL_INDEX_LOGIC_OP" },
{ GLenum::GL_INDEX_MATERIAL_EXT, "GL_INDEX_MATERIAL_EXT" },
{ GLenum::GL_INDEX_MATERIAL_FACE_EXT, "GL_INDEX_MATERIAL_FACE_EXT" },
{ GLenum::GL_INDEX_MATERIAL_PARAMETER_EXT, "GL_INDEX_MATERIAL_PARAMETER_EXT" },
{ GLenum::GL_INDEX_MODE, "GL_INDEX_MODE" },
{ GLenum::GL_INDEX_OFFSET, "GL_INDEX_OFFSET" },
{ GLenum::GL_INDEX_SHIFT, "GL_INDEX_SHIFT" },
{ GLenum::GL_INDEX_TEST_EXT, "GL_INDEX_TEST_EXT" },
{ GLenum::GL_INDEX_TEST_FUNC_EXT, "GL_INDEX_TEST_FUNC_EXT" },
{ GLenum::GL_INDEX_TEST_REF_EXT, "GL_INDEX_TEST_REF_EXT" },
{ GLenum::GL_INDEX_WRITEMASK, "GL_INDEX_WRITEMASK" },
{ GLenum::GL_INFO_LOG_LENGTH, "GL_INFO_LOG_LENGTH" },
{ GLenum::GL_INNOCENT_CONTEXT_RESET, "GL_INNOCENT_CONTEXT_RESET" },
{ GLenum::GL_INNOCENT_CONTEXT_RESET_ARB, "GL_INNOCENT_CONTEXT_RESET_ARB" },
{ GLenum::GL_INNOCENT_CONTEXT_RESET_KHR, "GL_INNOCENT_CONTEXT_RESET_KHR" },
{ GLenum::GL_INSTRUMENT_BUFFER_POINTER_SGIX, "GL_INSTRUMENT_BUFFER_POINTER_SGIX" },
{ GLenum::GL_INSTRUMENT_MEASUREMENTS_SGIX, "GL_INSTRUMENT_MEASUREMENTS_SGIX" },
{ GLenum::GL_INT, "GL_INT" },
{ GLenum::GL_INT16_NV, "GL_INT16_NV" },
{ GLenum::GL_INT16_VEC2_NV, "GL_INT16_VEC2_NV" },
{ GLenum::GL_INT16_VEC3_NV, "GL_INT16_VEC3_NV" },
{ GLenum::GL_INT16_VEC4_NV, "GL_INT16_VEC4_NV" },
{ GLenum::GL_INT64_ARB, "GL_INT64_ARB" },
{ GLenum::GL_INT64_NV, "GL_INT64_NV" },
{ GLenum::GL_INT64_VEC2_ARB, "GL_INT64_VEC2_ARB" },
{ GLenum::GL_INT64_VEC2_NV, "GL_INT64_VEC2_NV" },
{ GLenum::GL_INT64_VEC3_ARB, "GL_INT64_VEC3_ARB" },
{ GLenum::GL_INT64_VEC3_NV, "GL_INT64_VEC3_NV" },
{ GLenum::GL_INT64_VEC4_ARB, "GL_INT64_VEC4_ARB" },
{ GLenum::GL_INT64_VEC4_NV, "GL_INT64_VEC4_NV" },
{ GLenum::GL_INT8_NV, "GL_INT8_NV" },
{ GLenum::GL_INT8_VEC2_NV, "GL_INT8_VEC2_NV" },
{ GLenum::GL_INT8_VEC3_NV, "GL_INT8_VEC3_NV" },
{ GLenum::GL_INT8_VEC4_NV, "GL_INT8_VEC4_NV" },
{ GLenum::GL_INT_2_10_10_10_REV, "GL_INT_2_10_10_10_REV" },
{ GLenum::GL_INT_IMAGE_1D, "GL_INT_IMAGE_1D" },
{ GLenum::GL_INT_IMAGE_1D_ARRAY, "GL_INT_IMAGE_1D_ARRAY" },
{ GLenum::GL_INT_IMAGE_1D_ARRAY_EXT, "GL_INT_IMAGE_1D_ARRAY_EXT" },
{ GLenum::GL_INT_IMAGE_1D_EXT, "GL_INT_IMAGE_1D_EXT" },
{ GLenum::GL_INT_IMAGE_2D, "GL_INT_IMAGE_2D" },
{ GLenum::GL_INT_IMAGE_2D_ARRAY, "GL_INT_IMAGE_2D_ARRAY" },
{ GLenum::GL_INT_IMAGE_2D_ARRAY_EXT, "GL_INT_IMAGE_2D_ARRAY_EXT" },
{ GLenum::GL_INT_IMAGE_2D_EXT, "GL_INT_IMAGE_2D_EXT" },
{ GLenum::GL_INT_IMAGE_2D_MULTISAMPLE, "GL_INT_IMAGE_2D_MULTISAMPLE" },
{ GLenum::GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY, "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT, "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT" },
{ GLenum::GL_INT_IMAGE_2D_MULTISAMPLE_EXT, "GL_INT_IMAGE_2D_MULTISAMPLE_EXT" },
{ GLenum::GL_INT_IMAGE_2D_RECT, "GL_INT_IMAGE_2D_RECT" },
{ GLenum::GL_INT_IMAGE_2D_RECT_EXT, "GL_INT_IMAGE_2D_RECT_EXT" },
{ GLenum::GL_INT_IMAGE_3D, "GL_INT_IMAGE_3D" },
{ GLenum::GL_INT_IMAGE_3D_EXT, "GL_INT_IMAGE_3D_EXT" },
{ GLenum::GL_INT_IMAGE_BUFFER, "GL_INT_IMAGE_BUFFER" },
{ GLenum::GL_INT_IMAGE_BUFFER_EXT, "GL_INT_IMAGE_BUFFER_EXT" },
{ GLenum::GL_INT_IMAGE_CUBE, "GL_INT_IMAGE_CUBE" },
{ GLenum::GL_INT_IMAGE_CUBE_EXT, "GL_INT_IMAGE_CUBE_EXT" },
{ GLenum::GL_INT_IMAGE_CUBE_MAP_ARRAY, "GL_INT_IMAGE_CUBE_MAP_ARRAY" },
{ GLenum::GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT, "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT" },
{ GLenum::GL_INT_SAMPLER_1D, "GL_INT_SAMPLER_1D" },
{ GLenum::GL_INT_SAMPLER_1D_ARRAY, "GL_INT_SAMPLER_1D_ARRAY" },
{ GLenum::GL_INT_SAMPLER_1D_ARRAY_EXT, "GL_INT_SAMPLER_1D_ARRAY_EXT" },
{ GLenum::GL_INT_SAMPLER_1D_EXT, "GL_INT_SAMPLER_1D_EXT" },
{ GLenum::GL_INT_SAMPLER_2D, "GL_INT_SAMPLER_2D" },
{ GLenum::GL_INT_SAMPLER_2D_ARRAY, "GL_INT_SAMPLER_2D_ARRAY" },
{ GLenum::GL_INT_SAMPLER_2D_ARRAY_EXT, "GL_INT_SAMPLER_2D_ARRAY_EXT" },
{ GLenum::GL_INT_SAMPLER_2D_EXT, "GL_INT_SAMPLER_2D_EXT" },
{ GLenum::GL_INT_SAMPLER_2D_MULTISAMPLE, "GL_INT_SAMPLER_2D_MULTISAMPLE" },
{ GLenum::GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_INT_SAMPLER_2D_RECT, "GL_INT_SAMPLER_2D_RECT" },
{ GLenum::GL_INT_SAMPLER_2D_RECT_EXT, "GL_INT_SAMPLER_2D_RECT_EXT" },
{ GLenum::GL_INT_SAMPLER_3D, "GL_INT_SAMPLER_3D" },
{ GLenum::GL_INT_SAMPLER_3D_EXT, "GL_INT_SAMPLER_3D_EXT" },
{ GLenum::GL_INT_SAMPLER_BUFFER, "GL_INT_SAMPLER_BUFFER" },
{ GLenum::GL_INT_SAMPLER_BUFFER_AMD, "GL_INT_SAMPLER_BUFFER_AMD" },
{ GLenum::GL_INT_SAMPLER_BUFFER_EXT, "GL_INT_SAMPLER_BUFFER_EXT" },
{ GLenum::GL_INT_SAMPLER_CUBE, "GL_INT_SAMPLER_CUBE" },
{ GLenum::GL_INT_SAMPLER_CUBE_EXT, "GL_INT_SAMPLER_CUBE_EXT" },
{ GLenum::GL_INT_SAMPLER_CUBE_MAP_ARRAY, "GL_INT_SAMPLER_CUBE_MAP_ARRAY" },
{ GLenum::GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB, "GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_INT_SAMPLER_RENDERBUFFER_NV, "GL_INT_SAMPLER_RENDERBUFFER_NV" },
{ GLenum::GL_INT_VEC2, "GL_INT_VEC2" },
{ GLenum::GL_INT_VEC2_ARB, "GL_INT_VEC2_ARB" },
{ GLenum::GL_INT_VEC3, "GL_INT_VEC3" },
{ GLenum::GL_INT_VEC3_ARB, "GL_INT_VEC3_ARB" },
{ GLenum::GL_INT_VEC4, "GL_INT_VEC4" },
{ GLenum::GL_INT_VEC4_ARB, "GL_INT_VEC4_ARB" },
{ GLenum::GL_INTENSITY, "GL_INTENSITY" },
{ GLenum::GL_INTENSITY12, "GL_INTENSITY12" },
{ GLenum::GL_INTENSITY12_EXT, "GL_INTENSITY12_EXT" },
{ GLenum::GL_INTENSITY16, "GL_INTENSITY16" },
{ GLenum::GL_INTENSITY16_EXT, "GL_INTENSITY16_EXT" },
{ GLenum::GL_INTENSITY16_SNORM, "GL_INTENSITY16_SNORM" },
{ GLenum::GL_INTENSITY16F_ARB, "GL_INTENSITY16F_ARB" },
{ GLenum::GL_INTENSITY16I_EXT, "GL_INTENSITY16I_EXT" },
{ GLenum::GL_INTENSITY16UI_EXT, "GL_INTENSITY16UI_EXT" },
{ GLenum::GL_INTENSITY32F_ARB, "GL_INTENSITY32F_ARB" },
{ GLenum::GL_INTENSITY32I_EXT, "GL_INTENSITY32I_EXT" },
{ GLenum::GL_INTENSITY32UI_EXT, "GL_INTENSITY32UI_EXT" },
{ GLenum::GL_INTENSITY4, "GL_INTENSITY4" },
{ GLenum::GL_INTENSITY4_EXT, "GL_INTENSITY4_EXT" },
{ GLenum::GL_INTENSITY8, "GL_INTENSITY8" },
{ GLenum::GL_INTENSITY8_EXT, "GL_INTENSITY8_EXT" },
{ GLenum::GL_INTENSITY8_SNORM, "GL_INTENSITY8_SNORM" },
{ GLenum::GL_INTENSITY8I_EXT, "GL_INTENSITY8I_EXT" },
{ GLenum::GL_INTENSITY8UI_EXT, "GL_INTENSITY8UI_EXT" },
{ GLenum::GL_INTENSITY_EXT, "GL_INTENSITY_EXT" },
{ GLenum::GL_INTENSITY_FLOAT16_APPLE, "GL_INTENSITY_FLOAT16_APPLE" },
{ GLenum::GL_INTENSITY_FLOAT16_ATI, "GL_INTENSITY_FLOAT16_ATI" },
{ GLenum::GL_INTENSITY_FLOAT32_APPLE, "GL_INTENSITY_FLOAT32_APPLE" },
{ GLenum::GL_INTENSITY_FLOAT32_ATI, "GL_INTENSITY_FLOAT32_ATI" },
{ GLenum::GL_INTENSITY_SNORM, "GL_INTENSITY_SNORM" },
{ GLenum::GL_INTERLACE_OML, "GL_INTERLACE_OML" },
{ GLenum::GL_INTERLACE_READ_INGR, "GL_INTERLACE_READ_INGR" },
{ GLenum::GL_INTERLACE_READ_OML, "GL_INTERLACE_READ_OML" },
{ GLenum::GL_INTERLACE_SGIX, "GL_INTERLACE_SGIX" },
{ GLenum::GL_INTERLEAVED_ATTRIBS, "GL_INTERLEAVED_ATTRIBS" },
{ GLenum::GL_INTERLEAVED_ATTRIBS_EXT, "GL_INTERLEAVED_ATTRIBS_EXT" },
{ GLenum::GL_INTERLEAVED_ATTRIBS_NV, "GL_INTERLEAVED_ATTRIBS_NV" },
{ GLenum::GL_INTERNALFORMAT_ALPHA_SIZE, "GL_INTERNALFORMAT_ALPHA_SIZE" },
{ GLenum::GL_INTERNALFORMAT_ALPHA_TYPE, "GL_INTERNALFORMAT_ALPHA_TYPE" },
{ GLenum::GL_INTERNALFORMAT_BLUE_SIZE, "GL_INTERNALFORMAT_BLUE_SIZE" },
{ GLenum::GL_INTERNALFORMAT_BLUE_TYPE, "GL_INTERNALFORMAT_BLUE_TYPE" },
{ GLenum::GL_INTERNALFORMAT_DEPTH_SIZE, "GL_INTERNALFORMAT_DEPTH_SIZE" },
{ GLenum::GL_INTERNALFORMAT_DEPTH_TYPE, "GL_INTERNALFORMAT_DEPTH_TYPE" },
{ GLenum::GL_INTERNALFORMAT_GREEN_SIZE, "GL_INTERNALFORMAT_GREEN_SIZE" },
{ GLenum::GL_INTERNALFORMAT_GREEN_TYPE, "GL_INTERNALFORMAT_GREEN_TYPE" },
{ GLenum::GL_INTERNALFORMAT_PREFERRED, "GL_INTERNALFORMAT_PREFERRED" },
{ GLenum::GL_INTERNALFORMAT_RED_SIZE, "GL_INTERNALFORMAT_RED_SIZE" },
{ GLenum::GL_INTERNALFORMAT_RED_TYPE, "GL_INTERNALFORMAT_RED_TYPE" },
{ GLenum::GL_INTERNALFORMAT_SHARED_SIZE, "GL_INTERNALFORMAT_SHARED_SIZE" },
{ GLenum::GL_INTERNALFORMAT_STENCIL_SIZE, "GL_INTERNALFORMAT_STENCIL_SIZE" },
{ GLenum::GL_INTERNALFORMAT_STENCIL_TYPE, "GL_INTERNALFORMAT_STENCIL_TYPE" },
{ GLenum::GL_INTERNALFORMAT_SUPPORTED, "GL_INTERNALFORMAT_SUPPORTED" },
{ GLenum::GL_INTERPOLATE, "GL_INTERPOLATE" },
{ GLenum::GL_INTERPOLATE_ARB, "GL_INTERPOLATE_ARB" },
{ GLenum::GL_INTERPOLATE_EXT, "GL_INTERPOLATE_EXT" },
{ GLenum::GL_INVALID_ENUM, "GL_INVALID_ENUM" },
{ GLenum::GL_INVALID_FRAMEBUFFER_OPERATION, "GL_INVALID_FRAMEBUFFER_OPERATION" },
{ GLenum::GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "GL_INVALID_FRAMEBUFFER_OPERATION_EXT" },
{ GLenum::GL_INVALID_OPERATION, "GL_INVALID_OPERATION" },
{ GLenum::GL_INVALID_VALUE, "GL_INVALID_VALUE" },
{ GLenum::GL_INVARIANT_DATATYPE_EXT, "GL_INVARIANT_DATATYPE_EXT" },
{ GLenum::GL_INVARIANT_EXT, "GL_INVARIANT_EXT" },
{ GLenum::GL_INVARIANT_VALUE_EXT, "GL_INVARIANT_VALUE_EXT" },
{ GLenum::GL_INVERSE_NV, "GL_INVERSE_NV" },
{ GLenum::GL_INVERSE_TRANSPOSE_NV, "GL_INVERSE_TRANSPOSE_NV" },
{ GLenum::GL_INVERT, "GL_INVERT" },
{ GLenum::GL_INVERT_OVG_NV, "GL_INVERT_OVG_NV" },
{ GLenum::GL_INVERT_RGB_NV, "GL_INVERT_RGB_NV" },
{ GLenum::GL_INVERTED_SCREEN_W_REND, "GL_INVERTED_SCREEN_W_REND" },
{ GLenum::GL_IR_INSTRUMENT1_SGIX, "GL_IR_INSTRUMENT1_SGIX" },
{ GLenum::GL_IS_PER_PATCH, "GL_IS_PER_PATCH" },
{ GLenum::GL_IS_ROW_MAJOR, "GL_IS_ROW_MAJOR" },
{ GLenum::GL_ISOLINES, "GL_ISOLINES" },
{ GLenum::GL_IUI_N3F_V2F_EXT, "GL_IUI_N3F_V2F_EXT" },
{ GLenum::GL_IUI_N3F_V3F_EXT, "GL_IUI_N3F_V3F_EXT" },
{ GLenum::GL_IUI_V2F_EXT, "GL_IUI_V2F_EXT" },
{ GLenum::GL_IUI_V3F_EXT, "GL_IUI_V3F_EXT" },
{ GLenum::GL_KEEP, "GL_KEEP" },
{ GLenum::GL_LARGE_CCW_ARC_TO_NV, "GL_LARGE_CCW_ARC_TO_NV" },
{ GLenum::GL_LARGE_CW_ARC_TO_NV, "GL_LARGE_CW_ARC_TO_NV" },
{ GLenum::GL_LAST_VERTEX_CONVENTION, "GL_LAST_VERTEX_CONVENTION" },
{ GLenum::GL_LAST_VERTEX_CONVENTION_EXT, "GL_LAST_VERTEX_CONVENTION_EXT" },
{ GLenum::GL_LAST_VIDEO_CAPTURE_STATUS_NV, "GL_LAST_VIDEO_CAPTURE_STATUS_NV" },
{ GLenum::GL_LAYER_NV, "GL_LAYER_NV" },
{ GLenum::GL_LAYER_PROVOKING_VERTEX, "GL_LAYER_PROVOKING_VERTEX" },
{ GLenum::GL_LAYOUT_COLOR_ATTACHMENT_EXT, "GL_LAYOUT_COLOR_ATTACHMENT_EXT" },
{ GLenum::GL_LAYOUT_DEFAULT_INTEL, "GL_LAYOUT_DEFAULT_INTEL" },
{ GLenum::GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT, "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT" },
{ GLenum::GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT, "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT" },
{ GLenum::GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT, "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT" },
{ GLenum::GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT, "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT" },
{ GLenum::GL_LAYOUT_GENERAL_EXT, "GL_LAYOUT_GENERAL_EXT" },
{ GLenum::GL_LAYOUT_LINEAR_CPU_CACHED_INTEL, "GL_LAYOUT_LINEAR_CPU_CACHED_INTEL" },
{ GLenum::GL_LAYOUT_LINEAR_INTEL, "GL_LAYOUT_LINEAR_INTEL" },
{ GLenum::GL_LAYOUT_SHADER_READ_ONLY_EXT, "GL_LAYOUT_SHADER_READ_ONLY_EXT" },
{ GLenum::GL_LAYOUT_TRANSFER_DST_EXT, "GL_LAYOUT_TRANSFER_DST_EXT" },
{ GLenum::GL_LAYOUT_TRANSFER_SRC_EXT, "GL_LAYOUT_TRANSFER_SRC_EXT" },
{ GLenum::GL_LEFT, "GL_LEFT" },
{ GLenum::GL_LEQUAL, "GL_LEQUAL" },
{ GLenum::GL_LERP_ATI, "GL_LERP_ATI" },
{ GLenum::GL_LESS, "GL_LESS" },
{ GLenum::GL_LIGHT0, "GL_LIGHT0" },
{ GLenum::GL_LIGHT1, "GL_LIGHT1" },
{ GLenum::GL_LIGHT2, "GL_LIGHT2" },
{ GLenum::GL_LIGHT3, "GL_LIGHT3" },
{ GLenum::GL_LIGHT4, "GL_LIGHT4" },
{ GLenum::GL_LIGHT5, "GL_LIGHT5" },
{ GLenum::GL_LIGHT6, "GL_LIGHT6" },
{ GLenum::GL_LIGHT7, "GL_LIGHT7" },
{ GLenum::GL_LIGHT_ENV_MODE_SGIX, "GL_LIGHT_ENV_MODE_SGIX" },
{ GLenum::GL_LIGHT_MODEL_AMBIENT, "GL_LIGHT_MODEL_AMBIENT" },
{ GLenum::GL_LIGHT_MODEL_COLOR_CONTROL, "GL_LIGHT_MODEL_COLOR_CONTROL" },
{ GLenum::GL_LIGHT_MODEL_COLOR_CONTROL_EXT, "GL_LIGHT_MODEL_COLOR_CONTROL_EXT" },
{ GLenum::GL_LIGHT_MODEL_LOCAL_VIEWER, "GL_LIGHT_MODEL_LOCAL_VIEWER" },
{ GLenum::GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE, "GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE" },
{ GLenum::GL_LIGHT_MODEL_TWO_SIDE, "GL_LIGHT_MODEL_TWO_SIDE" },
{ GLenum::GL_LIGHTEN_KHR, "GL_LIGHTEN_KHR" },
{ GLenum::GL_LIGHTEN_NV, "GL_LIGHTEN_NV" },
{ GLenum::GL_LIGHTING, "GL_LIGHTING" },
{ GLenum::GL_LINE, "GL_LINE" },
{ GLenum::GL_LINE_LOOP, "GL_LINE_LOOP" },
{ GLenum::GL_LINE_RESET_TOKEN, "GL_LINE_RESET_TOKEN" },
{ GLenum::GL_LINE_SMOOTH, "GL_LINE_SMOOTH" },
{ GLenum::GL_LINE_SMOOTH_HINT, "GL_LINE_SMOOTH_HINT" },
{ GLenum::GL_LINE_STIPPLE, "GL_LINE_STIPPLE" },
{ GLenum::GL_LINE_STIPPLE_PATTERN, "GL_LINE_STIPPLE_PATTERN" },
{ GLenum::GL_LINE_STIPPLE_REPEAT, "GL_LINE_STIPPLE_REPEAT" },
{ GLenum::GL_LINE_STRIP, "GL_LINE_STRIP" },
{ GLenum::GL_LINE_STRIP_ADJACENCY, "GL_LINE_STRIP_ADJACENCY" },
{ GLenum::GL_LINE_STRIP_ADJACENCY_ARB, "GL_LINE_STRIP_ADJACENCY_ARB" },
{ GLenum::GL_LINE_STRIP_ADJACENCY_EXT, "GL_LINE_STRIP_ADJACENCY_EXT" },
{ GLenum::GL_LINE_TO_NV, "GL_LINE_TO_NV" },
{ GLenum::GL_LINE_TOKEN, "GL_LINE_TOKEN" },
{ GLenum::GL_LINE_WIDTH, "GL_LINE_WIDTH" },
{ GLenum::GL_LINE_WIDTH_COMMAND_NV, "GL_LINE_WIDTH_COMMAND_NV" },
{ GLenum::GL_LINE_WIDTH_GRANULARITY, "GL_LINE_WIDTH_GRANULARITY" },
{ GLenum::GL_LINE_WIDTH_RANGE, "GL_LINE_WIDTH_RANGE" },
{ GLenum::GL_LINEAR, "GL_LINEAR" },
{ GLenum::GL_LINEAR_ATTENUATION, "GL_LINEAR_ATTENUATION" },
{ GLenum::GL_LINEAR_CLIPMAP_LINEAR_SGIX, "GL_LINEAR_CLIPMAP_LINEAR_SGIX" },
{ GLenum::GL_LINEAR_CLIPMAP_NEAREST_SGIX, "GL_LINEAR_CLIPMAP_NEAREST_SGIX" },
{ GLenum::GL_LINEAR_DETAIL_ALPHA_SGIS, "GL_LINEAR_DETAIL_ALPHA_SGIS" },
{ GLenum::GL_LINEAR_DETAIL_COLOR_SGIS, "GL_LINEAR_DETAIL_COLOR_SGIS" },
{ GLenum::GL_LINEAR_DETAIL_SGIS, "GL_LINEAR_DETAIL_SGIS" },
{ GLenum::GL_LINEAR_MIPMAP_LINEAR, "GL_LINEAR_MIPMAP_LINEAR" },
{ GLenum::GL_LINEAR_MIPMAP_NEAREST, "GL_LINEAR_MIPMAP_NEAREST" },
{ GLenum::GL_LINEAR_SHARPEN_ALPHA_SGIS, "GL_LINEAR_SHARPEN_ALPHA_SGIS" },
{ GLenum::GL_LINEAR_SHARPEN_COLOR_SGIS, "GL_LINEAR_SHARPEN_COLOR_SGIS" },
{ GLenum::GL_LINEAR_SHARPEN_SGIS, "GL_LINEAR_SHARPEN_SGIS" },
{ GLenum::GL_LINEAR_TILING_EXT, "GL_LINEAR_TILING_EXT" },
{ GLenum::GL_LINEARBURN_NV, "GL_LINEARBURN_NV" },
{ GLenum::GL_LINEARDODGE_NV, "GL_LINEARDODGE_NV" },
{ GLenum::GL_LINEARLIGHT_NV, "GL_LINEARLIGHT_NV" },
{ GLenum::GL_LINES, "GL_LINES" },
{ GLenum::GL_LINES_ADJACENCY, "GL_LINES_ADJACENCY" },
{ GLenum::GL_LINES_ADJACENCY_ARB, "GL_LINES_ADJACENCY_ARB" },
{ GLenum::GL_LINES_ADJACENCY_EXT, "GL_LINES_ADJACENCY_EXT" },
{ GLenum::GL_LINK_STATUS, "GL_LINK_STATUS" },
{ GLenum::GL_LIST_BASE, "GL_LIST_BASE" },
{ GLenum::GL_LIST_INDEX, "GL_LIST_INDEX" },
{ GLenum::GL_LIST_MODE, "GL_LIST_MODE" },
{ GLenum::GL_LIST_PRIORITY_SGIX, "GL_LIST_PRIORITY_SGIX" },
{ GLenum::GL_LO_BIAS_NV, "GL_LO_BIAS_NV" },
{ GLenum::GL_LO_SCALE_NV, "GL_LO_SCALE_NV" },
{ GLenum::GL_LOAD, "GL_LOAD" },
{ GLenum::GL_LOCAL_CONSTANT_DATATYPE_EXT, "GL_LOCAL_CONSTANT_DATATYPE_EXT" },
{ GLenum::GL_LOCAL_CONSTANT_EXT, "GL_LOCAL_CONSTANT_EXT" },
{ GLenum::GL_LOCAL_CONSTANT_VALUE_EXT, "GL_LOCAL_CONSTANT_VALUE_EXT" },
{ GLenum::GL_LOCAL_EXT, "GL_LOCAL_EXT" },
{ GLenum::GL_LOCATION, "GL_LOCATION" },
{ GLenum::GL_LOCATION_COMPONENT, "GL_LOCATION_COMPONENT" },
{ GLenum::GL_LOCATION_INDEX, "GL_LOCATION_INDEX" },
{ GLenum::GL_LOGIC_OP, "GL_LOGIC_OP" },
{ GLenum::GL_LOGIC_OP_MODE, "GL_LOGIC_OP_MODE" },
{ GLenum::GL_LOSE_CONTEXT_ON_RESET, "GL_LOSE_CONTEXT_ON_RESET" },
{ GLenum::GL_LOSE_CONTEXT_ON_RESET_ARB, "GL_LOSE_CONTEXT_ON_RESET_ARB" },
{ GLenum::GL_LOSE_CONTEXT_ON_RESET_KHR, "GL_LOSE_CONTEXT_ON_RESET_KHR" },
{ GLenum::GL_LOW_FLOAT, "GL_LOW_FLOAT" },
{ GLenum::GL_LOW_INT, "GL_LOW_INT" },
{ GLenum::GL_LOWER_LEFT, "GL_LOWER_LEFT" },
{ GLenum::GL_LUMINANCE, "GL_LUMINANCE" },
{ GLenum::GL_LUMINANCE12, "GL_LUMINANCE12" },
{ GLenum::GL_LUMINANCE12_ALPHA12, "GL_LUMINANCE12_ALPHA12" },
{ GLenum::GL_LUMINANCE12_ALPHA12_EXT, "GL_LUMINANCE12_ALPHA12_EXT" },
{ GLenum::GL_LUMINANCE12_ALPHA4, "GL_LUMINANCE12_ALPHA4" },
{ GLenum::GL_LUMINANCE12_ALPHA4_EXT, "GL_LUMINANCE12_ALPHA4_EXT" },
{ GLenum::GL_LUMINANCE12_EXT, "GL_LUMINANCE12_EXT" },
{ GLenum::GL_LUMINANCE16, "GL_LUMINANCE16" },
{ GLenum::GL_LUMINANCE16_ALPHA16, "GL_LUMINANCE16_ALPHA16" },
{ GLenum::GL_LUMINANCE16_ALPHA16_EXT, "GL_LUMINANCE16_ALPHA16_EXT" },
{ GLenum::GL_LUMINANCE16_ALPHA16_SNORM, "GL_LUMINANCE16_ALPHA16_SNORM" },
{ GLenum::GL_LUMINANCE16_EXT, "GL_LUMINANCE16_EXT" },
{ GLenum::GL_LUMINANCE16_SNORM, "GL_LUMINANCE16_SNORM" },
{ GLenum::GL_LUMINANCE16F_ARB, "GL_LUMINANCE16F_ARB" },
{ GLenum::GL_LUMINANCE16I_EXT, "GL_LUMINANCE16I_EXT" },
{ GLenum::GL_LUMINANCE16UI_EXT, "GL_LUMINANCE16UI_EXT" },
{ GLenum::GL_LUMINANCE32F_ARB, "GL_LUMINANCE32F_ARB" },
{ GLenum::GL_LUMINANCE32I_EXT, "GL_LUMINANCE32I_EXT" },
{ GLenum::GL_LUMINANCE32UI_EXT, "GL_LUMINANCE32UI_EXT" },
{ GLenum::GL_LUMINANCE4, "GL_LUMINANCE4" },
{ GLenum::GL_LUMINANCE4_ALPHA4, "GL_LUMINANCE4_ALPHA4" },
{ GLenum::GL_LUMINANCE4_ALPHA4_EXT, "GL_LUMINANCE4_ALPHA4_EXT" },
{ GLenum::GL_LUMINANCE4_EXT, "GL_LUMINANCE4_EXT" },
{ GLenum::GL_LUMINANCE6_ALPHA2, "GL_LUMINANCE6_ALPHA2" },
{ GLenum::GL_LUMINANCE6_ALPHA2_EXT, "GL_LUMINANCE6_ALPHA2_EXT" },
{ GLenum::GL_LUMINANCE8, "GL_LUMINANCE8" },
{ GLenum::GL_LUMINANCE8_ALPHA8, "GL_LUMINANCE8_ALPHA8" },
{ GLenum::GL_LUMINANCE8_ALPHA8_EXT, "GL_LUMINANCE8_ALPHA8_EXT" },
{ GLenum::GL_LUMINANCE8_ALPHA8_SNORM, "GL_LUMINANCE8_ALPHA8_SNORM" },
{ GLenum::GL_LUMINANCE8_EXT, "GL_LUMINANCE8_EXT" },
{ GLenum::GL_LUMINANCE8_SNORM, "GL_LUMINANCE8_SNORM" },
{ GLenum::GL_LUMINANCE8I_EXT, "GL_LUMINANCE8I_EXT" },
{ GLenum::GL_LUMINANCE8UI_EXT, "GL_LUMINANCE8UI_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA, "GL_LUMINANCE_ALPHA" },
{ GLenum::GL_LUMINANCE_ALPHA16F_ARB, "GL_LUMINANCE_ALPHA16F_ARB" },
{ GLenum::GL_LUMINANCE_ALPHA16I_EXT, "GL_LUMINANCE_ALPHA16I_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA16UI_EXT, "GL_LUMINANCE_ALPHA16UI_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA32F_ARB, "GL_LUMINANCE_ALPHA32F_ARB" },
{ GLenum::GL_LUMINANCE_ALPHA32I_EXT, "GL_LUMINANCE_ALPHA32I_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA32UI_EXT, "GL_LUMINANCE_ALPHA32UI_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA8I_EXT, "GL_LUMINANCE_ALPHA8I_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA8UI_EXT, "GL_LUMINANCE_ALPHA8UI_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA_FLOAT16_APPLE, "GL_LUMINANCE_ALPHA_FLOAT16_APPLE" },
{ GLenum::GL_LUMINANCE_ALPHA_FLOAT16_ATI, "GL_LUMINANCE_ALPHA_FLOAT16_ATI" },
{ GLenum::GL_LUMINANCE_ALPHA_FLOAT32_APPLE, "GL_LUMINANCE_ALPHA_FLOAT32_APPLE" },
{ GLenum::GL_LUMINANCE_ALPHA_FLOAT32_ATI, "GL_LUMINANCE_ALPHA_FLOAT32_ATI" },
{ GLenum::GL_LUMINANCE_ALPHA_INTEGER_EXT, "GL_LUMINANCE_ALPHA_INTEGER_EXT" },
{ GLenum::GL_LUMINANCE_ALPHA_SNORM, "GL_LUMINANCE_ALPHA_SNORM" },
{ GLenum::GL_LUMINANCE_FLOAT16_APPLE, "GL_LUMINANCE_FLOAT16_APPLE" },
{ GLenum::GL_LUMINANCE_FLOAT16_ATI, "GL_LUMINANCE_FLOAT16_ATI" },
{ GLenum::GL_LUMINANCE_FLOAT32_APPLE, "GL_LUMINANCE_FLOAT32_APPLE" },
{ GLenum::GL_LUMINANCE_FLOAT32_ATI, "GL_LUMINANCE_FLOAT32_ATI" },
{ GLenum::GL_LUMINANCE_INTEGER_EXT, "GL_LUMINANCE_INTEGER_EXT" },
{ GLenum::GL_LUMINANCE_SNORM, "GL_LUMINANCE_SNORM" },
{ GLenum::GL_MAD_ATI, "GL_MAD_ATI" },
{ GLenum::GL_MAGNITUDE_BIAS_NV, "GL_MAGNITUDE_BIAS_NV" },
{ GLenum::GL_MAGNITUDE_SCALE_NV, "GL_MAGNITUDE_SCALE_NV" },
{ GLenum::GL_MAJOR_VERSION, "GL_MAJOR_VERSION" },
{ GLenum::GL_MANUAL_GENERATE_MIPMAP, "GL_MANUAL_GENERATE_MIPMAP" },
{ GLenum::GL_MAP1_BINORMAL_EXT, "GL_MAP1_BINORMAL_EXT" },
{ GLenum::GL_MAP1_COLOR_4, "GL_MAP1_COLOR_4" },
{ GLenum::GL_MAP1_GRID_DOMAIN, "GL_MAP1_GRID_DOMAIN" },
{ GLenum::GL_MAP1_GRID_SEGMENTS, "GL_MAP1_GRID_SEGMENTS" },
{ GLenum::GL_MAP1_INDEX, "GL_MAP1_INDEX" },
{ GLenum::GL_MAP1_NORMAL, "GL_MAP1_NORMAL" },
{ GLenum::GL_MAP1_TANGENT_EXT, "GL_MAP1_TANGENT_EXT" },
{ GLenum::GL_MAP1_TEXTURE_COORD_1, "GL_MAP1_TEXTURE_COORD_1" },
{ GLenum::GL_MAP1_TEXTURE_COORD_2, "GL_MAP1_TEXTURE_COORD_2" },
{ GLenum::GL_MAP1_TEXTURE_COORD_3, "GL_MAP1_TEXTURE_COORD_3" },
{ GLenum::GL_MAP1_TEXTURE_COORD_4, "GL_MAP1_TEXTURE_COORD_4" },
{ GLenum::GL_MAP1_VERTEX_3, "GL_MAP1_VERTEX_3" },
{ GLenum::GL_MAP1_VERTEX_4, "GL_MAP1_VERTEX_4" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB0_4_NV, "GL_MAP1_VERTEX_ATTRIB0_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB10_4_NV, "GL_MAP1_VERTEX_ATTRIB10_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB11_4_NV, "GL_MAP1_VERTEX_ATTRIB11_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB12_4_NV, "GL_MAP1_VERTEX_ATTRIB12_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB13_4_NV, "GL_MAP1_VERTEX_ATTRIB13_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB14_4_NV, "GL_MAP1_VERTEX_ATTRIB14_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB15_4_NV, "GL_MAP1_VERTEX_ATTRIB15_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB1_4_NV, "GL_MAP1_VERTEX_ATTRIB1_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB2_4_NV, "GL_MAP1_VERTEX_ATTRIB2_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB3_4_NV, "GL_MAP1_VERTEX_ATTRIB3_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB4_4_NV, "GL_MAP1_VERTEX_ATTRIB4_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB5_4_NV, "GL_MAP1_VERTEX_ATTRIB5_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB6_4_NV, "GL_MAP1_VERTEX_ATTRIB6_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB7_4_NV, "GL_MAP1_VERTEX_ATTRIB7_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB8_4_NV, "GL_MAP1_VERTEX_ATTRIB8_4_NV" },
{ GLenum::GL_MAP1_VERTEX_ATTRIB9_4_NV, "GL_MAP1_VERTEX_ATTRIB9_4_NV" },
{ GLenum::GL_MAP2_BINORMAL_EXT, "GL_MAP2_BINORMAL_EXT" },
{ GLenum::GL_MAP2_COLOR_4, "GL_MAP2_COLOR_4" },
{ GLenum::GL_MAP2_GRID_DOMAIN, "GL_MAP2_GRID_DOMAIN" },
{ GLenum::GL_MAP2_GRID_SEGMENTS, "GL_MAP2_GRID_SEGMENTS" },
{ GLenum::GL_MAP2_INDEX, "GL_MAP2_INDEX" },
{ GLenum::GL_MAP2_NORMAL, "GL_MAP2_NORMAL" },
{ GLenum::GL_MAP2_TANGENT_EXT, "GL_MAP2_TANGENT_EXT" },
{ GLenum::GL_MAP2_TEXTURE_COORD_1, "GL_MAP2_TEXTURE_COORD_1" },
{ GLenum::GL_MAP2_TEXTURE_COORD_2, "GL_MAP2_TEXTURE_COORD_2" },
{ GLenum::GL_MAP2_TEXTURE_COORD_3, "GL_MAP2_TEXTURE_COORD_3" },
{ GLenum::GL_MAP2_TEXTURE_COORD_4, "GL_MAP2_TEXTURE_COORD_4" },
{ GLenum::GL_MAP2_VERTEX_3, "GL_MAP2_VERTEX_3" },
{ GLenum::GL_MAP2_VERTEX_4, "GL_MAP2_VERTEX_4" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB0_4_NV, "GL_MAP2_VERTEX_ATTRIB0_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB10_4_NV, "GL_MAP2_VERTEX_ATTRIB10_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB11_4_NV, "GL_MAP2_VERTEX_ATTRIB11_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB12_4_NV, "GL_MAP2_VERTEX_ATTRIB12_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB13_4_NV, "GL_MAP2_VERTEX_ATTRIB13_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB14_4_NV, "GL_MAP2_VERTEX_ATTRIB14_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB15_4_NV, "GL_MAP2_VERTEX_ATTRIB15_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB1_4_NV, "GL_MAP2_VERTEX_ATTRIB1_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB2_4_NV, "GL_MAP2_VERTEX_ATTRIB2_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB3_4_NV, "GL_MAP2_VERTEX_ATTRIB3_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB4_4_NV, "GL_MAP2_VERTEX_ATTRIB4_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB5_4_NV, "GL_MAP2_VERTEX_ATTRIB5_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB6_4_NV, "GL_MAP2_VERTEX_ATTRIB6_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB7_4_NV, "GL_MAP2_VERTEX_ATTRIB7_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB8_4_NV, "GL_MAP2_VERTEX_ATTRIB8_4_NV" },
{ GLenum::GL_MAP2_VERTEX_ATTRIB9_4_NV, "GL_MAP2_VERTEX_ATTRIB9_4_NV" },
{ GLenum::GL_MAP_ATTRIB_U_ORDER_NV, "GL_MAP_ATTRIB_U_ORDER_NV" },
{ GLenum::GL_MAP_ATTRIB_V_ORDER_NV, "GL_MAP_ATTRIB_V_ORDER_NV" },
{ GLenum::GL_MAP_COLOR, "GL_MAP_COLOR" },
{ GLenum::GL_MAP_STENCIL, "GL_MAP_STENCIL" },
{ GLenum::GL_MAP_TESSELLATION_NV, "GL_MAP_TESSELLATION_NV" },
{ GLenum::GL_MATERIAL_SIDE_HINT_PGI, "GL_MATERIAL_SIDE_HINT_PGI" },
{ GLenum::GL_MATRIX0_ARB, "GL_MATRIX0_ARB" },
{ GLenum::GL_MATRIX0_NV, "GL_MATRIX0_NV" },
{ GLenum::GL_MATRIX10_ARB, "GL_MATRIX10_ARB" },
{ GLenum::GL_MATRIX11_ARB, "GL_MATRIX11_ARB" },
{ GLenum::GL_MATRIX12_ARB, "GL_MATRIX12_ARB" },
{ GLenum::GL_MATRIX13_ARB, "GL_MATRIX13_ARB" },
{ GLenum::GL_MATRIX14_ARB, "GL_MATRIX14_ARB" },
{ GLenum::GL_MATRIX15_ARB, "GL_MATRIX15_ARB" },
{ GLenum::GL_MATRIX16_ARB, "GL_MATRIX16_ARB" },
{ GLenum::GL_MATRIX17_ARB, "GL_MATRIX17_ARB" },
{ GLenum::GL_MATRIX18_ARB, "GL_MATRIX18_ARB" },
{ GLenum::GL_MATRIX19_ARB, "GL_MATRIX19_ARB" },
{ GLenum::GL_MATRIX1_ARB, "GL_MATRIX1_ARB" },
{ GLenum::GL_MATRIX1_NV, "GL_MATRIX1_NV" },
{ GLenum::GL_MATRIX20_ARB, "GL_MATRIX20_ARB" },
{ GLenum::GL_MATRIX21_ARB, "GL_MATRIX21_ARB" },
{ GLenum::GL_MATRIX22_ARB, "GL_MATRIX22_ARB" },
{ GLenum::GL_MATRIX23_ARB, "GL_MATRIX23_ARB" },
{ GLenum::GL_MATRIX24_ARB, "GL_MATRIX24_ARB" },
{ GLenum::GL_MATRIX25_ARB, "GL_MATRIX25_ARB" },
{ GLenum::GL_MATRIX26_ARB, "GL_MATRIX26_ARB" },
{ GLenum::GL_MATRIX27_ARB, "GL_MATRIX27_ARB" },
{ GLenum::GL_MATRIX28_ARB, "GL_MATRIX28_ARB" },
{ GLenum::GL_MATRIX29_ARB, "GL_MATRIX29_ARB" },
{ GLenum::GL_MATRIX2_ARB, "GL_MATRIX2_ARB" },
{ GLenum::GL_MATRIX2_NV, "GL_MATRIX2_NV" },
{ GLenum::GL_MATRIX30_ARB, "GL_MATRIX30_ARB" },
{ GLenum::GL_MATRIX31_ARB, "GL_MATRIX31_ARB" },
{ GLenum::GL_MATRIX3_ARB, "GL_MATRIX3_ARB" },
{ GLenum::GL_MATRIX3_NV, "GL_MATRIX3_NV" },
{ GLenum::GL_MATRIX4_ARB, "GL_MATRIX4_ARB" },
{ GLenum::GL_MATRIX4_NV, "GL_MATRIX4_NV" },
{ GLenum::GL_MATRIX5_ARB, "GL_MATRIX5_ARB" },
{ GLenum::GL_MATRIX5_NV, "GL_MATRIX5_NV" },
{ GLenum::GL_MATRIX6_ARB, "GL_MATRIX6_ARB" },
{ GLenum::GL_MATRIX6_NV, "GL_MATRIX6_NV" },
{ GLenum::GL_MATRIX7_ARB, "GL_MATRIX7_ARB" },
{ GLenum::GL_MATRIX7_NV, "GL_MATRIX7_NV" },
{ GLenum::GL_MATRIX8_ARB, "GL_MATRIX8_ARB" },
{ GLenum::GL_MATRIX9_ARB, "GL_MATRIX9_ARB" },
{ GLenum::GL_MATRIX_EXT, "GL_MATRIX_EXT" },
{ GLenum::GL_MATRIX_INDEX_ARRAY_ARB, "GL_MATRIX_INDEX_ARRAY_ARB" },
{ GLenum::GL_MATRIX_INDEX_ARRAY_POINTER_ARB, "GL_MATRIX_INDEX_ARRAY_POINTER_ARB" },
{ GLenum::GL_MATRIX_INDEX_ARRAY_SIZE_ARB, "GL_MATRIX_INDEX_ARRAY_SIZE_ARB" },
{ GLenum::GL_MATRIX_INDEX_ARRAY_STRIDE_ARB, "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB" },
{ GLenum::GL_MATRIX_INDEX_ARRAY_TYPE_ARB, "GL_MATRIX_INDEX_ARRAY_TYPE_ARB" },
{ GLenum::GL_MATRIX_MODE, "GL_MATRIX_MODE" },
{ GLenum::GL_MATRIX_PALETTE_ARB, "GL_MATRIX_PALETTE_ARB" },
{ GLenum::GL_MATRIX_STRIDE, "GL_MATRIX_STRIDE" },
{ GLenum::GL_MAX, "GL_MAX" },
{ GLenum::GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE" },
{ GLenum::GL_MAX_3D_TEXTURE_SIZE_EXT, "GL_MAX_3D_TEXTURE_SIZE_EXT" },
{ GLenum::GL_MAX_4D_TEXTURE_SIZE_SGIS, "GL_MAX_4D_TEXTURE_SIZE_SGIS" },
{ GLenum::GL_MAX_ACTIVE_LIGHTS_SGIX, "GL_MAX_ACTIVE_LIGHTS_SGIX" },
{ GLenum::GL_MAX_ARRAY_TEXTURE_LAYERS, "GL_MAX_ARRAY_TEXTURE_LAYERS" },
{ GLenum::GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT" },
{ GLenum::GL_MAX_ASYNC_DRAW_PIXELS_SGIX, "GL_MAX_ASYNC_DRAW_PIXELS_SGIX" },
{ GLenum::GL_MAX_ASYNC_HISTOGRAM_SGIX, "GL_MAX_ASYNC_HISTOGRAM_SGIX" },
{ GLenum::GL_MAX_ASYNC_READ_PIXELS_SGIX, "GL_MAX_ASYNC_READ_PIXELS_SGIX" },
{ GLenum::GL_MAX_ASYNC_TEX_IMAGE_SGIX, "GL_MAX_ASYNC_TEX_IMAGE_SGIX" },
{ GLenum::GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS" },
{ GLenum::GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE, "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE" },
{ GLenum::GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH" },
{ GLenum::GL_MAX_BINDABLE_UNIFORM_SIZE_EXT, "GL_MAX_BINDABLE_UNIFORM_SIZE_EXT" },
{ GLenum::GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH" },
{ GLenum::GL_MAX_CLIP_DISTANCES, "GL_MAX_CLIP_DISTANCES" },
{ GLenum::GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES" },
{ GLenum::GL_MAX_CLIPMAP_DEPTH_SGIX, "GL_MAX_CLIPMAP_DEPTH_SGIX" },
{ GLenum::GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX, "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX" },
{ GLenum::GL_MAX_COARSE_FRAGMENT_SAMPLES_NV, "GL_MAX_COARSE_FRAGMENT_SAMPLES_NV" },
{ GLenum::GL_MAX_COLOR_ATTACHMENTS, "GL_MAX_COLOR_ATTACHMENTS" },
{ GLenum::GL_MAX_COLOR_ATTACHMENTS_EXT, "GL_MAX_COLOR_ATTACHMENTS_EXT" },
{ GLenum::GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD, "GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD" },
{ GLenum::GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD, "GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD" },
{ GLenum::GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH" },
{ GLenum::GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI, "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI" },
{ GLenum::GL_MAX_COLOR_TEXTURE_SAMPLES, "GL_MAX_COLOR_TEXTURE_SAMPLES" },
{ GLenum::GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS, "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_COMBINED_ATOMIC_COUNTERS, "GL_MAX_COMBINED_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES" },
{ GLenum::GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMBINED_DIMENSIONS, "GL_MAX_COMBINED_DIMENSIONS" },
{ GLenum::GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMBINED_IMAGE_UNIFORMS, "GL_MAX_COMBINED_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS, "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS" },
{ GLenum::GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT, "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT" },
{ GLenum::GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV, "GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV" },
{ GLenum::GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES, "GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES" },
{ GLenum::GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS, "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV, "GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV" },
{ GLenum::GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" },
{ GLenum::GL_MAX_COMBINED_UNIFORM_BLOCKS, "GL_MAX_COMBINED_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_COMPUTE_ATOMIC_COUNTERS, "GL_MAX_COMPUTE_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB, "GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB" },
{ GLenum::GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB, "GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB" },
{ GLenum::GL_MAX_COMPUTE_IMAGE_UNIFORMS, "GL_MAX_COMPUTE_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS, "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_COMPUTE_SHARED_MEMORY_SIZE, "GL_MAX_COMPUTE_SHARED_MEMORY_SIZE" },
{ GLenum::GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_COMPUTE_UNIFORM_BLOCKS, "GL_MAX_COMPUTE_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_COMPUTE_UNIFORM_COMPONENTS, "GL_MAX_COMPUTE_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB, "GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB" },
{ GLenum::GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB, "GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB" },
{ GLenum::GL_MAX_COMPUTE_WORK_GROUP_COUNT, "GL_MAX_COMPUTE_WORK_GROUP_COUNT" },
{ GLenum::GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS" },
{ GLenum::GL_MAX_COMPUTE_WORK_GROUP_SIZE, "GL_MAX_COMPUTE_WORK_GROUP_SIZE" },
{ GLenum::GL_MAX_CONVOLUTION_HEIGHT, "GL_MAX_CONVOLUTION_HEIGHT" },
{ GLenum::GL_MAX_CONVOLUTION_HEIGHT_EXT, "GL_MAX_CONVOLUTION_HEIGHT_EXT" },
{ GLenum::GL_MAX_CONVOLUTION_WIDTH, "GL_MAX_CONVOLUTION_WIDTH" },
{ GLenum::GL_MAX_CONVOLUTION_WIDTH_EXT, "GL_MAX_CONVOLUTION_WIDTH_EXT" },
{ GLenum::GL_MAX_CUBE_MAP_TEXTURE_SIZE, "GL_MAX_CUBE_MAP_TEXTURE_SIZE" },
{ GLenum::GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB" },
{ GLenum::GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT" },
{ GLenum::GL_MAX_CULL_DISTANCES, "GL_MAX_CULL_DISTANCES" },
{ GLenum::GL_MAX_DEBUG_GROUP_STACK_DEPTH, "GL_MAX_DEBUG_GROUP_STACK_DEPTH" },
{ GLenum::GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR, "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR" },
{ GLenum::GL_MAX_DEBUG_LOGGED_MESSAGES, "GL_MAX_DEBUG_LOGGED_MESSAGES" },
{ GLenum::GL_MAX_DEBUG_LOGGED_MESSAGES_AMD, "GL_MAX_DEBUG_LOGGED_MESSAGES_AMD" },
{ GLenum::GL_MAX_DEBUG_LOGGED_MESSAGES_ARB, "GL_MAX_DEBUG_LOGGED_MESSAGES_ARB" },
{ GLenum::GL_MAX_DEBUG_LOGGED_MESSAGES_KHR, "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR" },
{ GLenum::GL_MAX_DEBUG_MESSAGE_LENGTH, "GL_MAX_DEBUG_MESSAGE_LENGTH" },
{ GLenum::GL_MAX_DEBUG_MESSAGE_LENGTH_AMD, "GL_MAX_DEBUG_MESSAGE_LENGTH_AMD" },
{ GLenum::GL_MAX_DEBUG_MESSAGE_LENGTH_ARB, "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB" },
{ GLenum::GL_MAX_DEBUG_MESSAGE_LENGTH_KHR, "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR" },
{ GLenum::GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV, "GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV" },
{ GLenum::GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV, "GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV" },
{ GLenum::GL_MAX_DEFORMATION_ORDER_SGIX, "GL_MAX_DEFORMATION_ORDER_SGIX" },
{ GLenum::GL_MAX_DEPTH, "GL_MAX_DEPTH" },
{ GLenum::GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD, "GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD" },
{ GLenum::GL_MAX_DEPTH_TEXTURE_SAMPLES, "GL_MAX_DEPTH_TEXTURE_SAMPLES" },
{ GLenum::GL_MAX_DETACHED_BUFFERS_NV, "GL_MAX_DETACHED_BUFFERS_NV" },
{ GLenum::GL_MAX_DETACHED_TEXTURES_NV, "GL_MAX_DETACHED_TEXTURES_NV" },
{ GLenum::GL_MAX_DRAW_BUFFERS, "GL_MAX_DRAW_BUFFERS" },
{ GLenum::GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB" },
{ GLenum::GL_MAX_DRAW_BUFFERS_ATI, "GL_MAX_DRAW_BUFFERS_ATI" },
{ GLenum::GL_MAX_DRAW_MESH_TASKS_COUNT_NV, "GL_MAX_DRAW_MESH_TASKS_COUNT_NV" },
{ GLenum::GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS" },
{ GLenum::GL_MAX_ELEMENT_INDEX, "GL_MAX_ELEMENT_INDEX" },
{ GLenum::GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES" },
{ GLenum::GL_MAX_ELEMENTS_INDICES_EXT, "GL_MAX_ELEMENTS_INDICES_EXT" },
{ GLenum::GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES" },
{ GLenum::GL_MAX_ELEMENTS_VERTICES_EXT, "GL_MAX_ELEMENTS_VERTICES_EXT" },
{ GLenum::GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER" },
{ GLenum::GL_MAX_EXT, "GL_MAX_EXT" },
{ GLenum::GL_MAX_FOG_FUNC_POINTS_SGIS, "GL_MAX_FOG_FUNC_POINTS_SGIS" },
{ GLenum::GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_FRAGMENT_ATOMIC_COUNTERS, "GL_MAX_FRAGMENT_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT, "GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT" },
{ GLenum::GL_MAX_FRAGMENT_IMAGE_UNIFORMS, "GL_MAX_FRAGMENT_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_FRAGMENT_INPUT_COMPONENTS, "GL_MAX_FRAGMENT_INPUT_COMPONENTS" },
{ GLenum::GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET" },
{ GLenum::GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV, "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV" },
{ GLenum::GL_MAX_FRAGMENT_LIGHTS_SGIX, "GL_MAX_FRAGMENT_LIGHTS_SGIX" },
{ GLenum::GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV, "GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV" },
{ GLenum::GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS, "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_FRAGMENT_UNIFORM_BLOCKS, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" },
{ GLenum::GL_MAX_FRAGMENT_UNIFORM_VECTORS, "GL_MAX_FRAGMENT_UNIFORM_VECTORS" },
{ GLenum::GL_MAX_FRAMEBUFFER_HEIGHT, "GL_MAX_FRAMEBUFFER_HEIGHT" },
{ GLenum::GL_MAX_FRAMEBUFFER_LAYERS, "GL_MAX_FRAMEBUFFER_LAYERS" },
{ GLenum::GL_MAX_FRAMEBUFFER_SAMPLES, "GL_MAX_FRAMEBUFFER_SAMPLES" },
{ GLenum::GL_MAX_FRAMEBUFFER_WIDTH, "GL_MAX_FRAMEBUFFER_WIDTH" },
{ GLenum::GL_MAX_FRAMEZOOM_FACTOR_SGIX, "GL_MAX_FRAMEZOOM_FACTOR_SGIX" },
{ GLenum::GL_MAX_GENERAL_COMBINERS_NV, "GL_MAX_GENERAL_COMBINERS_NV" },
{ GLenum::GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS, "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_GEOMETRY_ATOMIC_COUNTERS, "GL_MAX_GEOMETRY_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT, "GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT" },
{ GLenum::GL_MAX_GEOMETRY_IMAGE_UNIFORMS, "GL_MAX_GEOMETRY_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_GEOMETRY_INPUT_COMPONENTS, "GL_MAX_GEOMETRY_INPUT_COMPONENTS" },
{ GLenum::GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_GEOMETRY_OUTPUT_VERTICES, "GL_MAX_GEOMETRY_OUTPUT_VERTICES" },
{ GLenum::GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB, "GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB" },
{ GLenum::GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT" },
{ GLenum::GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV, "GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV" },
{ GLenum::GL_MAX_GEOMETRY_SHADER_INVOCATIONS, "GL_MAX_GEOMETRY_SHADER_INVOCATIONS" },
{ GLenum::GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS, "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB" },
{ GLenum::GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT" },
{ GLenum::GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB" },
{ GLenum::GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT" },
{ GLenum::GL_MAX_GEOMETRY_UNIFORM_BLOCKS, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB" },
{ GLenum::GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT" },
{ GLenum::GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB, "GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB" },
{ GLenum::GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT, "GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT" },
{ GLenum::GL_MAX_HEIGHT, "GL_MAX_HEIGHT" },
{ GLenum::GL_MAX_IMAGE_SAMPLES, "GL_MAX_IMAGE_SAMPLES" },
{ GLenum::GL_MAX_IMAGE_SAMPLES_EXT, "GL_MAX_IMAGE_SAMPLES_EXT" },
{ GLenum::GL_MAX_IMAGE_UNITS, "GL_MAX_IMAGE_UNITS" },
{ GLenum::GL_MAX_IMAGE_UNITS_EXT, "GL_MAX_IMAGE_UNITS_EXT" },
{ GLenum::GL_MAX_INTEGER_SAMPLES, "GL_MAX_INTEGER_SAMPLES" },
{ GLenum::GL_MAX_LABEL_LENGTH, "GL_MAX_LABEL_LENGTH" },
{ GLenum::GL_MAX_LABEL_LENGTH_KHR, "GL_MAX_LABEL_LENGTH_KHR" },
{ GLenum::GL_MAX_LAYERS, "GL_MAX_LAYERS" },
{ GLenum::GL_MAX_LGPU_GPUS_NVX, "GL_MAX_LGPU_GPUS_NVX" },
{ GLenum::GL_MAX_LIGHTS, "GL_MAX_LIGHTS" },
{ GLenum::GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING" },
{ GLenum::GL_MAX_MAP_TESSELLATION_NV, "GL_MAX_MAP_TESSELLATION_NV" },
{ GLenum::GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB, "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB" },
{ GLenum::GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV, "GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV" },
{ GLenum::GL_MAX_MESH_ATOMIC_COUNTERS_NV, "GL_MAX_MESH_ATOMIC_COUNTERS_NV" },
{ GLenum::GL_MAX_MESH_IMAGE_UNIFORMS_NV, "GL_MAX_MESH_IMAGE_UNIFORMS_NV" },
{ GLenum::GL_MAX_MESH_OUTPUT_PRIMITIVES_NV, "GL_MAX_MESH_OUTPUT_PRIMITIVES_NV" },
{ GLenum::GL_MAX_MESH_OUTPUT_VERTICES_NV, "GL_MAX_MESH_OUTPUT_VERTICES_NV" },
{ GLenum::GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV, "GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV" },
{ GLenum::GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV, "GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV" },
{ GLenum::GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV, "GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV" },
{ GLenum::GL_MAX_MESH_UNIFORM_BLOCKS_NV, "GL_MAX_MESH_UNIFORM_BLOCKS_NV" },
{ GLenum::GL_MAX_MESH_UNIFORM_COMPONENTS_NV, "GL_MAX_MESH_UNIFORM_COMPONENTS_NV" },
{ GLenum::GL_MAX_MESH_VIEWS_NV, "GL_MAX_MESH_VIEWS_NV" },
{ GLenum::GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV, "GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV" },
{ GLenum::GL_MAX_MESH_WORK_GROUP_SIZE_NV, "GL_MAX_MESH_WORK_GROUP_SIZE_NV" },
{ GLenum::GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH" },
{ GLenum::GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV, "GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV" },
{ GLenum::GL_MAX_NAME_LENGTH, "GL_MAX_NAME_LENGTH" },
{ GLenum::GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH" },
{ GLenum::GL_MAX_NUM_ACTIVE_VARIABLES, "GL_MAX_NUM_ACTIVE_VARIABLES" },
{ GLenum::GL_MAX_NUM_COMPATIBLE_SUBROUTINES, "GL_MAX_NUM_COMPATIBLE_SUBROUTINES" },
{ GLenum::GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT, "GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT" },
{ GLenum::GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT, "GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT" },
{ GLenum::GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT" },
{ GLenum::GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT, "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT" },
{ GLenum::GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT, "GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT" },
{ GLenum::GL_MAX_PALETTE_MATRICES_ARB, "GL_MAX_PALETTE_MATRICES_ARB" },
{ GLenum::GL_MAX_PATCH_VERTICES, "GL_MAX_PATCH_VERTICES" },
{ GLenum::GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE" },
{ GLenum::GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT, "GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT" },
{ GLenum::GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI, "GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI" },
{ GLenum::GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV, "GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV" },
{ GLenum::GL_MAX_PROGRAM_ATTRIBS_ARB, "GL_MAX_PROGRAM_ATTRIBS_ARB" },
{ GLenum::GL_MAX_PROGRAM_CALL_DEPTH_NV, "GL_MAX_PROGRAM_CALL_DEPTH_NV" },
{ GLenum::GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV, "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" },
{ GLenum::GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV, "GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV" },
{ GLenum::GL_MAX_PROGRAM_GENERIC_RESULTS_NV, "GL_MAX_PROGRAM_GENERIC_RESULTS_NV" },
{ GLenum::GL_MAX_PROGRAM_IF_DEPTH_NV, "GL_MAX_PROGRAM_IF_DEPTH_NV" },
{ GLenum::GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_LOOP_COUNT_NV, "GL_MAX_PROGRAM_LOOP_COUNT_NV" },
{ GLenum::GL_MAX_PROGRAM_LOOP_DEPTH_NV, "GL_MAX_PROGRAM_LOOP_DEPTH_NV" },
{ GLenum::GL_MAX_PROGRAM_MATRICES_ARB, "GL_MAX_PROGRAM_MATRICES_ARB" },
{ GLenum::GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_OUTPUT_VERTICES_NV, "GL_MAX_PROGRAM_OUTPUT_VERTICES_NV" },
{ GLenum::GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV, "GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV" },
{ GLenum::GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV, "GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV" },
{ GLenum::GL_MAX_PROGRAM_PARAMETERS_ARB, "GL_MAX_PROGRAM_PARAMETERS_ARB" },
{ GLenum::GL_MAX_PROGRAM_PATCH_ATTRIBS_NV, "GL_MAX_PROGRAM_PATCH_ATTRIBS_NV" },
{ GLenum::GL_MAX_PROGRAM_RESULT_COMPONENTS_NV, "GL_MAX_PROGRAM_RESULT_COMPONENTS_NV" },
{ GLenum::GL_MAX_PROGRAM_SUBROUTINE_NUM_NV, "GL_MAX_PROGRAM_SUBROUTINE_NUM_NV" },
{ GLenum::GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV, "GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV" },
{ GLenum::GL_MAX_PROGRAM_TEMPORARIES_ARB, "GL_MAX_PROGRAM_TEMPORARIES_ARB" },
{ GLenum::GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" },
{ GLenum::GL_MAX_PROGRAM_TEXEL_OFFSET, "GL_MAX_PROGRAM_TEXEL_OFFSET" },
{ GLenum::GL_MAX_PROGRAM_TEXEL_OFFSET_EXT, "GL_MAX_PROGRAM_TEXEL_OFFSET_EXT" },
{ GLenum::GL_MAX_PROGRAM_TEXEL_OFFSET_NV, "GL_MAX_PROGRAM_TEXEL_OFFSET_NV" },
{ GLenum::GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB, "GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB" },
{ GLenum::GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET" },
{ GLenum::GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB, "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB" },
{ GLenum::GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV, "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV" },
{ GLenum::GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV, "GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV" },
{ GLenum::GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH" },
{ GLenum::GL_MAX_RASTER_SAMPLES_EXT, "GL_MAX_RASTER_SAMPLES_EXT" },
{ GLenum::GL_MAX_RATIONAL_EVAL_ORDER_NV, "GL_MAX_RATIONAL_EVAL_ORDER_NV" },
{ GLenum::GL_MAX_RECTANGLE_TEXTURE_SIZE, "GL_MAX_RECTANGLE_TEXTURE_SIZE" },
{ GLenum::GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB" },
{ GLenum::GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" },
{ GLenum::GL_MAX_RENDERBUFFER_SIZE, "GL_MAX_RENDERBUFFER_SIZE" },
{ GLenum::GL_MAX_RENDERBUFFER_SIZE_EXT, "GL_MAX_RENDERBUFFER_SIZE_EXT" },
{ GLenum::GL_MAX_SAMPLE_MASK_WORDS, "GL_MAX_SAMPLE_MASK_WORDS" },
{ GLenum::GL_MAX_SAMPLE_MASK_WORDS_NV, "GL_MAX_SAMPLE_MASK_WORDS_NV" },
{ GLenum::GL_MAX_SAMPLES, "GL_MAX_SAMPLES" },
{ GLenum::GL_MAX_SAMPLES_EXT, "GL_MAX_SAMPLES_EXT" },
{ GLenum::GL_MAX_SERVER_WAIT_TIMEOUT, "GL_MAX_SERVER_WAIT_TIMEOUT" },
{ GLenum::GL_MAX_SHADER_BUFFER_ADDRESS_NV, "GL_MAX_SHADER_BUFFER_ADDRESS_NV" },
{ GLenum::GL_MAX_SHADER_COMPILER_THREADS_ARB, "GL_MAX_SHADER_COMPILER_THREADS_ARB" },
{ GLenum::GL_MAX_SHADER_COMPILER_THREADS_KHR, "GL_MAX_SHADER_COMPILER_THREADS_KHR" },
{ GLenum::GL_MAX_SHADER_STORAGE_BLOCK_SIZE, "GL_MAX_SHADER_STORAGE_BLOCK_SIZE" },
{ GLenum::GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS" },
{ GLenum::GL_MAX_SHININESS_NV, "GL_MAX_SHININESS_NV" },
{ GLenum::GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD, "GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD" },
{ GLenum::GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB, "GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB" },
{ GLenum::GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS, "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS" },
{ GLenum::GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB, "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB" },
{ GLenum::GL_MAX_SPARSE_TEXTURE_SIZE_AMD, "GL_MAX_SPARSE_TEXTURE_SIZE_AMD" },
{ GLenum::GL_MAX_SPARSE_TEXTURE_SIZE_ARB, "GL_MAX_SPARSE_TEXTURE_SIZE_ARB" },
{ GLenum::GL_MAX_SPOT_EXPONENT_NV, "GL_MAX_SPOT_EXPONENT_NV" },
{ GLenum::GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV, "GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV" },
{ GLenum::GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS, "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS" },
{ GLenum::GL_MAX_SUBROUTINES, "GL_MAX_SUBROUTINES" },
{ GLenum::GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV, "GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV" },
{ GLenum::GL_MAX_TASK_ATOMIC_COUNTERS_NV, "GL_MAX_TASK_ATOMIC_COUNTERS_NV" },
{ GLenum::GL_MAX_TASK_IMAGE_UNIFORMS_NV, "GL_MAX_TASK_IMAGE_UNIFORMS_NV" },
{ GLenum::GL_MAX_TASK_OUTPUT_COUNT_NV, "GL_MAX_TASK_OUTPUT_COUNT_NV" },
{ GLenum::GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV, "GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV" },
{ GLenum::GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV, "GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV" },
{ GLenum::GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV, "GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV" },
{ GLenum::GL_MAX_TASK_UNIFORM_BLOCKS_NV, "GL_MAX_TASK_UNIFORM_BLOCKS_NV" },
{ GLenum::GL_MAX_TASK_UNIFORM_COMPONENTS_NV, "GL_MAX_TASK_UNIFORM_COMPONENTS_NV" },
{ GLenum::GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV, "GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV" },
{ GLenum::GL_MAX_TASK_WORK_GROUP_SIZE_NV, "GL_MAX_TASK_WORK_GROUP_SIZE_NV" },
{ GLenum::GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS, "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_TESS_CONTROL_INPUT_COMPONENTS, "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS" },
{ GLenum::GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS, "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS, "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS, "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS, "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS, "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS, "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS, "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS, "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS" },
{ GLenum::GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS, "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS, "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS, "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS, "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS, "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_TESS_GEN_LEVEL, "GL_MAX_TESS_GEN_LEVEL" },
{ GLenum::GL_MAX_TESS_PATCH_COMPONENTS, "GL_MAX_TESS_PATCH_COMPONENTS" },
{ GLenum::GL_MAX_TEXTURE_BUFFER_SIZE, "GL_MAX_TEXTURE_BUFFER_SIZE" },
{ GLenum::GL_MAX_TEXTURE_BUFFER_SIZE_ARB, "GL_MAX_TEXTURE_BUFFER_SIZE_ARB" },
{ GLenum::GL_MAX_TEXTURE_BUFFER_SIZE_EXT, "GL_MAX_TEXTURE_BUFFER_SIZE_EXT" },
{ GLenum::GL_MAX_TEXTURE_COORDS, "GL_MAX_TEXTURE_COORDS" },
{ GLenum::GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
{ GLenum::GL_MAX_TEXTURE_COORDS_NV, "GL_MAX_TEXTURE_COORDS_NV" },
{ GLenum::GL_MAX_TEXTURE_IMAGE_UNITS, "GL_MAX_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
{ GLenum::GL_MAX_TEXTURE_IMAGE_UNITS_NV, "GL_MAX_TEXTURE_IMAGE_UNITS_NV" },
{ GLenum::GL_MAX_TEXTURE_LOD_BIAS, "GL_MAX_TEXTURE_LOD_BIAS" },
{ GLenum::GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT" },
{ GLenum::GL_MAX_TEXTURE_MAX_ANISOTROPY, "GL_MAX_TEXTURE_MAX_ANISOTROPY" },
{ GLenum::GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT" },
{ GLenum::GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE" },
{ GLenum::GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH" },
{ GLenum::GL_MAX_TEXTURE_UNITS, "GL_MAX_TEXTURE_UNITS" },
{ GLenum::GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB" },
{ GLenum::GL_MAX_TRACK_MATRICES_NV, "GL_MAX_TRACK_MATRICES_NV" },
{ GLenum::GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV, "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT" },
{ GLenum::GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV" },
{ GLenum::GL_MAX_UNIFORM_BLOCK_SIZE, "GL_MAX_UNIFORM_BLOCK_SIZE" },
{ GLenum::GL_MAX_UNIFORM_BUFFER_BINDINGS, "GL_MAX_UNIFORM_BUFFER_BINDINGS" },
{ GLenum::GL_MAX_UNIFORM_LOCATIONS, "GL_MAX_UNIFORM_LOCATIONS" },
{ GLenum::GL_MAX_VARYING_COMPONENTS, "GL_MAX_VARYING_COMPONENTS" },
{ GLenum::GL_MAX_VARYING_COMPONENTS_EXT, "GL_MAX_VARYING_COMPONENTS_EXT" },
{ GLenum::GL_MAX_VARYING_FLOATS, "GL_MAX_VARYING_FLOATS" },
{ GLenum::GL_MAX_VARYING_FLOATS_ARB, "GL_MAX_VARYING_FLOATS_ARB" },
{ GLenum::GL_MAX_VARYING_VECTORS, "GL_MAX_VARYING_VECTORS" },
{ GLenum::GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV, "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV" },
{ GLenum::GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS, "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS" },
{ GLenum::GL_MAX_VERTEX_ATOMIC_COUNTERS, "GL_MAX_VERTEX_ATOMIC_COUNTERS" },
{ GLenum::GL_MAX_VERTEX_ATTRIB_BINDINGS, "GL_MAX_VERTEX_ATTRIB_BINDINGS" },
{ GLenum::GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET" },
{ GLenum::GL_MAX_VERTEX_ATTRIB_STRIDE, "GL_MAX_VERTEX_ATTRIB_STRIDE" },
{ GLenum::GL_MAX_VERTEX_ATTRIBS, "GL_MAX_VERTEX_ATTRIBS" },
{ GLenum::GL_MAX_VERTEX_ATTRIBS_ARB, "GL_MAX_VERTEX_ATTRIBS_ARB" },
{ GLenum::GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT, "GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT" },
{ GLenum::GL_MAX_VERTEX_HINT_PGI, "GL_MAX_VERTEX_HINT_PGI" },
{ GLenum::GL_MAX_VERTEX_IMAGE_UNIFORMS, "GL_MAX_VERTEX_IMAGE_UNIFORMS" },
{ GLenum::GL_MAX_VERTEX_OUTPUT_COMPONENTS, "GL_MAX_VERTEX_OUTPUT_COMPONENTS" },
{ GLenum::GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT, "GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT" },
{ GLenum::GL_MAX_VERTEX_SHADER_INVARIANTS_EXT, "GL_MAX_VERTEX_SHADER_INVARIANTS_EXT" },
{ GLenum::GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, "GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT" },
{ GLenum::GL_MAX_VERTEX_SHADER_LOCALS_EXT, "GL_MAX_VERTEX_SHADER_LOCALS_EXT" },
{ GLenum::GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS" },
{ GLenum::GL_MAX_VERTEX_SHADER_VARIANTS_EXT, "GL_MAX_VERTEX_SHADER_VARIANTS_EXT" },
{ GLenum::GL_MAX_VERTEX_STREAMS, "GL_MAX_VERTEX_STREAMS" },
{ GLenum::GL_MAX_VERTEX_STREAMS_ATI, "GL_MAX_VERTEX_STREAMS_ATI" },
{ GLenum::GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS" },
{ GLenum::GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" },
{ GLenum::GL_MAX_VERTEX_UNIFORM_BLOCKS, "GL_MAX_VERTEX_UNIFORM_BLOCKS" },
{ GLenum::GL_MAX_VERTEX_UNIFORM_COMPONENTS, "GL_MAX_VERTEX_UNIFORM_COMPONENTS" },
{ GLenum::GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB" },
{ GLenum::GL_MAX_VERTEX_UNIFORM_VECTORS, "GL_MAX_VERTEX_UNIFORM_VECTORS" },
{ GLenum::GL_MAX_VERTEX_UNITS_ARB, "GL_MAX_VERTEX_UNITS_ARB" },
{ GLenum::GL_MAX_VERTEX_VARYING_COMPONENTS_ARB, "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB" },
{ GLenum::GL_MAX_VERTEX_VARYING_COMPONENTS_EXT, "GL_MAX_VERTEX_VARYING_COMPONENTS_EXT" },
{ GLenum::GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS" },
{ GLenum::GL_MAX_VIEWPORTS, "GL_MAX_VIEWPORTS" },
{ GLenum::GL_MAX_VIEWS_OVR, "GL_MAX_VIEWS_OVR" },
{ GLenum::GL_MAX_WIDTH, "GL_MAX_WIDTH" },
{ GLenum::GL_MAX_WINDOW_RECTANGLES_EXT, "GL_MAX_WINDOW_RECTANGLES_EXT" },
{ GLenum::GL_MEDIUM_FLOAT, "GL_MEDIUM_FLOAT" },
{ GLenum::GL_MEDIUM_INT, "GL_MEDIUM_INT" },
{ GLenum::GL_MEMORY_ATTACHABLE_ALIGNMENT_NV, "GL_MEMORY_ATTACHABLE_ALIGNMENT_NV" },
{ GLenum::GL_MEMORY_ATTACHABLE_NV, "GL_MEMORY_ATTACHABLE_NV" },
{ GLenum::GL_MEMORY_ATTACHABLE_SIZE_NV, "GL_MEMORY_ATTACHABLE_SIZE_NV" },
{ GLenum::GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV, "GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV" },
{ GLenum::GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV, "GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV" },
{ GLenum::GL_MESH_OUTPUT_TYPE_NV, "GL_MESH_OUTPUT_TYPE_NV" },
{ GLenum::GL_MESH_PRIMITIVES_OUT_NV, "GL_MESH_PRIMITIVES_OUT_NV" },
{ GLenum::GL_MESH_SHADER_NV, "GL_MESH_SHADER_NV" },
{ GLenum::GL_MESH_SUBROUTINE_NV, "GL_MESH_SUBROUTINE_NV" },
{ GLenum::GL_MESH_SUBROUTINE_UNIFORM_NV, "GL_MESH_SUBROUTINE_UNIFORM_NV" },
{ GLenum::GL_MESH_VERTICES_OUT_NV, "GL_MESH_VERTICES_OUT_NV" },
{ GLenum::GL_MESH_WORK_GROUP_SIZE_NV, "GL_MESH_WORK_GROUP_SIZE_NV" },
{ GLenum::GL_MIN, "GL_MIN" },
{ GLenum::GL_MIN_EXT, "GL_MIN_EXT" },
{ GLenum::GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET" },
{ GLenum::GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV, "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV" },
{ GLenum::GL_MIN_LOD_WARNING_AMD, "GL_MIN_LOD_WARNING_AMD" },
{ GLenum::GL_MIN_MAP_BUFFER_ALIGNMENT, "GL_MIN_MAP_BUFFER_ALIGNMENT" },
{ GLenum::GL_MIN_PROGRAM_TEXEL_OFFSET, "GL_MIN_PROGRAM_TEXEL_OFFSET" },
{ GLenum::GL_MIN_PROGRAM_TEXEL_OFFSET_EXT, "GL_MIN_PROGRAM_TEXEL_OFFSET_EXT" },
{ GLenum::GL_MIN_PROGRAM_TEXEL_OFFSET_NV, "GL_MIN_PROGRAM_TEXEL_OFFSET_NV" },
{ GLenum::GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET" },
{ GLenum::GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB, "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB" },
{ GLenum::GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV, "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV" },
{ GLenum::GL_MIN_SAMPLE_SHADING_VALUE, "GL_MIN_SAMPLE_SHADING_VALUE" },
{ GLenum::GL_MIN_SAMPLE_SHADING_VALUE_ARB, "GL_MIN_SAMPLE_SHADING_VALUE_ARB" },
{ GLenum::GL_MIN_SPARSE_LEVEL_AMD, "GL_MIN_SPARSE_LEVEL_AMD" },
{ GLenum::GL_MINMAX, "GL_MINMAX" },
{ GLenum::GL_MINMAX_EXT, "GL_MINMAX_EXT" },
{ GLenum::GL_MINMAX_FORMAT, "GL_MINMAX_FORMAT" },
{ GLenum::GL_MINMAX_FORMAT_EXT, "GL_MINMAX_FORMAT_EXT" },
{ GLenum::GL_MINMAX_SINK, "GL_MINMAX_SINK" },
{ GLenum::GL_MINMAX_SINK_EXT, "GL_MINMAX_SINK_EXT" },
{ GLenum::GL_MINOR_VERSION, "GL_MINOR_VERSION" },
{ GLenum::GL_MINUS_CLAMPED_NV, "GL_MINUS_CLAMPED_NV" },
{ GLenum::GL_MINUS_NV, "GL_MINUS_NV" },
{ GLenum::GL_MIPMAP, "GL_MIPMAP" },
{ GLenum::GL_MIRROR_CLAMP_ATI, "GL_MIRROR_CLAMP_ATI" },
{ GLenum::GL_MIRROR_CLAMP_EXT, "GL_MIRROR_CLAMP_EXT" },
{ GLenum::GL_MIRROR_CLAMP_TO_BORDER_EXT, "GL_MIRROR_CLAMP_TO_BORDER_EXT" },
{ GLenum::GL_MIRROR_CLAMP_TO_EDGE, "GL_MIRROR_CLAMP_TO_EDGE" },
{ GLenum::GL_MIRROR_CLAMP_TO_EDGE_ATI, "GL_MIRROR_CLAMP_TO_EDGE_ATI" },
{ GLenum::GL_MIRROR_CLAMP_TO_EDGE_EXT, "GL_MIRROR_CLAMP_TO_EDGE_EXT" },
{ GLenum::GL_MIRRORED_REPEAT, "GL_MIRRORED_REPEAT" },
{ GLenum::GL_MIRRORED_REPEAT_ARB, "GL_MIRRORED_REPEAT_ARB" },
{ GLenum::GL_MIRRORED_REPEAT_IBM, "GL_MIRRORED_REPEAT_IBM" },
{ GLenum::GL_MITER_REVERT_NV, "GL_MITER_REVERT_NV" },
{ GLenum::GL_MITER_TRUNCATE_NV, "GL_MITER_TRUNCATE_NV" },
{ GLenum::GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV, "GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV" },
{ GLenum::GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV, "GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV" },
{ GLenum::GL_MODELVIEW, "GL_MODELVIEW" },
{ GLenum::GL_MODELVIEW0_ARB, "GL_MODELVIEW0_ARB" },
{ GLenum::GL_MODELVIEW0_EXT, "GL_MODELVIEW0_EXT" },
{ GLenum::GL_MODELVIEW0_MATRIX_EXT, "GL_MODELVIEW0_MATRIX_EXT" },
{ GLenum::GL_MODELVIEW0_STACK_DEPTH_EXT, "GL_MODELVIEW0_STACK_DEPTH_EXT" },
{ GLenum::GL_MODELVIEW10_ARB, "GL_MODELVIEW10_ARB" },
{ GLenum::GL_MODELVIEW11_ARB, "GL_MODELVIEW11_ARB" },
{ GLenum::GL_MODELVIEW12_ARB, "GL_MODELVIEW12_ARB" },
{ GLenum::GL_MODELVIEW13_ARB, "GL_MODELVIEW13_ARB" },
{ GLenum::GL_MODELVIEW14_ARB, "GL_MODELVIEW14_ARB" },
{ GLenum::GL_MODELVIEW15_ARB, "GL_MODELVIEW15_ARB" },
{ GLenum::GL_MODELVIEW16_ARB, "GL_MODELVIEW16_ARB" },
{ GLenum::GL_MODELVIEW17_ARB, "GL_MODELVIEW17_ARB" },
{ GLenum::GL_MODELVIEW18_ARB, "GL_MODELVIEW18_ARB" },
{ GLenum::GL_MODELVIEW19_ARB, "GL_MODELVIEW19_ARB" },
{ GLenum::GL_MODELVIEW1_ARB, "GL_MODELVIEW1_ARB" },
{ GLenum::GL_MODELVIEW1_EXT, "GL_MODELVIEW1_EXT" },
{ GLenum::GL_MODELVIEW1_MATRIX_EXT, "GL_MODELVIEW1_MATRIX_EXT" },
{ GLenum::GL_MODELVIEW1_STACK_DEPTH_EXT, "GL_MODELVIEW1_STACK_DEPTH_EXT" },
{ GLenum::GL_MODELVIEW20_ARB, "GL_MODELVIEW20_ARB" },
{ GLenum::GL_MODELVIEW21_ARB, "GL_MODELVIEW21_ARB" },
{ GLenum::GL_MODELVIEW22_ARB, "GL_MODELVIEW22_ARB" },
{ GLenum::GL_MODELVIEW23_ARB, "GL_MODELVIEW23_ARB" },
{ GLenum::GL_MODELVIEW24_ARB, "GL_MODELVIEW24_ARB" },
{ GLenum::GL_MODELVIEW25_ARB, "GL_MODELVIEW25_ARB" },
{ GLenum::GL_MODELVIEW26_ARB, "GL_MODELVIEW26_ARB" },
{ GLenum::GL_MODELVIEW27_ARB, "GL_MODELVIEW27_ARB" },
{ GLenum::GL_MODELVIEW28_ARB, "GL_MODELVIEW28_ARB" },
{ GLenum::GL_MODELVIEW29_ARB, "GL_MODELVIEW29_ARB" },
{ GLenum::GL_MODELVIEW2_ARB, "GL_MODELVIEW2_ARB" },
{ GLenum::GL_MODELVIEW30_ARB, "GL_MODELVIEW30_ARB" },
{ GLenum::GL_MODELVIEW31_ARB, "GL_MODELVIEW31_ARB" },
{ GLenum::GL_MODELVIEW3_ARB, "GL_MODELVIEW3_ARB" },
{ GLenum::GL_MODELVIEW4_ARB, "GL_MODELVIEW4_ARB" },
{ GLenum::GL_MODELVIEW5_ARB, "GL_MODELVIEW5_ARB" },
{ GLenum::GL_MODELVIEW6_ARB, "GL_MODELVIEW6_ARB" },
{ GLenum::GL_MODELVIEW7_ARB, "GL_MODELVIEW7_ARB" },
{ GLenum::GL_MODELVIEW8_ARB, "GL_MODELVIEW8_ARB" },
{ GLenum::GL_MODELVIEW9_ARB, "GL_MODELVIEW9_ARB" },
{ GLenum::GL_MODELVIEW_MATRIX, "GL_MODELVIEW_MATRIX" },
{ GLenum::GL_MODELVIEW_PROJECTION_NV, "GL_MODELVIEW_PROJECTION_NV" },
{ GLenum::GL_MODELVIEW_STACK_DEPTH, "GL_MODELVIEW_STACK_DEPTH" },
{ GLenum::GL_MODULATE, "GL_MODULATE" },
{ GLenum::GL_MODULATE_ADD_ATI, "GL_MODULATE_ADD_ATI" },
{ GLenum::GL_MODULATE_SIGNED_ADD_ATI, "GL_MODULATE_SIGNED_ADD_ATI" },
{ GLenum::GL_MODULATE_SUBTRACT_ATI, "GL_MODULATE_SUBTRACT_ATI" },
{ GLenum::GL_MOV_ATI, "GL_MOV_ATI" },
{ GLenum::GL_MOVE_TO_CONTINUES_NV, "GL_MOVE_TO_CONTINUES_NV" },
{ GLenum::GL_MOVE_TO_NV, "GL_MOVE_TO_NV" },
{ GLenum::GL_MOVE_TO_RESETS_NV, "GL_MOVE_TO_RESETS_NV" },
{ GLenum::GL_MUL_ATI, "GL_MUL_ATI" },
{ GLenum::GL_MULT, "GL_MULT" },
{ GLenum::GL_MULTICAST_GPUS_NV, "GL_MULTICAST_GPUS_NV" },
{ GLenum::GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV, "GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV" },
{ GLenum::GL_MULTIPLY_KHR, "GL_MULTIPLY_KHR" },
{ GLenum::GL_MULTIPLY_NV, "GL_MULTIPLY_NV" },
{ GLenum::GL_MULTISAMPLE, "GL_MULTISAMPLE" },
{ GLenum::GL_MULTISAMPLE_3DFX, "GL_MULTISAMPLE_3DFX" },
{ GLenum::GL_MULTISAMPLE_ARB, "GL_MULTISAMPLE_ARB" },
{ GLenum::GL_MULTISAMPLE_COVERAGE_MODES_NV, "GL_MULTISAMPLE_COVERAGE_MODES_NV" },
{ GLenum::GL_MULTISAMPLE_EXT, "GL_MULTISAMPLE_EXT" },
{ GLenum::GL_MULTISAMPLE_FILTER_HINT_NV, "GL_MULTISAMPLE_FILTER_HINT_NV" },
{ GLenum::GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB, "GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB" },
{ GLenum::GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB, "GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB" },
{ GLenum::GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT, "GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT" },
{ GLenum::GL_MULTISAMPLE_SGIS, "GL_MULTISAMPLE_SGIS" },
{ GLenum::GL_MULTISAMPLES_NV, "GL_MULTISAMPLES_NV" },
{ GLenum::GL_MVP_MATRIX_EXT, "GL_MVP_MATRIX_EXT" },
{ GLenum::GL_N3F_V3F, "GL_N3F_V3F" },
{ GLenum::GL_NAME_LENGTH, "GL_NAME_LENGTH" },
{ GLenum::GL_NAME_STACK_DEPTH, "GL_NAME_STACK_DEPTH" },
{ GLenum::GL_NAMED_STRING_LENGTH_ARB, "GL_NAMED_STRING_LENGTH_ARB" },
{ GLenum::GL_NAMED_STRING_TYPE_ARB, "GL_NAMED_STRING_TYPE_ARB" },
{ GLenum::GL_NAND, "GL_NAND" },
{ GLenum::GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI, "GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI" },
{ GLenum::GL_NATIVE_GRAPHICS_END_HINT_PGI, "GL_NATIVE_GRAPHICS_END_HINT_PGI" },
{ GLenum::GL_NATIVE_GRAPHICS_HANDLE_PGI, "GL_NATIVE_GRAPHICS_HANDLE_PGI" },
{ GLenum::GL_NEAREST, "GL_NEAREST" },
{ GLenum::GL_NEAREST_CLIPMAP_LINEAR_SGIX, "GL_NEAREST_CLIPMAP_LINEAR_SGIX" },
{ GLenum::GL_NEAREST_CLIPMAP_NEAREST_SGIX, "GL_NEAREST_CLIPMAP_NEAREST_SGIX" },
{ GLenum::GL_NEAREST_MIPMAP_LINEAR, "GL_NEAREST_MIPMAP_LINEAR" },
{ GLenum::GL_NEAREST_MIPMAP_NEAREST, "GL_NEAREST_MIPMAP_NEAREST" },
{ GLenum::GL_NEGATIVE_ONE_EXT, "GL_NEGATIVE_ONE_EXT" },
{ GLenum::GL_NEGATIVE_ONE_TO_ONE, "GL_NEGATIVE_ONE_TO_ONE" },
{ GLenum::GL_NEGATIVE_W_EXT, "GL_NEGATIVE_W_EXT" },
{ GLenum::GL_NEGATIVE_X_EXT, "GL_NEGATIVE_X_EXT" },
{ GLenum::GL_NEGATIVE_Y_EXT, "GL_NEGATIVE_Y_EXT" },
{ GLenum::GL_NEGATIVE_Z_EXT, "GL_NEGATIVE_Z_EXT" },
{ GLenum::GL_NEVER, "GL_NEVER" },
{ GLenum::GL_NEXT_BUFFER_NV, "GL_NEXT_BUFFER_NV" },
{ GLenum::GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV, "GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV" },
{ GLenum::GL_NICEST, "GL_NICEST" },
{ GLenum::GL_NO_ERROR, "GL_NO_ERROR" },
{ GLenum::GL_NO_RESET_NOTIFICATION, "GL_NO_RESET_NOTIFICATION" },
{ GLenum::GL_NO_RESET_NOTIFICATION_ARB, "GL_NO_RESET_NOTIFICATION_ARB" },
{ GLenum::GL_NO_RESET_NOTIFICATION_KHR, "GL_NO_RESET_NOTIFICATION_KHR" },
{ GLenum::GL_NONE, "GL_NONE" },
{ GLenum::GL_NOOP, "GL_NOOP" },
{ GLenum::GL_NOP_COMMAND_NV, "GL_NOP_COMMAND_NV" },
{ GLenum::GL_NOR, "GL_NOR" },
{ GLenum::GL_NORMAL_ARRAY, "GL_NORMAL_ARRAY" },
{ GLenum::GL_NORMAL_ARRAY_ADDRESS_NV, "GL_NORMAL_ARRAY_ADDRESS_NV" },
{ GLenum::GL_NORMAL_ARRAY_BUFFER_BINDING, "GL_NORMAL_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_NORMAL_ARRAY_COUNT_EXT, "GL_NORMAL_ARRAY_COUNT_EXT" },
{ GLenum::GL_NORMAL_ARRAY_EXT, "GL_NORMAL_ARRAY_EXT" },
{ GLenum::GL_NORMAL_ARRAY_LENGTH_NV, "GL_NORMAL_ARRAY_LENGTH_NV" },
{ GLenum::GL_NORMAL_ARRAY_LIST_IBM, "GL_NORMAL_ARRAY_LIST_IBM" },
{ GLenum::GL_NORMAL_ARRAY_LIST_STRIDE_IBM, "GL_NORMAL_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL, "GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL" },
{ GLenum::GL_NORMAL_ARRAY_POINTER, "GL_NORMAL_ARRAY_POINTER" },
{ GLenum::GL_NORMAL_ARRAY_POINTER_EXT, "GL_NORMAL_ARRAY_POINTER_EXT" },
{ GLenum::GL_NORMAL_ARRAY_STRIDE, "GL_NORMAL_ARRAY_STRIDE" },
{ GLenum::GL_NORMAL_ARRAY_STRIDE_EXT, "GL_NORMAL_ARRAY_STRIDE_EXT" },
{ GLenum::GL_NORMAL_ARRAY_TYPE, "GL_NORMAL_ARRAY_TYPE" },
{ GLenum::GL_NORMAL_ARRAY_TYPE_EXT, "GL_NORMAL_ARRAY_TYPE_EXT" },
{ GLenum::GL_NORMAL_MAP, "GL_NORMAL_MAP" },
{ GLenum::GL_NORMAL_MAP_ARB, "GL_NORMAL_MAP_ARB" },
{ GLenum::GL_NORMAL_MAP_EXT, "GL_NORMAL_MAP_EXT" },
{ GLenum::GL_NORMAL_MAP_NV, "GL_NORMAL_MAP_NV" },
{ GLenum::GL_NORMALIZE, "GL_NORMALIZE" },
{ GLenum::GL_NORMALIZED_RANGE_EXT, "GL_NORMALIZED_RANGE_EXT" },
{ GLenum::GL_NOTEQUAL, "GL_NOTEQUAL" },
{ GLenum::GL_NUM_ACTIVE_VARIABLES, "GL_NUM_ACTIVE_VARIABLES" },
{ GLenum::GL_NUM_COMPATIBLE_SUBROUTINES, "GL_NUM_COMPATIBLE_SUBROUTINES" },
{ GLenum::GL_NUM_COMPRESSED_TEXTURE_FORMATS, "GL_NUM_COMPRESSED_TEXTURE_FORMATS" },
{ GLenum::GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB" },
{ GLenum::GL_NUM_DEVICE_UUIDS_EXT, "GL_NUM_DEVICE_UUIDS_EXT" },
{ GLenum::GL_NUM_EXTENSIONS, "GL_NUM_EXTENSIONS" },
{ GLenum::GL_NUM_FILL_STREAMS_NV, "GL_NUM_FILL_STREAMS_NV" },
{ GLenum::GL_NUM_FRAGMENT_CONSTANTS_ATI, "GL_NUM_FRAGMENT_CONSTANTS_ATI" },
{ GLenum::GL_NUM_FRAGMENT_REGISTERS_ATI, "GL_NUM_FRAGMENT_REGISTERS_ATI" },
{ GLenum::GL_NUM_GENERAL_COMBINERS_NV, "GL_NUM_GENERAL_COMBINERS_NV" },
{ GLenum::GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI, "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI" },
{ GLenum::GL_NUM_INSTRUCTIONS_PER_PASS_ATI, "GL_NUM_INSTRUCTIONS_PER_PASS_ATI" },
{ GLenum::GL_NUM_INSTRUCTIONS_TOTAL_ATI, "GL_NUM_INSTRUCTIONS_TOTAL_ATI" },
{ GLenum::GL_NUM_LOOPBACK_COMPONENTS_ATI, "GL_NUM_LOOPBACK_COMPONENTS_ATI" },
{ GLenum::GL_NUM_PASSES_ATI, "GL_NUM_PASSES_ATI" },
{ GLenum::GL_NUM_PROGRAM_BINARY_FORMATS, "GL_NUM_PROGRAM_BINARY_FORMATS" },
{ GLenum::GL_NUM_SAMPLE_COUNTS, "GL_NUM_SAMPLE_COUNTS" },
{ GLenum::GL_NUM_SHADER_BINARY_FORMATS, "GL_NUM_SHADER_BINARY_FORMATS" },
{ GLenum::GL_NUM_SHADING_LANGUAGE_VERSIONS, "GL_NUM_SHADING_LANGUAGE_VERSIONS" },
{ GLenum::GL_NUM_SPARSE_LEVELS_ARB, "GL_NUM_SPARSE_LEVELS_ARB" },
{ GLenum::GL_NUM_SPIR_V_EXTENSIONS, "GL_NUM_SPIR_V_EXTENSIONS" },
{ GLenum::GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD, "GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD" },
{ GLenum::GL_NUM_TILING_TYPES_EXT, "GL_NUM_TILING_TYPES_EXT" },
{ GLenum::GL_NUM_VIDEO_CAPTURE_STREAMS_NV, "GL_NUM_VIDEO_CAPTURE_STREAMS_NV" },
{ GLenum::GL_NUM_VIRTUAL_PAGE_SIZES_ARB, "GL_NUM_VIRTUAL_PAGE_SIZES_ARB" },
{ GLenum::GL_NUM_WINDOW_RECTANGLES_EXT, "GL_NUM_WINDOW_RECTANGLES_EXT" },
{ GLenum::GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB, "GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB" },
{ GLenum::GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, "GL_OBJECT_ACTIVE_ATTRIBUTES_ARB" },
{ GLenum::GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB, "GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB" },
{ GLenum::GL_OBJECT_ACTIVE_UNIFORMS_ARB, "GL_OBJECT_ACTIVE_UNIFORMS_ARB" },
{ GLenum::GL_OBJECT_ATTACHED_OBJECTS_ARB, "GL_OBJECT_ATTACHED_OBJECTS_ARB" },
{ GLenum::GL_OBJECT_BUFFER_SIZE_ATI, "GL_OBJECT_BUFFER_SIZE_ATI" },
{ GLenum::GL_OBJECT_BUFFER_USAGE_ATI, "GL_OBJECT_BUFFER_USAGE_ATI" },
{ GLenum::GL_OBJECT_COMPILE_STATUS_ARB, "GL_OBJECT_COMPILE_STATUS_ARB" },
{ GLenum::GL_OBJECT_DELETE_STATUS_ARB, "GL_OBJECT_DELETE_STATUS_ARB" },
{ GLenum::GL_OBJECT_DISTANCE_TO_LINE_SGIS, "GL_OBJECT_DISTANCE_TO_LINE_SGIS" },
{ GLenum::GL_OBJECT_DISTANCE_TO_POINT_SGIS, "GL_OBJECT_DISTANCE_TO_POINT_SGIS" },
{ GLenum::GL_OBJECT_INFO_LOG_LENGTH_ARB, "GL_OBJECT_INFO_LOG_LENGTH_ARB" },
{ GLenum::GL_OBJECT_LINE_SGIS, "GL_OBJECT_LINE_SGIS" },
{ GLenum::GL_OBJECT_LINEAR, "GL_OBJECT_LINEAR" },
{ GLenum::GL_OBJECT_LINEAR_NV, "GL_OBJECT_LINEAR_NV" },
{ GLenum::GL_OBJECT_LINK_STATUS_ARB, "GL_OBJECT_LINK_STATUS_ARB" },
{ GLenum::GL_OBJECT_PLANE, "GL_OBJECT_PLANE" },
{ GLenum::GL_OBJECT_POINT_SGIS, "GL_OBJECT_POINT_SGIS" },
{ GLenum::GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB" },
{ GLenum::GL_OBJECT_SUBTYPE_ARB, "GL_OBJECT_SUBTYPE_ARB" },
{ GLenum::GL_OBJECT_TYPE, "GL_OBJECT_TYPE" },
{ GLenum::GL_OBJECT_TYPE_ARB, "GL_OBJECT_TYPE_ARB" },
{ GLenum::GL_OBJECT_VALIDATE_STATUS_ARB, "GL_OBJECT_VALIDATE_STATUS_ARB" },
{ GLenum::GL_OCCLUSION_QUERY_EVENT_MASK_AMD, "GL_OCCLUSION_QUERY_EVENT_MASK_AMD" },
{ GLenum::GL_OCCLUSION_TEST_HP, "GL_OCCLUSION_TEST_HP" },
{ GLenum::GL_OCCLUSION_TEST_RESULT_HP, "GL_OCCLUSION_TEST_RESULT_HP" },
{ GLenum::GL_OFFSET, "GL_OFFSET" },
{ GLenum::GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV, "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV" },
{ GLenum::GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV, "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_OFFSET_HILO_TEXTURE_2D_NV, "GL_OFFSET_HILO_TEXTURE_2D_NV" },
{ GLenum::GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV, "GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV" },
{ GLenum::GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV" },
{ GLenum::GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV, "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV, "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV" },
{ GLenum::GL_OFFSET_TEXTURE_2D_BIAS_NV, "GL_OFFSET_TEXTURE_2D_BIAS_NV" },
{ GLenum::GL_OFFSET_TEXTURE_2D_MATRIX_NV, "GL_OFFSET_TEXTURE_2D_MATRIX_NV" },
{ GLenum::GL_OFFSET_TEXTURE_2D_NV, "GL_OFFSET_TEXTURE_2D_NV" },
{ GLenum::GL_OFFSET_TEXTURE_2D_SCALE_NV, "GL_OFFSET_TEXTURE_2D_SCALE_NV" },
{ GLenum::GL_OFFSET_TEXTURE_BIAS_NV, "GL_OFFSET_TEXTURE_BIAS_NV" },
{ GLenum::GL_OFFSET_TEXTURE_MATRIX_NV, "GL_OFFSET_TEXTURE_MATRIX_NV" },
{ GLenum::GL_OFFSET_TEXTURE_RECTANGLE_NV, "GL_OFFSET_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV, "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV" },
{ GLenum::GL_OFFSET_TEXTURE_SCALE_NV, "GL_OFFSET_TEXTURE_SCALE_NV" },
{ GLenum::GL_ONE, "GL_ONE" },
{ GLenum::GL_ONE_EXT, "GL_ONE_EXT" },
{ GLenum::GL_ONE_MINUS_CONSTANT_ALPHA, "GL_ONE_MINUS_CONSTANT_ALPHA" },
{ GLenum::GL_ONE_MINUS_CONSTANT_ALPHA_EXT, "GL_ONE_MINUS_CONSTANT_ALPHA_EXT" },
{ GLenum::GL_ONE_MINUS_CONSTANT_COLOR, "GL_ONE_MINUS_CONSTANT_COLOR" },
{ GLenum::GL_ONE_MINUS_CONSTANT_COLOR_EXT, "GL_ONE_MINUS_CONSTANT_COLOR_EXT" },
{ GLenum::GL_ONE_MINUS_DST_ALPHA, "GL_ONE_MINUS_DST_ALPHA" },
{ GLenum::GL_ONE_MINUS_DST_COLOR, "GL_ONE_MINUS_DST_COLOR" },
{ GLenum::GL_ONE_MINUS_SRC1_ALPHA, "GL_ONE_MINUS_SRC1_ALPHA" },
{ GLenum::GL_ONE_MINUS_SRC1_COLOR, "GL_ONE_MINUS_SRC1_COLOR" },
{ GLenum::GL_ONE_MINUS_SRC_ALPHA, "GL_ONE_MINUS_SRC_ALPHA" },
{ GLenum::GL_ONE_MINUS_SRC_COLOR, "GL_ONE_MINUS_SRC_COLOR" },
{ GLenum::GL_OP_ADD_EXT, "GL_OP_ADD_EXT" },
{ GLenum::GL_OP_CLAMP_EXT, "GL_OP_CLAMP_EXT" },
{ GLenum::GL_OP_CROSS_PRODUCT_EXT, "GL_OP_CROSS_PRODUCT_EXT" },
{ GLenum::GL_OP_DOT3_EXT, "GL_OP_DOT3_EXT" },
{ GLenum::GL_OP_DOT4_EXT, "GL_OP_DOT4_EXT" },
{ GLenum::GL_OP_EXP_BASE_2_EXT, "GL_OP_EXP_BASE_2_EXT" },
{ GLenum::GL_OP_FLOOR_EXT, "GL_OP_FLOOR_EXT" },
{ GLenum::GL_OP_FRAC_EXT, "GL_OP_FRAC_EXT" },
{ GLenum::GL_OP_INDEX_EXT, "GL_OP_INDEX_EXT" },
{ GLenum::GL_OP_LOG_BASE_2_EXT, "GL_OP_LOG_BASE_2_EXT" },
{ GLenum::GL_OP_MADD_EXT, "GL_OP_MADD_EXT" },
{ GLenum::GL_OP_MAX_EXT, "GL_OP_MAX_EXT" },
{ GLenum::GL_OP_MIN_EXT, "GL_OP_MIN_EXT" },
{ GLenum::GL_OP_MOV_EXT, "GL_OP_MOV_EXT" },
{ GLenum::GL_OP_MUL_EXT, "GL_OP_MUL_EXT" },
{ GLenum::GL_OP_MULTIPLY_MATRIX_EXT, "GL_OP_MULTIPLY_MATRIX_EXT" },
{ GLenum::GL_OP_NEGATE_EXT, "GL_OP_NEGATE_EXT" },
{ GLenum::GL_OP_POWER_EXT, "GL_OP_POWER_EXT" },
{ GLenum::GL_OP_RECIP_EXT, "GL_OP_RECIP_EXT" },
{ GLenum::GL_OP_RECIP_SQRT_EXT, "GL_OP_RECIP_SQRT_EXT" },
{ GLenum::GL_OP_ROUND_EXT, "GL_OP_ROUND_EXT" },
{ GLenum::GL_OP_SET_GE_EXT, "GL_OP_SET_GE_EXT" },
{ GLenum::GL_OP_SET_LT_EXT, "GL_OP_SET_LT_EXT" },
{ GLenum::GL_OP_SUB_EXT, "GL_OP_SUB_EXT" },
{ GLenum::GL_OPERAND0_ALPHA, "GL_OPERAND0_ALPHA" },
{ GLenum::GL_OPERAND0_ALPHA_ARB, "GL_OPERAND0_ALPHA_ARB" },
{ GLenum::GL_OPERAND0_ALPHA_EXT, "GL_OPERAND0_ALPHA_EXT" },
{ GLenum::GL_OPERAND0_RGB, "GL_OPERAND0_RGB" },
{ GLenum::GL_OPERAND0_RGB_ARB, "GL_OPERAND0_RGB_ARB" },
{ GLenum::GL_OPERAND0_RGB_EXT, "GL_OPERAND0_RGB_EXT" },
{ GLenum::GL_OPERAND1_ALPHA, "GL_OPERAND1_ALPHA" },
{ GLenum::GL_OPERAND1_ALPHA_ARB, "GL_OPERAND1_ALPHA_ARB" },
{ GLenum::GL_OPERAND1_ALPHA_EXT, "GL_OPERAND1_ALPHA_EXT" },
{ GLenum::GL_OPERAND1_RGB, "GL_OPERAND1_RGB" },
{ GLenum::GL_OPERAND1_RGB_ARB, "GL_OPERAND1_RGB_ARB" },
{ GLenum::GL_OPERAND1_RGB_EXT, "GL_OPERAND1_RGB_EXT" },
{ GLenum::GL_OPERAND2_ALPHA, "GL_OPERAND2_ALPHA" },
{ GLenum::GL_OPERAND2_ALPHA_ARB, "GL_OPERAND2_ALPHA_ARB" },
{ GLenum::GL_OPERAND2_ALPHA_EXT, "GL_OPERAND2_ALPHA_EXT" },
{ GLenum::GL_OPERAND2_RGB, "GL_OPERAND2_RGB" },
{ GLenum::GL_OPERAND2_RGB_ARB, "GL_OPERAND2_RGB_ARB" },
{ GLenum::GL_OPERAND2_RGB_EXT, "GL_OPERAND2_RGB_EXT" },
{ GLenum::GL_OPERAND3_ALPHA_NV, "GL_OPERAND3_ALPHA_NV" },
{ GLenum::GL_OPERAND3_RGB_NV, "GL_OPERAND3_RGB_NV" },
{ GLenum::GL_OPTIMAL_TILING_EXT, "GL_OPTIMAL_TILING_EXT" },
{ GLenum::GL_OR, "GL_OR" },
{ GLenum::GL_OR_INVERTED, "GL_OR_INVERTED" },
{ GLenum::GL_OR_REVERSE, "GL_OR_REVERSE" },
{ GLenum::GL_ORDER, "GL_ORDER" },
{ GLenum::GL_OUT_OF_MEMORY, "GL_OUT_OF_MEMORY" },
{ GLenum::GL_OUTPUT_COLOR0_EXT, "GL_OUTPUT_COLOR0_EXT" },
{ GLenum::GL_OUTPUT_COLOR1_EXT, "GL_OUTPUT_COLOR1_EXT" },
{ GLenum::GL_OUTPUT_FOG_EXT, "GL_OUTPUT_FOG_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD0_EXT, "GL_OUTPUT_TEXTURE_COORD0_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD10_EXT, "GL_OUTPUT_TEXTURE_COORD10_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD11_EXT, "GL_OUTPUT_TEXTURE_COORD11_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD12_EXT, "GL_OUTPUT_TEXTURE_COORD12_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD13_EXT, "GL_OUTPUT_TEXTURE_COORD13_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD14_EXT, "GL_OUTPUT_TEXTURE_COORD14_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD15_EXT, "GL_OUTPUT_TEXTURE_COORD15_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD16_EXT, "GL_OUTPUT_TEXTURE_COORD16_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD17_EXT, "GL_OUTPUT_TEXTURE_COORD17_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD18_EXT, "GL_OUTPUT_TEXTURE_COORD18_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD19_EXT, "GL_OUTPUT_TEXTURE_COORD19_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD1_EXT, "GL_OUTPUT_TEXTURE_COORD1_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD20_EXT, "GL_OUTPUT_TEXTURE_COORD20_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD21_EXT, "GL_OUTPUT_TEXTURE_COORD21_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD22_EXT, "GL_OUTPUT_TEXTURE_COORD22_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD23_EXT, "GL_OUTPUT_TEXTURE_COORD23_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD24_EXT, "GL_OUTPUT_TEXTURE_COORD24_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD25_EXT, "GL_OUTPUT_TEXTURE_COORD25_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD26_EXT, "GL_OUTPUT_TEXTURE_COORD26_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD27_EXT, "GL_OUTPUT_TEXTURE_COORD27_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD28_EXT, "GL_OUTPUT_TEXTURE_COORD28_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD29_EXT, "GL_OUTPUT_TEXTURE_COORD29_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD2_EXT, "GL_OUTPUT_TEXTURE_COORD2_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD30_EXT, "GL_OUTPUT_TEXTURE_COORD30_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD31_EXT, "GL_OUTPUT_TEXTURE_COORD31_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD3_EXT, "GL_OUTPUT_TEXTURE_COORD3_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD4_EXT, "GL_OUTPUT_TEXTURE_COORD4_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD5_EXT, "GL_OUTPUT_TEXTURE_COORD5_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD6_EXT, "GL_OUTPUT_TEXTURE_COORD6_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD7_EXT, "GL_OUTPUT_TEXTURE_COORD7_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD8_EXT, "GL_OUTPUT_TEXTURE_COORD8_EXT" },
{ GLenum::GL_OUTPUT_TEXTURE_COORD9_EXT, "GL_OUTPUT_TEXTURE_COORD9_EXT" },
{ GLenum::GL_OUTPUT_VERTEX_EXT, "GL_OUTPUT_VERTEX_EXT" },
{ GLenum::GL_OVERLAY_KHR, "GL_OVERLAY_KHR" },
{ GLenum::GL_OVERLAY_NV, "GL_OVERLAY_NV" },
{ GLenum::GL_PACK_ALIGNMENT, "GL_PACK_ALIGNMENT" },
{ GLenum::GL_PACK_CMYK_HINT_EXT, "GL_PACK_CMYK_HINT_EXT" },
{ GLenum::GL_PACK_COMPRESSED_BLOCK_DEPTH, "GL_PACK_COMPRESSED_BLOCK_DEPTH" },
{ GLenum::GL_PACK_COMPRESSED_BLOCK_HEIGHT, "GL_PACK_COMPRESSED_BLOCK_HEIGHT" },
{ GLenum::GL_PACK_COMPRESSED_BLOCK_SIZE, "GL_PACK_COMPRESSED_BLOCK_SIZE" },
{ GLenum::GL_PACK_COMPRESSED_BLOCK_WIDTH, "GL_PACK_COMPRESSED_BLOCK_WIDTH" },
{ GLenum::GL_PACK_IMAGE_DEPTH_SGIS, "GL_PACK_IMAGE_DEPTH_SGIS" },
{ GLenum::GL_PACK_IMAGE_HEIGHT, "GL_PACK_IMAGE_HEIGHT" },
{ GLenum::GL_PACK_IMAGE_HEIGHT_EXT, "GL_PACK_IMAGE_HEIGHT_EXT" },
{ GLenum::GL_PACK_INVERT_MESA, "GL_PACK_INVERT_MESA" },
{ GLenum::GL_PACK_LSB_FIRST, "GL_PACK_LSB_FIRST" },
{ GLenum::GL_PACK_RESAMPLE_OML, "GL_PACK_RESAMPLE_OML" },
{ GLenum::GL_PACK_RESAMPLE_SGIX, "GL_PACK_RESAMPLE_SGIX" },
{ GLenum::GL_PACK_ROW_BYTES_APPLE, "GL_PACK_ROW_BYTES_APPLE" },
{ GLenum::GL_PACK_ROW_LENGTH, "GL_PACK_ROW_LENGTH" },
{ GLenum::GL_PACK_SKIP_IMAGES, "GL_PACK_SKIP_IMAGES" },
{ GLenum::GL_PACK_SKIP_IMAGES_EXT, "GL_PACK_SKIP_IMAGES_EXT" },
{ GLenum::GL_PACK_SKIP_PIXELS, "GL_PACK_SKIP_PIXELS" },
{ GLenum::GL_PACK_SKIP_ROWS, "GL_PACK_SKIP_ROWS" },
{ GLenum::GL_PACK_SKIP_VOLUMES_SGIS, "GL_PACK_SKIP_VOLUMES_SGIS" },
{ GLenum::GL_PACK_SUBSAMPLE_RATE_SGIX, "GL_PACK_SUBSAMPLE_RATE_SGIX" },
{ GLenum::GL_PACK_SWAP_BYTES, "GL_PACK_SWAP_BYTES" },
{ GLenum::GL_PALETTE4_R5_G6_B5_OES, "GL_PALETTE4_R5_G6_B5_OES" },
{ GLenum::GL_PALETTE4_RGB5_A1_OES, "GL_PALETTE4_RGB5_A1_OES" },
{ GLenum::GL_PALETTE4_RGB8_OES, "GL_PALETTE4_RGB8_OES" },
{ GLenum::GL_PALETTE4_RGBA4_OES, "GL_PALETTE4_RGBA4_OES" },
{ GLenum::GL_PALETTE4_RGBA8_OES, "GL_PALETTE4_RGBA8_OES" },
{ GLenum::GL_PALETTE8_R5_G6_B5_OES, "GL_PALETTE8_R5_G6_B5_OES" },
{ GLenum::GL_PALETTE8_RGB5_A1_OES, "GL_PALETTE8_RGB5_A1_OES" },
{ GLenum::GL_PALETTE8_RGB8_OES, "GL_PALETTE8_RGB8_OES" },
{ GLenum::GL_PALETTE8_RGBA4_OES, "GL_PALETTE8_RGBA4_OES" },
{ GLenum::GL_PALETTE8_RGBA8_OES, "GL_PALETTE8_RGBA8_OES" },
{ GLenum::GL_PARALLEL_ARRAYS_INTEL, "GL_PARALLEL_ARRAYS_INTEL" },
{ GLenum::GL_PARAMETER_BUFFER, "GL_PARAMETER_BUFFER" },
{ GLenum::GL_PARAMETER_BUFFER_ARB, "GL_PARAMETER_BUFFER_ARB" },
{ GLenum::GL_PARAMETER_BUFFER_BINDING, "GL_PARAMETER_BUFFER_BINDING" },
{ GLenum::GL_PARAMETER_BUFFER_BINDING_ARB, "GL_PARAMETER_BUFFER_BINDING_ARB" },
{ GLenum::GL_PARTIAL_SUCCESS_NV, "GL_PARTIAL_SUCCESS_NV" },
{ GLenum::GL_PASS_THROUGH_NV, "GL_PASS_THROUGH_NV" },
{ GLenum::GL_PASS_THROUGH_TOKEN, "GL_PASS_THROUGH_TOKEN" },
{ GLenum::GL_PATCH_DEFAULT_INNER_LEVEL, "GL_PATCH_DEFAULT_INNER_LEVEL" },
{ GLenum::GL_PATCH_DEFAULT_OUTER_LEVEL, "GL_PATCH_DEFAULT_OUTER_LEVEL" },
{ GLenum::GL_PATCH_VERTICES, "GL_PATCH_VERTICES" },
{ GLenum::GL_PATCHES, "GL_PATCHES" },
{ GLenum::GL_PATH_CLIENT_LENGTH_NV, "GL_PATH_CLIENT_LENGTH_NV" },
{ GLenum::GL_PATH_COMMAND_COUNT_NV, "GL_PATH_COMMAND_COUNT_NV" },
{ GLenum::GL_PATH_COMPUTED_LENGTH_NV, "GL_PATH_COMPUTED_LENGTH_NV" },
{ GLenum::GL_PATH_COORD_COUNT_NV, "GL_PATH_COORD_COUNT_NV" },
{ GLenum::GL_PATH_COVER_DEPTH_FUNC_NV, "GL_PATH_COVER_DEPTH_FUNC_NV" },
{ GLenum::GL_PATH_DASH_ARRAY_COUNT_NV, "GL_PATH_DASH_ARRAY_COUNT_NV" },
{ GLenum::GL_PATH_DASH_CAPS_NV, "GL_PATH_DASH_CAPS_NV" },
{ GLenum::GL_PATH_DASH_OFFSET_NV, "GL_PATH_DASH_OFFSET_NV" },
{ GLenum::GL_PATH_DASH_OFFSET_RESET_NV, "GL_PATH_DASH_OFFSET_RESET_NV" },
{ GLenum::GL_PATH_END_CAPS_NV, "GL_PATH_END_CAPS_NV" },
{ GLenum::GL_PATH_ERROR_POSITION_NV, "GL_PATH_ERROR_POSITION_NV" },
{ GLenum::GL_PATH_FILL_BOUNDING_BOX_NV, "GL_PATH_FILL_BOUNDING_BOX_NV" },
{ GLenum::GL_PATH_FILL_COVER_MODE_NV, "GL_PATH_FILL_COVER_MODE_NV" },
{ GLenum::GL_PATH_FILL_MASK_NV, "GL_PATH_FILL_MASK_NV" },
{ GLenum::GL_PATH_FILL_MODE_NV, "GL_PATH_FILL_MODE_NV" },
{ GLenum::GL_PATH_FOG_GEN_MODE_NV, "GL_PATH_FOG_GEN_MODE_NV" },
{ GLenum::GL_PATH_FORMAT_PS_NV, "GL_PATH_FORMAT_PS_NV" },
{ GLenum::GL_PATH_FORMAT_SVG_NV, "GL_PATH_FORMAT_SVG_NV" },
{ GLenum::GL_PATH_GEN_COEFF_NV, "GL_PATH_GEN_COEFF_NV" },
{ GLenum::GL_PATH_GEN_COLOR_FORMAT_NV, "GL_PATH_GEN_COLOR_FORMAT_NV" },
{ GLenum::GL_PATH_GEN_COMPONENTS_NV, "GL_PATH_GEN_COMPONENTS_NV" },
{ GLenum::GL_PATH_GEN_MODE_NV, "GL_PATH_GEN_MODE_NV" },
{ GLenum::GL_PATH_INITIAL_DASH_CAP_NV, "GL_PATH_INITIAL_DASH_CAP_NV" },
{ GLenum::GL_PATH_INITIAL_END_CAP_NV, "GL_PATH_INITIAL_END_CAP_NV" },
{ GLenum::GL_PATH_JOIN_STYLE_NV, "GL_PATH_JOIN_STYLE_NV" },
{ GLenum::GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV, "GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV" },
{ GLenum::GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV, "GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV" },
{ GLenum::GL_PATH_MITER_LIMIT_NV, "GL_PATH_MITER_LIMIT_NV" },
{ GLenum::GL_PATH_MODELVIEW_MATRIX_NV, "GL_PATH_MODELVIEW_MATRIX_NV" },
{ GLenum::GL_PATH_MODELVIEW_NV, "GL_PATH_MODELVIEW_NV" },
{ GLenum::GL_PATH_MODELVIEW_STACK_DEPTH_NV, "GL_PATH_MODELVIEW_STACK_DEPTH_NV" },
{ GLenum::GL_PATH_OBJECT_BOUNDING_BOX_NV, "GL_PATH_OBJECT_BOUNDING_BOX_NV" },
{ GLenum::GL_PATH_PROJECTION_MATRIX_NV, "GL_PATH_PROJECTION_MATRIX_NV" },
{ GLenum::GL_PATH_PROJECTION_NV, "GL_PATH_PROJECTION_NV" },
{ GLenum::GL_PATH_PROJECTION_STACK_DEPTH_NV, "GL_PATH_PROJECTION_STACK_DEPTH_NV" },
{ GLenum::GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV, "GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV" },
{ GLenum::GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV, "GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV" },
{ GLenum::GL_PATH_STENCIL_FUNC_NV, "GL_PATH_STENCIL_FUNC_NV" },
{ GLenum::GL_PATH_STENCIL_REF_NV, "GL_PATH_STENCIL_REF_NV" },
{ GLenum::GL_PATH_STENCIL_VALUE_MASK_NV, "GL_PATH_STENCIL_VALUE_MASK_NV" },
{ GLenum::GL_PATH_STROKE_BOUNDING_BOX_NV, "GL_PATH_STROKE_BOUNDING_BOX_NV" },
{ GLenum::GL_PATH_STROKE_COVER_MODE_NV, "GL_PATH_STROKE_COVER_MODE_NV" },
{ GLenum::GL_PATH_STROKE_MASK_NV, "GL_PATH_STROKE_MASK_NV" },
{ GLenum::GL_PATH_STROKE_WIDTH_NV, "GL_PATH_STROKE_WIDTH_NV" },
{ GLenum::GL_PATH_TERMINAL_DASH_CAP_NV, "GL_PATH_TERMINAL_DASH_CAP_NV" },
{ GLenum::GL_PATH_TERMINAL_END_CAP_NV, "GL_PATH_TERMINAL_END_CAP_NV" },
{ GLenum::GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV, "GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV" },
{ GLenum::GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV, "GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV" },
{ GLenum::GL_PER_GPU_STORAGE_NV, "GL_PER_GPU_STORAGE_NV" },
{ GLenum::GL_PER_STAGE_CONSTANTS_NV, "GL_PER_STAGE_CONSTANTS_NV" },
{ GLenum::GL_PERCENTAGE_AMD, "GL_PERCENTAGE_AMD" },
{ GLenum::GL_PERFMON_RESULT_AMD, "GL_PERFMON_RESULT_AMD" },
{ GLenum::GL_PERFMON_RESULT_AVAILABLE_AMD, "GL_PERFMON_RESULT_AVAILABLE_AMD" },
{ GLenum::GL_PERFMON_RESULT_SIZE_AMD, "GL_PERFMON_RESULT_SIZE_AMD" },
{ GLenum::GL_PERFORMANCE_MONITOR_AMD, "GL_PERFORMANCE_MONITOR_AMD" },
{ GLenum::GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL, "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL, "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL, "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL, "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL, "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL, "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL, "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL, "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_EVENT_INTEL, "GL_PERFQUERY_COUNTER_EVENT_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL, "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_RAW_INTEL, "GL_PERFQUERY_COUNTER_RAW_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL, "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL" },
{ GLenum::GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL, "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL" },
{ GLenum::GL_PERFQUERY_DONOT_FLUSH_INTEL, "GL_PERFQUERY_DONOT_FLUSH_INTEL" },
{ GLenum::GL_PERFQUERY_FLUSH_INTEL, "GL_PERFQUERY_FLUSH_INTEL" },
{ GLenum::GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL, "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL" },
{ GLenum::GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL, "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL" },
{ GLenum::GL_PERFQUERY_WAIT_INTEL, "GL_PERFQUERY_WAIT_INTEL" },
{ GLenum::GL_PERSPECTIVE_CORRECTION_HINT, "GL_PERSPECTIVE_CORRECTION_HINT" },
{ GLenum::GL_PERTURB_EXT, "GL_PERTURB_EXT" },
{ GLenum::GL_PHONG_HINT_WIN, "GL_PHONG_HINT_WIN" },
{ GLenum::GL_PHONG_WIN, "GL_PHONG_WIN" },
{ GLenum::GL_PINLIGHT_NV, "GL_PINLIGHT_NV" },
{ GLenum::GL_PIXEL_COUNT_AVAILABLE_NV, "GL_PIXEL_COUNT_AVAILABLE_NV" },
{ GLenum::GL_PIXEL_COUNT_NV, "GL_PIXEL_COUNT_NV" },
{ GLenum::GL_PIXEL_COUNTER_BITS_NV, "GL_PIXEL_COUNTER_BITS_NV" },
{ GLenum::GL_PIXEL_CUBIC_WEIGHT_EXT, "GL_PIXEL_CUBIC_WEIGHT_EXT" },
{ GLenum::GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS, "GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS" },
{ GLenum::GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS, "GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS" },
{ GLenum::GL_PIXEL_GROUP_COLOR_SGIS, "GL_PIXEL_GROUP_COLOR_SGIS" },
{ GLenum::GL_PIXEL_MAG_FILTER_EXT, "GL_PIXEL_MAG_FILTER_EXT" },
{ GLenum::GL_PIXEL_MAP_A_TO_A, "GL_PIXEL_MAP_A_TO_A" },
{ GLenum::GL_PIXEL_MAP_A_TO_A_SIZE, "GL_PIXEL_MAP_A_TO_A_SIZE" },
{ GLenum::GL_PIXEL_MAP_B_TO_B, "GL_PIXEL_MAP_B_TO_B" },
{ GLenum::GL_PIXEL_MAP_B_TO_B_SIZE, "GL_PIXEL_MAP_B_TO_B_SIZE" },
{ GLenum::GL_PIXEL_MAP_G_TO_G, "GL_PIXEL_MAP_G_TO_G" },
{ GLenum::GL_PIXEL_MAP_G_TO_G_SIZE, "GL_PIXEL_MAP_G_TO_G_SIZE" },
{ GLenum::GL_PIXEL_MAP_I_TO_A, "GL_PIXEL_MAP_I_TO_A" },
{ GLenum::GL_PIXEL_MAP_I_TO_A_SIZE, "GL_PIXEL_MAP_I_TO_A_SIZE" },
{ GLenum::GL_PIXEL_MAP_I_TO_B, "GL_PIXEL_MAP_I_TO_B" },
{ GLenum::GL_PIXEL_MAP_I_TO_B_SIZE, "GL_PIXEL_MAP_I_TO_B_SIZE" },
{ GLenum::GL_PIXEL_MAP_I_TO_G, "GL_PIXEL_MAP_I_TO_G" },
{ GLenum::GL_PIXEL_MAP_I_TO_G_SIZE, "GL_PIXEL_MAP_I_TO_G_SIZE" },
{ GLenum::GL_PIXEL_MAP_I_TO_I, "GL_PIXEL_MAP_I_TO_I" },
{ GLenum::GL_PIXEL_MAP_I_TO_I_SIZE, "GL_PIXEL_MAP_I_TO_I_SIZE" },
{ GLenum::GL_PIXEL_MAP_I_TO_R, "GL_PIXEL_MAP_I_TO_R" },
{ GLenum::GL_PIXEL_MAP_I_TO_R_SIZE, "GL_PIXEL_MAP_I_TO_R_SIZE" },
{ GLenum::GL_PIXEL_MAP_R_TO_R, "GL_PIXEL_MAP_R_TO_R" },
{ GLenum::GL_PIXEL_MAP_R_TO_R_SIZE, "GL_PIXEL_MAP_R_TO_R_SIZE" },
{ GLenum::GL_PIXEL_MAP_S_TO_S, "GL_PIXEL_MAP_S_TO_S" },
{ GLenum::GL_PIXEL_MAP_S_TO_S_SIZE, "GL_PIXEL_MAP_S_TO_S_SIZE" },
{ GLenum::GL_PIXEL_MIN_FILTER_EXT, "GL_PIXEL_MIN_FILTER_EXT" },
{ GLenum::GL_PIXEL_PACK_BUFFER, "GL_PIXEL_PACK_BUFFER" },
{ GLenum::GL_PIXEL_PACK_BUFFER_ARB, "GL_PIXEL_PACK_BUFFER_ARB" },
{ GLenum::GL_PIXEL_PACK_BUFFER_BINDING, "GL_PIXEL_PACK_BUFFER_BINDING" },
{ GLenum::GL_PIXEL_PACK_BUFFER_BINDING_ARB, "GL_PIXEL_PACK_BUFFER_BINDING_ARB" },
{ GLenum::GL_PIXEL_PACK_BUFFER_BINDING_EXT, "GL_PIXEL_PACK_BUFFER_BINDING_EXT" },
{ GLenum::GL_PIXEL_PACK_BUFFER_EXT, "GL_PIXEL_PACK_BUFFER_EXT" },
{ GLenum::GL_PIXEL_SUBSAMPLE_2424_SGIX, "GL_PIXEL_SUBSAMPLE_2424_SGIX" },
{ GLenum::GL_PIXEL_SUBSAMPLE_4242_SGIX, "GL_PIXEL_SUBSAMPLE_4242_SGIX" },
{ GLenum::GL_PIXEL_SUBSAMPLE_4444_SGIX, "GL_PIXEL_SUBSAMPLE_4444_SGIX" },
{ GLenum::GL_PIXEL_TEX_GEN_MODE_SGIX, "GL_PIXEL_TEX_GEN_MODE_SGIX" },
{ GLenum::GL_PIXEL_TEX_GEN_SGIX, "GL_PIXEL_TEX_GEN_SGIX" },
{ GLenum::GL_PIXEL_TEXTURE_SGIS, "GL_PIXEL_TEXTURE_SGIS" },
{ GLenum::GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX, "GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX" },
{ GLenum::GL_PIXEL_TILE_CACHE_INCREMENT_SGIX, "GL_PIXEL_TILE_CACHE_INCREMENT_SGIX" },
{ GLenum::GL_PIXEL_TILE_CACHE_SIZE_SGIX, "GL_PIXEL_TILE_CACHE_SIZE_SGIX" },
{ GLenum::GL_PIXEL_TILE_GRID_DEPTH_SGIX, "GL_PIXEL_TILE_GRID_DEPTH_SGIX" },
{ GLenum::GL_PIXEL_TILE_GRID_HEIGHT_SGIX, "GL_PIXEL_TILE_GRID_HEIGHT_SGIX" },
{ GLenum::GL_PIXEL_TILE_GRID_WIDTH_SGIX, "GL_PIXEL_TILE_GRID_WIDTH_SGIX" },
{ GLenum::GL_PIXEL_TILE_HEIGHT_SGIX, "GL_PIXEL_TILE_HEIGHT_SGIX" },
{ GLenum::GL_PIXEL_TILE_WIDTH_SGIX, "GL_PIXEL_TILE_WIDTH_SGIX" },
{ GLenum::GL_PIXEL_TRANSFORM_2D_EXT, "GL_PIXEL_TRANSFORM_2D_EXT" },
{ GLenum::GL_PIXEL_TRANSFORM_2D_MATRIX_EXT, "GL_PIXEL_TRANSFORM_2D_MATRIX_EXT" },
{ GLenum::GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT, "GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER, "GL_PIXEL_UNPACK_BUFFER" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER_ARB, "GL_PIXEL_UNPACK_BUFFER_ARB" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER_BINDING, "GL_PIXEL_UNPACK_BUFFER_BINDING" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER_BINDING_ARB, "GL_PIXEL_UNPACK_BUFFER_BINDING_ARB" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT" },
{ GLenum::GL_PIXEL_UNPACK_BUFFER_EXT, "GL_PIXEL_UNPACK_BUFFER_EXT" },
{ GLenum::GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD, "GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD" },
{ GLenum::GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD, "GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD" },
{ GLenum::GL_PLUS_CLAMPED_ALPHA_NV, "GL_PLUS_CLAMPED_ALPHA_NV" },
{ GLenum::GL_PLUS_CLAMPED_NV, "GL_PLUS_CLAMPED_NV" },
{ GLenum::GL_PLUS_DARKER_NV, "GL_PLUS_DARKER_NV" },
{ GLenum::GL_PLUS_NV, "GL_PLUS_NV" },
{ GLenum::GL_PN_TRIANGLES_ATI, "GL_PN_TRIANGLES_ATI" },
{ GLenum::GL_PN_TRIANGLES_NORMAL_MODE_ATI, "GL_PN_TRIANGLES_NORMAL_MODE_ATI" },
{ GLenum::GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI, "GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI" },
{ GLenum::GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI, "GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI" },
{ GLenum::GL_PN_TRIANGLES_POINT_MODE_ATI, "GL_PN_TRIANGLES_POINT_MODE_ATI" },
{ GLenum::GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI, "GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI" },
{ GLenum::GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI, "GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI" },
{ GLenum::GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, "GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI" },
{ GLenum::GL_POINT, "GL_POINT" },
{ GLenum::GL_POINT_DISTANCE_ATTENUATION, "GL_POINT_DISTANCE_ATTENUATION" },
{ GLenum::GL_POINT_DISTANCE_ATTENUATION_ARB, "GL_POINT_DISTANCE_ATTENUATION_ARB" },
{ GLenum::GL_POINT_FADE_THRESHOLD_SIZE, "GL_POINT_FADE_THRESHOLD_SIZE" },
{ GLenum::GL_POINT_FADE_THRESHOLD_SIZE_ARB, "GL_POINT_FADE_THRESHOLD_SIZE_ARB" },
{ GLenum::GL_POINT_FADE_THRESHOLD_SIZE_EXT, "GL_POINT_FADE_THRESHOLD_SIZE_EXT" },
{ GLenum::GL_POINT_FADE_THRESHOLD_SIZE_SGIS, "GL_POINT_FADE_THRESHOLD_SIZE_SGIS" },
{ GLenum::GL_POINT_SIZE, "GL_POINT_SIZE" },
{ GLenum::GL_POINT_SIZE_GRANULARITY, "GL_POINT_SIZE_GRANULARITY" },
{ GLenum::GL_POINT_SIZE_MAX, "GL_POINT_SIZE_MAX" },
{ GLenum::GL_POINT_SIZE_MAX_ARB, "GL_POINT_SIZE_MAX_ARB" },
{ GLenum::GL_POINT_SIZE_MAX_EXT, "GL_POINT_SIZE_MAX_EXT" },
{ GLenum::GL_POINT_SIZE_MAX_SGIS, "GL_POINT_SIZE_MAX_SGIS" },
{ GLenum::GL_POINT_SIZE_MIN, "GL_POINT_SIZE_MIN" },
{ GLenum::GL_POINT_SIZE_MIN_ARB, "GL_POINT_SIZE_MIN_ARB" },
{ GLenum::GL_POINT_SIZE_MIN_EXT, "GL_POINT_SIZE_MIN_EXT" },
{ GLenum::GL_POINT_SIZE_MIN_SGIS, "GL_POINT_SIZE_MIN_SGIS" },
{ GLenum::GL_POINT_SIZE_RANGE, "GL_POINT_SIZE_RANGE" },
{ GLenum::GL_POINT_SMOOTH, "GL_POINT_SMOOTH" },
{ GLenum::GL_POINT_SMOOTH_HINT, "GL_POINT_SMOOTH_HINT" },
{ GLenum::GL_POINT_SPRITE, "GL_POINT_SPRITE" },
{ GLenum::GL_POINT_SPRITE_ARB, "GL_POINT_SPRITE_ARB" },
{ GLenum::GL_POINT_SPRITE_COORD_ORIGIN, "GL_POINT_SPRITE_COORD_ORIGIN" },
{ GLenum::GL_POINT_SPRITE_NV, "GL_POINT_SPRITE_NV" },
{ GLenum::GL_POINT_SPRITE_R_MODE_NV, "GL_POINT_SPRITE_R_MODE_NV" },
{ GLenum::GL_POINT_TOKEN, "GL_POINT_TOKEN" },
{ GLenum::GL_POINTS, "GL_POINTS" },
{ GLenum::GL_POLYGON, "GL_POLYGON" },
{ GLenum::GL_POLYGON_MODE, "GL_POLYGON_MODE" },
{ GLenum::GL_POLYGON_OFFSET_BIAS_EXT, "GL_POLYGON_OFFSET_BIAS_EXT" },
{ GLenum::GL_POLYGON_OFFSET_CLAMP, "GL_POLYGON_OFFSET_CLAMP" },
{ GLenum::GL_POLYGON_OFFSET_CLAMP_EXT, "GL_POLYGON_OFFSET_CLAMP_EXT" },
{ GLenum::GL_POLYGON_OFFSET_COMMAND_NV, "GL_POLYGON_OFFSET_COMMAND_NV" },
{ GLenum::GL_POLYGON_OFFSET_EXT, "GL_POLYGON_OFFSET_EXT" },
{ GLenum::GL_POLYGON_OFFSET_FACTOR, "GL_POLYGON_OFFSET_FACTOR" },
{ GLenum::GL_POLYGON_OFFSET_FACTOR_EXT, "GL_POLYGON_OFFSET_FACTOR_EXT" },
{ GLenum::GL_POLYGON_OFFSET_FILL, "GL_POLYGON_OFFSET_FILL" },
{ GLenum::GL_POLYGON_OFFSET_LINE, "GL_POLYGON_OFFSET_LINE" },
{ GLenum::GL_POLYGON_OFFSET_POINT, "GL_POLYGON_OFFSET_POINT" },
{ GLenum::GL_POLYGON_OFFSET_UNITS, "GL_POLYGON_OFFSET_UNITS" },
{ GLenum::GL_POLYGON_SMOOTH, "GL_POLYGON_SMOOTH" },
{ GLenum::GL_POLYGON_SMOOTH_HINT, "GL_POLYGON_SMOOTH_HINT" },
{ GLenum::GL_POLYGON_STIPPLE, "GL_POLYGON_STIPPLE" },
{ GLenum::GL_POLYGON_TOKEN, "GL_POLYGON_TOKEN" },
{ GLenum::GL_POSITION, "GL_POSITION" },
{ GLenum::GL_POST_COLOR_MATRIX_ALPHA_BIAS, "GL_POST_COLOR_MATRIX_ALPHA_BIAS" },
{ GLenum::GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI, "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_ALPHA_SCALE, "GL_POST_COLOR_MATRIX_ALPHA_SCALE" },
{ GLenum::GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI, "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_BLUE_BIAS, "GL_POST_COLOR_MATRIX_BLUE_BIAS" },
{ GLenum::GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI, "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_BLUE_SCALE, "GL_POST_COLOR_MATRIX_BLUE_SCALE" },
{ GLenum::GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI, "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_COLOR_TABLE, "GL_POST_COLOR_MATRIX_COLOR_TABLE" },
{ GLenum::GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI, "GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_GREEN_BIAS, "GL_POST_COLOR_MATRIX_GREEN_BIAS" },
{ GLenum::GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI, "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_GREEN_SCALE, "GL_POST_COLOR_MATRIX_GREEN_SCALE" },
{ GLenum::GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI, "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_RED_BIAS, "GL_POST_COLOR_MATRIX_RED_BIAS" },
{ GLenum::GL_POST_COLOR_MATRIX_RED_BIAS_SGI, "GL_POST_COLOR_MATRIX_RED_BIAS_SGI" },
{ GLenum::GL_POST_COLOR_MATRIX_RED_SCALE, "GL_POST_COLOR_MATRIX_RED_SCALE" },
{ GLenum::GL_POST_COLOR_MATRIX_RED_SCALE_SGI, "GL_POST_COLOR_MATRIX_RED_SCALE_SGI" },
{ GLenum::GL_POST_CONVOLUTION_ALPHA_BIAS, "GL_POST_CONVOLUTION_ALPHA_BIAS" },
{ GLenum::GL_POST_CONVOLUTION_ALPHA_BIAS_EXT, "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT" },
{ GLenum::GL_POST_CONVOLUTION_ALPHA_SCALE, "GL_POST_CONVOLUTION_ALPHA_SCALE" },
{ GLenum::GL_POST_CONVOLUTION_ALPHA_SCALE_EXT, "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT" },
{ GLenum::GL_POST_CONVOLUTION_BLUE_BIAS, "GL_POST_CONVOLUTION_BLUE_BIAS" },
{ GLenum::GL_POST_CONVOLUTION_BLUE_BIAS_EXT, "GL_POST_CONVOLUTION_BLUE_BIAS_EXT" },
{ GLenum::GL_POST_CONVOLUTION_BLUE_SCALE, "GL_POST_CONVOLUTION_BLUE_SCALE" },
{ GLenum::GL_POST_CONVOLUTION_BLUE_SCALE_EXT, "GL_POST_CONVOLUTION_BLUE_SCALE_EXT" },
{ GLenum::GL_POST_CONVOLUTION_COLOR_TABLE, "GL_POST_CONVOLUTION_COLOR_TABLE" },
{ GLenum::GL_POST_CONVOLUTION_COLOR_TABLE_SGI, "GL_POST_CONVOLUTION_COLOR_TABLE_SGI" },
{ GLenum::GL_POST_CONVOLUTION_GREEN_BIAS, "GL_POST_CONVOLUTION_GREEN_BIAS" },
{ GLenum::GL_POST_CONVOLUTION_GREEN_BIAS_EXT, "GL_POST_CONVOLUTION_GREEN_BIAS_EXT" },
{ GLenum::GL_POST_CONVOLUTION_GREEN_SCALE, "GL_POST_CONVOLUTION_GREEN_SCALE" },
{ GLenum::GL_POST_CONVOLUTION_GREEN_SCALE_EXT, "GL_POST_CONVOLUTION_GREEN_SCALE_EXT" },
{ GLenum::GL_POST_CONVOLUTION_RED_BIAS, "GL_POST_CONVOLUTION_RED_BIAS" },
{ GLenum::GL_POST_CONVOLUTION_RED_BIAS_EXT, "GL_POST_CONVOLUTION_RED_BIAS_EXT" },
{ GLenum::GL_POST_CONVOLUTION_RED_SCALE, "GL_POST_CONVOLUTION_RED_SCALE" },
{ GLenum::GL_POST_CONVOLUTION_RED_SCALE_EXT, "GL_POST_CONVOLUTION_RED_SCALE_EXT" },
{ GLenum::GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP, "GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP" },
{ GLenum::GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX, "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX" },
{ GLenum::GL_POST_TEXTURE_FILTER_BIAS_SGIX, "GL_POST_TEXTURE_FILTER_BIAS_SGIX" },
{ GLenum::GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX, "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX" },
{ GLenum::GL_POST_TEXTURE_FILTER_SCALE_SGIX, "GL_POST_TEXTURE_FILTER_SCALE_SGIX" },
{ GLenum::GL_PREFER_DOUBLEBUFFER_HINT_PGI, "GL_PREFER_DOUBLEBUFFER_HINT_PGI" },
{ GLenum::GL_PRESENT_DURATION_NV, "GL_PRESENT_DURATION_NV" },
{ GLenum::GL_PRESENT_TIME_NV, "GL_PRESENT_TIME_NV" },
{ GLenum::GL_PRESERVE_ATI, "GL_PRESERVE_ATI" },
{ GLenum::GL_PREVIOUS, "GL_PREVIOUS" },
{ GLenum::GL_PREVIOUS_ARB, "GL_PREVIOUS_ARB" },
{ GLenum::GL_PREVIOUS_EXT, "GL_PREVIOUS_EXT" },
{ GLenum::GL_PREVIOUS_TEXTURE_INPUT_NV, "GL_PREVIOUS_TEXTURE_INPUT_NV" },
{ GLenum::GL_PRIMARY_COLOR, "GL_PRIMARY_COLOR" },
{ GLenum::GL_PRIMARY_COLOR_ARB, "GL_PRIMARY_COLOR_ARB" },
{ GLenum::GL_PRIMARY_COLOR_EXT, "GL_PRIMARY_COLOR_EXT" },
{ GLenum::GL_PRIMARY_COLOR_NV, "GL_PRIMARY_COLOR_NV" },
{ GLenum::GL_PRIMITIVE_BOUNDING_BOX_ARB, "GL_PRIMITIVE_BOUNDING_BOX_ARB" },
{ GLenum::GL_PRIMITIVE_ID_NV, "GL_PRIMITIVE_ID_NV" },
{ GLenum::GL_PRIMITIVE_RESTART, "GL_PRIMITIVE_RESTART" },
{ GLenum::GL_PRIMITIVE_RESTART_FIXED_INDEX, "GL_PRIMITIVE_RESTART_FIXED_INDEX" },
{ GLenum::GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED, "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED" },
{ GLenum::GL_PRIMITIVE_RESTART_INDEX, "GL_PRIMITIVE_RESTART_INDEX" },
{ GLenum::GL_PRIMITIVE_RESTART_INDEX_NV, "GL_PRIMITIVE_RESTART_INDEX_NV" },
{ GLenum::GL_PRIMITIVE_RESTART_NV, "GL_PRIMITIVE_RESTART_NV" },
{ GLenum::GL_PRIMITIVES_GENERATED, "GL_PRIMITIVES_GENERATED" },
{ GLenum::GL_PRIMITIVES_GENERATED_EXT, "GL_PRIMITIVES_GENERATED_EXT" },
{ GLenum::GL_PRIMITIVES_GENERATED_NV, "GL_PRIMITIVES_GENERATED_NV" },
{ GLenum::GL_PRIMITIVES_SUBMITTED, "GL_PRIMITIVES_SUBMITTED" },
{ GLenum::GL_PRIMITIVES_SUBMITTED_ARB, "GL_PRIMITIVES_SUBMITTED_ARB" },
{ GLenum::GL_PROGRAM, "GL_PROGRAM" },
{ GLenum::GL_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_PROGRAM_ADDRESS_REGISTERS_ARB" },
{ GLenum::GL_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_PROGRAM_ALU_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_ATTRIB_COMPONENTS_NV, "GL_PROGRAM_ATTRIB_COMPONENTS_NV" },
{ GLenum::GL_PROGRAM_ATTRIBS_ARB, "GL_PROGRAM_ATTRIBS_ARB" },
{ GLenum::GL_PROGRAM_BINARY_FORMAT_MESA, "GL_PROGRAM_BINARY_FORMAT_MESA" },
{ GLenum::GL_PROGRAM_BINARY_FORMATS, "GL_PROGRAM_BINARY_FORMATS" },
{ GLenum::GL_PROGRAM_BINARY_LENGTH, "GL_PROGRAM_BINARY_LENGTH" },
{ GLenum::GL_PROGRAM_BINARY_RETRIEVABLE_HINT, "GL_PROGRAM_BINARY_RETRIEVABLE_HINT" },
{ GLenum::GL_PROGRAM_BINDING_ARB, "GL_PROGRAM_BINDING_ARB" },
{ GLenum::GL_PROGRAM_ERROR_POSITION_ARB, "GL_PROGRAM_ERROR_POSITION_ARB" },
{ GLenum::GL_PROGRAM_ERROR_POSITION_NV, "GL_PROGRAM_ERROR_POSITION_NV" },
{ GLenum::GL_PROGRAM_ERROR_STRING_ARB, "GL_PROGRAM_ERROR_STRING_ARB" },
{ GLenum::GL_PROGRAM_ERROR_STRING_NV, "GL_PROGRAM_ERROR_STRING_NV" },
{ GLenum::GL_PROGRAM_FORMAT_ARB, "GL_PROGRAM_FORMAT_ARB" },
{ GLenum::GL_PROGRAM_FORMAT_ASCII_ARB, "GL_PROGRAM_FORMAT_ASCII_ARB" },
{ GLenum::GL_PROGRAM_INPUT, "GL_PROGRAM_INPUT" },
{ GLenum::GL_PROGRAM_INSTRUCTIONS_ARB, "GL_PROGRAM_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_KHR, "GL_PROGRAM_KHR" },
{ GLenum::GL_PROGRAM_LENGTH_ARB, "GL_PROGRAM_LENGTH_ARB" },
{ GLenum::GL_PROGRAM_LENGTH_NV, "GL_PROGRAM_LENGTH_NV" },
{ GLenum::GL_PROGRAM_MATRIX_EXT, "GL_PROGRAM_MATRIX_EXT" },
{ GLenum::GL_PROGRAM_MATRIX_STACK_DEPTH_EXT, "GL_PROGRAM_MATRIX_STACK_DEPTH_EXT" },
{ GLenum::GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_PROGRAM_NATIVE_ATTRIBS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_PROGRAM_NATIVE_PARAMETERS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_PROGRAM_NATIVE_TEMPORARIES_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" },
{ GLenum::GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_OBJECT_ARB, "GL_PROGRAM_OBJECT_ARB" },
{ GLenum::GL_PROGRAM_OBJECT_EXT, "GL_PROGRAM_OBJECT_EXT" },
{ GLenum::GL_PROGRAM_OUTPUT, "GL_PROGRAM_OUTPUT" },
{ GLenum::GL_PROGRAM_PARAMETER_NV, "GL_PROGRAM_PARAMETER_NV" },
{ GLenum::GL_PROGRAM_PARAMETERS_ARB, "GL_PROGRAM_PARAMETERS_ARB" },
{ GLenum::GL_PROGRAM_PIPELINE, "GL_PROGRAM_PIPELINE" },
{ GLenum::GL_PROGRAM_PIPELINE_BINDING, "GL_PROGRAM_PIPELINE_BINDING" },
{ GLenum::GL_PROGRAM_PIPELINE_BINDING_EXT, "GL_PROGRAM_PIPELINE_BINDING_EXT" },
{ GLenum::GL_PROGRAM_PIPELINE_KHR, "GL_PROGRAM_PIPELINE_KHR" },
{ GLenum::GL_PROGRAM_PIPELINE_OBJECT_EXT, "GL_PROGRAM_PIPELINE_OBJECT_EXT" },
{ GLenum::GL_PROGRAM_POINT_SIZE, "GL_PROGRAM_POINT_SIZE" },
{ GLenum::GL_PROGRAM_POINT_SIZE_ARB, "GL_PROGRAM_POINT_SIZE_ARB" },
{ GLenum::GL_PROGRAM_POINT_SIZE_EXT, "GL_PROGRAM_POINT_SIZE_EXT" },
{ GLenum::GL_PROGRAM_RESIDENT_NV, "GL_PROGRAM_RESIDENT_NV" },
{ GLenum::GL_PROGRAM_RESULT_COMPONENTS_NV, "GL_PROGRAM_RESULT_COMPONENTS_NV" },
{ GLenum::GL_PROGRAM_SEPARABLE, "GL_PROGRAM_SEPARABLE" },
{ GLenum::GL_PROGRAM_SEPARABLE_EXT, "GL_PROGRAM_SEPARABLE_EXT" },
{ GLenum::GL_PROGRAM_STRING_ARB, "GL_PROGRAM_STRING_ARB" },
{ GLenum::GL_PROGRAM_STRING_NV, "GL_PROGRAM_STRING_NV" },
{ GLenum::GL_PROGRAM_TARGET_NV, "GL_PROGRAM_TARGET_NV" },
{ GLenum::GL_PROGRAM_TEMPORARIES_ARB, "GL_PROGRAM_TEMPORARIES_ARB" },
{ GLenum::GL_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_PROGRAM_TEX_INDIRECTIONS_ARB" },
{ GLenum::GL_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_PROGRAM_TEX_INSTRUCTIONS_ARB" },
{ GLenum::GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB" },
{ GLenum::GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB, "GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB" },
{ GLenum::GL_PROGRAMMABLE_SAMPLE_LOCATION_NV, "GL_PROGRAMMABLE_SAMPLE_LOCATION_NV" },
{ GLenum::GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB, "GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB" },
{ GLenum::GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV, "GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV" },
{ GLenum::GL_PROJECTION, "GL_PROJECTION" },
{ GLenum::GL_PROJECTION_MATRIX, "GL_PROJECTION_MATRIX" },
{ GLenum::GL_PROJECTION_STACK_DEPTH, "GL_PROJECTION_STACK_DEPTH" },
{ GLenum::GL_PROTECTED_MEMORY_OBJECT_EXT, "GL_PROTECTED_MEMORY_OBJECT_EXT" },
{ GLenum::GL_PROVOKING_VERTEX, "GL_PROVOKING_VERTEX" },
{ GLenum::GL_PROVOKING_VERTEX_EXT, "GL_PROVOKING_VERTEX_EXT" },
{ GLenum::GL_PROXY_COLOR_TABLE, "GL_PROXY_COLOR_TABLE" },
{ GLenum::GL_PROXY_COLOR_TABLE_SGI, "GL_PROXY_COLOR_TABLE_SGI" },
{ GLenum::GL_PROXY_HISTOGRAM, "GL_PROXY_HISTOGRAM" },
{ GLenum::GL_PROXY_HISTOGRAM_EXT, "GL_PROXY_HISTOGRAM_EXT" },
{ GLenum::GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE, "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE" },
{ GLenum::GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI, "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI" },
{ GLenum::GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE" },
{ GLenum::GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI" },
{ GLenum::GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP, "GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP" },
{ GLenum::GL_PROXY_TEXTURE_1D, "GL_PROXY_TEXTURE_1D" },
{ GLenum::GL_PROXY_TEXTURE_1D_ARRAY, "GL_PROXY_TEXTURE_1D_ARRAY" },
{ GLenum::GL_PROXY_TEXTURE_1D_ARRAY_EXT, "GL_PROXY_TEXTURE_1D_ARRAY_EXT" },
{ GLenum::GL_PROXY_TEXTURE_1D_EXT, "GL_PROXY_TEXTURE_1D_EXT" },
{ GLenum::GL_PROXY_TEXTURE_1D_STACK_MESAX, "GL_PROXY_TEXTURE_1D_STACK_MESAX" },
{ GLenum::GL_PROXY_TEXTURE_2D, "GL_PROXY_TEXTURE_2D" },
{ GLenum::GL_PROXY_TEXTURE_2D_ARRAY, "GL_PROXY_TEXTURE_2D_ARRAY" },
{ GLenum::GL_PROXY_TEXTURE_2D_ARRAY_EXT, "GL_PROXY_TEXTURE_2D_ARRAY_EXT" },
{ GLenum::GL_PROXY_TEXTURE_2D_EXT, "GL_PROXY_TEXTURE_2D_EXT" },
{ GLenum::GL_PROXY_TEXTURE_2D_MULTISAMPLE, "GL_PROXY_TEXTURE_2D_MULTISAMPLE" },
{ GLenum::GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY, "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_PROXY_TEXTURE_2D_STACK_MESAX, "GL_PROXY_TEXTURE_2D_STACK_MESAX" },
{ GLenum::GL_PROXY_TEXTURE_3D, "GL_PROXY_TEXTURE_3D" },
{ GLenum::GL_PROXY_TEXTURE_3D_EXT, "GL_PROXY_TEXTURE_3D_EXT" },
{ GLenum::GL_PROXY_TEXTURE_4D_SGIS, "GL_PROXY_TEXTURE_4D_SGIS" },
{ GLenum::GL_PROXY_TEXTURE_COLOR_TABLE_SGI, "GL_PROXY_TEXTURE_COLOR_TABLE_SGI" },
{ GLenum::GL_PROXY_TEXTURE_CUBE_MAP, "GL_PROXY_TEXTURE_CUBE_MAP" },
{ GLenum::GL_PROXY_TEXTURE_CUBE_MAP_ARB, "GL_PROXY_TEXTURE_CUBE_MAP_ARB" },
{ GLenum::GL_PROXY_TEXTURE_CUBE_MAP_ARRAY, "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY" },
{ GLenum::GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB, "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_PROXY_TEXTURE_CUBE_MAP_EXT, "GL_PROXY_TEXTURE_CUBE_MAP_EXT" },
{ GLenum::GL_PROXY_TEXTURE_RECTANGLE, "GL_PROXY_TEXTURE_RECTANGLE" },
{ GLenum::GL_PROXY_TEXTURE_RECTANGLE_ARB, "GL_PROXY_TEXTURE_RECTANGLE_ARB" },
{ GLenum::GL_PROXY_TEXTURE_RECTANGLE_NV, "GL_PROXY_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_PURGEABLE_APPLE, "GL_PURGEABLE_APPLE" },
{ GLenum::GL_PURGED_CONTEXT_RESET_NV, "GL_PURGED_CONTEXT_RESET_NV" },
{ GLenum::GL_Q, "GL_Q" },
{ GLenum::GL_QUAD_ALPHA4_SGIS, "GL_QUAD_ALPHA4_SGIS" },
{ GLenum::GL_QUAD_ALPHA8_SGIS, "GL_QUAD_ALPHA8_SGIS" },
{ GLenum::GL_QUAD_INTENSITY4_SGIS, "GL_QUAD_INTENSITY4_SGIS" },
{ GLenum::GL_QUAD_INTENSITY8_SGIS, "GL_QUAD_INTENSITY8_SGIS" },
{ GLenum::GL_QUAD_LUMINANCE4_SGIS, "GL_QUAD_LUMINANCE4_SGIS" },
{ GLenum::GL_QUAD_LUMINANCE8_SGIS, "GL_QUAD_LUMINANCE8_SGIS" },
{ GLenum::GL_QUAD_MESH_SUN, "GL_QUAD_MESH_SUN" },
{ GLenum::GL_QUAD_STRIP, "GL_QUAD_STRIP" },
{ GLenum::GL_QUAD_TEXTURE_SELECT_SGIS, "GL_QUAD_TEXTURE_SELECT_SGIS" },
{ GLenum::GL_QUADRATIC_ATTENUATION, "GL_QUADRATIC_ATTENUATION" },
{ GLenum::GL_QUADRATIC_CURVE_TO_NV, "GL_QUADRATIC_CURVE_TO_NV" },
{ GLenum::GL_QUADS, "GL_QUADS" },
{ GLenum::GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION, "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION" },
{ GLenum::GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT, "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT" },
{ GLenum::GL_QUERY, "GL_QUERY" },
{ GLenum::GL_QUERY_BUFFER, "GL_QUERY_BUFFER" },
{ GLenum::GL_QUERY_BUFFER_AMD, "GL_QUERY_BUFFER_AMD" },
{ GLenum::GL_QUERY_BUFFER_BINDING, "GL_QUERY_BUFFER_BINDING" },
{ GLenum::GL_QUERY_BUFFER_BINDING_AMD, "GL_QUERY_BUFFER_BINDING_AMD" },
{ GLenum::GL_QUERY_BY_REGION_NO_WAIT, "GL_QUERY_BY_REGION_NO_WAIT" },
{ GLenum::GL_QUERY_BY_REGION_NO_WAIT_INVERTED, "GL_QUERY_BY_REGION_NO_WAIT_INVERTED" },
{ GLenum::GL_QUERY_BY_REGION_NO_WAIT_NV, "GL_QUERY_BY_REGION_NO_WAIT_NV" },
{ GLenum::GL_QUERY_BY_REGION_WAIT, "GL_QUERY_BY_REGION_WAIT" },
{ GLenum::GL_QUERY_BY_REGION_WAIT_INVERTED, "GL_QUERY_BY_REGION_WAIT_INVERTED" },
{ GLenum::GL_QUERY_BY_REGION_WAIT_NV, "GL_QUERY_BY_REGION_WAIT_NV" },
{ GLenum::GL_QUERY_COUNTER_BITS, "GL_QUERY_COUNTER_BITS" },
{ GLenum::GL_QUERY_COUNTER_BITS_ARB, "GL_QUERY_COUNTER_BITS_ARB" },
{ GLenum::GL_QUERY_KHR, "GL_QUERY_KHR" },
{ GLenum::GL_QUERY_NO_WAIT, "GL_QUERY_NO_WAIT" },
{ GLenum::GL_QUERY_NO_WAIT_INVERTED, "GL_QUERY_NO_WAIT_INVERTED" },
{ GLenum::GL_QUERY_NO_WAIT_NV, "GL_QUERY_NO_WAIT_NV" },
{ GLenum::GL_QUERY_OBJECT_AMD, "GL_QUERY_OBJECT_AMD" },
{ GLenum::GL_QUERY_OBJECT_EXT, "GL_QUERY_OBJECT_EXT" },
{ GLenum::GL_QUERY_RESOURCE_BUFFEROBJECT_NV, "GL_QUERY_RESOURCE_BUFFEROBJECT_NV" },
{ GLenum::GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV, "GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV" },
{ GLenum::GL_QUERY_RESOURCE_RENDERBUFFER_NV, "GL_QUERY_RESOURCE_RENDERBUFFER_NV" },
{ GLenum::GL_QUERY_RESOURCE_SYS_RESERVED_NV, "GL_QUERY_RESOURCE_SYS_RESERVED_NV" },
{ GLenum::GL_QUERY_RESOURCE_TEXTURE_NV, "GL_QUERY_RESOURCE_TEXTURE_NV" },
{ GLenum::GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV, "GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV" },
{ GLenum::GL_QUERY_RESULT, "GL_QUERY_RESULT" },
{ GLenum::GL_QUERY_RESULT_ARB, "GL_QUERY_RESULT_ARB" },
{ GLenum::GL_QUERY_RESULT_AVAILABLE, "GL_QUERY_RESULT_AVAILABLE" },
{ GLenum::GL_QUERY_RESULT_AVAILABLE_ARB, "GL_QUERY_RESULT_AVAILABLE_ARB" },
{ GLenum::GL_QUERY_RESULT_NO_WAIT, "GL_QUERY_RESULT_NO_WAIT" },
{ GLenum::GL_QUERY_RESULT_NO_WAIT_AMD, "GL_QUERY_RESULT_NO_WAIT_AMD" },
{ GLenum::GL_QUERY_TARGET, "GL_QUERY_TARGET" },
{ GLenum::GL_QUERY_WAIT, "GL_QUERY_WAIT" },
{ GLenum::GL_QUERY_WAIT_INVERTED, "GL_QUERY_WAIT_INVERTED" },
{ GLenum::GL_QUERY_WAIT_NV, "GL_QUERY_WAIT_NV" },
{ GLenum::GL_R, "GL_R" },
{ GLenum::GL_R11F_G11F_B10F, "GL_R11F_G11F_B10F" },
{ GLenum::GL_R11F_G11F_B10F_EXT, "GL_R11F_G11F_B10F_EXT" },
{ GLenum::GL_R16, "GL_R16" },
{ GLenum::GL_R16_SNORM, "GL_R16_SNORM" },
{ GLenum::GL_R16F, "GL_R16F" },
{ GLenum::GL_R16I, "GL_R16I" },
{ GLenum::GL_R16UI, "GL_R16UI" },
{ GLenum::GL_R1UI_C3F_V3F_SUN, "GL_R1UI_C3F_V3F_SUN" },
{ GLenum::GL_R1UI_C4F_N3F_V3F_SUN, "GL_R1UI_C4F_N3F_V3F_SUN" },
{ GLenum::GL_R1UI_C4UB_V3F_SUN, "GL_R1UI_C4UB_V3F_SUN" },
{ GLenum::GL_R1UI_N3F_V3F_SUN, "GL_R1UI_N3F_V3F_SUN" },
{ GLenum::GL_R1UI_T2F_C4F_N3F_V3F_SUN, "GL_R1UI_T2F_C4F_N3F_V3F_SUN" },
{ GLenum::GL_R1UI_T2F_N3F_V3F_SUN, "GL_R1UI_T2F_N3F_V3F_SUN" },
{ GLenum::GL_R1UI_T2F_V3F_SUN, "GL_R1UI_T2F_V3F_SUN" },
{ GLenum::GL_R1UI_V3F_SUN, "GL_R1UI_V3F_SUN" },
{ GLenum::GL_R32F, "GL_R32F" },
{ GLenum::GL_R32I, "GL_R32I" },
{ GLenum::GL_R32UI, "GL_R32UI" },
{ GLenum::GL_R3_G3_B2, "GL_R3_G3_B2" },
{ GLenum::GL_R8, "GL_R8" },
{ GLenum::GL_R8_SNORM, "GL_R8_SNORM" },
{ GLenum::GL_R8I, "GL_R8I" },
{ GLenum::GL_R8UI, "GL_R8UI" },
{ GLenum::GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT, "GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT" },
{ GLenum::GL_RASTER_MULTISAMPLE_EXT, "GL_RASTER_MULTISAMPLE_EXT" },
{ GLenum::GL_RASTER_POSITION_UNCLIPPED_IBM, "GL_RASTER_POSITION_UNCLIPPED_IBM" },
{ GLenum::GL_RASTER_SAMPLES_EXT, "GL_RASTER_SAMPLES_EXT" },
{ GLenum::GL_RASTERIZER_DISCARD, "GL_RASTERIZER_DISCARD" },
{ GLenum::GL_RASTERIZER_DISCARD_EXT, "GL_RASTERIZER_DISCARD_EXT" },
{ GLenum::GL_RASTERIZER_DISCARD_NV, "GL_RASTERIZER_DISCARD_NV" },
{ GLenum::GL_READ_BUFFER, "GL_READ_BUFFER" },
{ GLenum::GL_READ_FRAMEBUFFER, "GL_READ_FRAMEBUFFER" },
{ GLenum::GL_READ_FRAMEBUFFER_BINDING, "GL_READ_FRAMEBUFFER_BINDING" },
{ GLenum::GL_READ_FRAMEBUFFER_BINDING_EXT, "GL_READ_FRAMEBUFFER_BINDING_EXT" },
{ GLenum::GL_READ_FRAMEBUFFER_EXT, "GL_READ_FRAMEBUFFER_EXT" },
{ GLenum::GL_READ_ONLY, "GL_READ_ONLY" },
{ GLenum::GL_READ_ONLY_ARB, "GL_READ_ONLY_ARB" },
{ GLenum::GL_READ_PIXEL_DATA_RANGE_LENGTH_NV, "GL_READ_PIXEL_DATA_RANGE_LENGTH_NV" },
{ GLenum::GL_READ_PIXEL_DATA_RANGE_NV, "GL_READ_PIXEL_DATA_RANGE_NV" },
{ GLenum::GL_READ_PIXEL_DATA_RANGE_POINTER_NV, "GL_READ_PIXEL_DATA_RANGE_POINTER_NV" },
{ GLenum::GL_READ_PIXELS, "GL_READ_PIXELS" },
{ GLenum::GL_READ_PIXELS_FORMAT, "GL_READ_PIXELS_FORMAT" },
{ GLenum::GL_READ_PIXELS_TYPE, "GL_READ_PIXELS_TYPE" },
{ GLenum::GL_READ_WRITE, "GL_READ_WRITE" },
{ GLenum::GL_READ_WRITE_ARB, "GL_READ_WRITE_ARB" },
{ GLenum::GL_RECLAIM_MEMORY_HINT_PGI, "GL_RECLAIM_MEMORY_HINT_PGI" },
{ GLenum::GL_RECT_NV, "GL_RECT_NV" },
{ GLenum::GL_RED, "GL_RED" },
{ GLenum::GL_RED_BIAS, "GL_RED_BIAS" },
{ GLenum::GL_RED_BITS, "GL_RED_BITS" },
{ GLenum::GL_RED_INTEGER, "GL_RED_INTEGER" },
{ GLenum::GL_RED_INTEGER_EXT, "GL_RED_INTEGER_EXT" },
{ GLenum::GL_RED_MAX_CLAMP_INGR, "GL_RED_MAX_CLAMP_INGR" },
{ GLenum::GL_RED_MIN_CLAMP_INGR, "GL_RED_MIN_CLAMP_INGR" },
{ GLenum::GL_RED_NV, "GL_RED_NV" },
{ GLenum::GL_RED_SCALE, "GL_RED_SCALE" },
{ GLenum::GL_RED_SNORM, "GL_RED_SNORM" },
{ GLenum::GL_REDUCE, "GL_REDUCE" },
{ GLenum::GL_REDUCE_EXT, "GL_REDUCE_EXT" },
{ GLenum::GL_REFERENCE_PLANE_EQUATION_SGIX, "GL_REFERENCE_PLANE_EQUATION_SGIX" },
{ GLenum::GL_REFERENCE_PLANE_SGIX, "GL_REFERENCE_PLANE_SGIX" },
{ GLenum::GL_REFERENCED_BY_COMPUTE_SHADER, "GL_REFERENCED_BY_COMPUTE_SHADER" },
{ GLenum::GL_REFERENCED_BY_FRAGMENT_SHADER, "GL_REFERENCED_BY_FRAGMENT_SHADER" },
{ GLenum::GL_REFERENCED_BY_GEOMETRY_SHADER, "GL_REFERENCED_BY_GEOMETRY_SHADER" },
{ GLenum::GL_REFERENCED_BY_MESH_SHADER_NV, "GL_REFERENCED_BY_MESH_SHADER_NV" },
{ GLenum::GL_REFERENCED_BY_TASK_SHADER_NV, "GL_REFERENCED_BY_TASK_SHADER_NV" },
{ GLenum::GL_REFERENCED_BY_TESS_CONTROL_SHADER, "GL_REFERENCED_BY_TESS_CONTROL_SHADER" },
{ GLenum::GL_REFERENCED_BY_TESS_EVALUATION_SHADER, "GL_REFERENCED_BY_TESS_EVALUATION_SHADER" },
{ GLenum::GL_REFERENCED_BY_VERTEX_SHADER, "GL_REFERENCED_BY_VERTEX_SHADER" },
{ GLenum::GL_REFLECTION_MAP, "GL_REFLECTION_MAP" },
{ GLenum::GL_REFLECTION_MAP_ARB, "GL_REFLECTION_MAP_ARB" },
{ GLenum::GL_REFLECTION_MAP_EXT, "GL_REFLECTION_MAP_EXT" },
{ GLenum::GL_REFLECTION_MAP_NV, "GL_REFLECTION_MAP_NV" },
{ GLenum::GL_REG_0_ATI, "GL_REG_0_ATI" },
{ GLenum::GL_REG_10_ATI, "GL_REG_10_ATI" },
{ GLenum::GL_REG_11_ATI, "GL_REG_11_ATI" },
{ GLenum::GL_REG_12_ATI, "GL_REG_12_ATI" },
{ GLenum::GL_REG_13_ATI, "GL_REG_13_ATI" },
{ GLenum::GL_REG_14_ATI, "GL_REG_14_ATI" },
{ GLenum::GL_REG_15_ATI, "GL_REG_15_ATI" },
{ GLenum::GL_REG_16_ATI, "GL_REG_16_ATI" },
{ GLenum::GL_REG_17_ATI, "GL_REG_17_ATI" },
{ GLenum::GL_REG_18_ATI, "GL_REG_18_ATI" },
{ GLenum::GL_REG_19_ATI, "GL_REG_19_ATI" },
{ GLenum::GL_REG_1_ATI, "GL_REG_1_ATI" },
{ GLenum::GL_REG_20_ATI, "GL_REG_20_ATI" },
{ GLenum::GL_REG_21_ATI, "GL_REG_21_ATI" },
{ GLenum::GL_REG_22_ATI, "GL_REG_22_ATI" },
{ GLenum::GL_REG_23_ATI, "GL_REG_23_ATI" },
{ GLenum::GL_REG_24_ATI, "GL_REG_24_ATI" },
{ GLenum::GL_REG_25_ATI, "GL_REG_25_ATI" },
{ GLenum::GL_REG_26_ATI, "GL_REG_26_ATI" },
{ GLenum::GL_REG_27_ATI, "GL_REG_27_ATI" },
{ GLenum::GL_REG_28_ATI, "GL_REG_28_ATI" },
{ GLenum::GL_REG_29_ATI, "GL_REG_29_ATI" },
{ GLenum::GL_REG_2_ATI, "GL_REG_2_ATI" },
{ GLenum::GL_REG_30_ATI, "GL_REG_30_ATI" },
{ GLenum::GL_REG_31_ATI, "GL_REG_31_ATI" },
{ GLenum::GL_REG_3_ATI, "GL_REG_3_ATI" },
{ GLenum::GL_REG_4_ATI, "GL_REG_4_ATI" },
{ GLenum::GL_REG_5_ATI, "GL_REG_5_ATI" },
{ GLenum::GL_REG_6_ATI, "GL_REG_6_ATI" },
{ GLenum::GL_REG_7_ATI, "GL_REG_7_ATI" },
{ GLenum::GL_REG_8_ATI, "GL_REG_8_ATI" },
{ GLenum::GL_REG_9_ATI, "GL_REG_9_ATI" },
{ GLenum::GL_REGISTER_COMBINERS_NV, "GL_REGISTER_COMBINERS_NV" },
{ GLenum::GL_RELATIVE_ARC_TO_NV, "GL_RELATIVE_ARC_TO_NV" },
{ GLenum::GL_RELATIVE_CONIC_CURVE_TO_NV, "GL_RELATIVE_CONIC_CURVE_TO_NV" },
{ GLenum::GL_RELATIVE_CUBIC_CURVE_TO_NV, "GL_RELATIVE_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_RELATIVE_HORIZONTAL_LINE_TO_NV, "GL_RELATIVE_HORIZONTAL_LINE_TO_NV" },
{ GLenum::GL_RELATIVE_LARGE_CCW_ARC_TO_NV, "GL_RELATIVE_LARGE_CCW_ARC_TO_NV" },
{ GLenum::GL_RELATIVE_LARGE_CW_ARC_TO_NV, "GL_RELATIVE_LARGE_CW_ARC_TO_NV" },
{ GLenum::GL_RELATIVE_LINE_TO_NV, "GL_RELATIVE_LINE_TO_NV" },
{ GLenum::GL_RELATIVE_MOVE_TO_NV, "GL_RELATIVE_MOVE_TO_NV" },
{ GLenum::GL_RELATIVE_QUADRATIC_CURVE_TO_NV, "GL_RELATIVE_QUADRATIC_CURVE_TO_NV" },
{ GLenum::GL_RELATIVE_RECT_NV, "GL_RELATIVE_RECT_NV" },
{ GLenum::GL_RELATIVE_ROUNDED_RECT2_NV, "GL_RELATIVE_ROUNDED_RECT2_NV" },
{ GLenum::GL_RELATIVE_ROUNDED_RECT4_NV, "GL_RELATIVE_ROUNDED_RECT4_NV" },
{ GLenum::GL_RELATIVE_ROUNDED_RECT8_NV, "GL_RELATIVE_ROUNDED_RECT8_NV" },
{ GLenum::GL_RELATIVE_ROUNDED_RECT_NV, "GL_RELATIVE_ROUNDED_RECT_NV" },
{ GLenum::GL_RELATIVE_SMALL_CCW_ARC_TO_NV, "GL_RELATIVE_SMALL_CCW_ARC_TO_NV" },
{ GLenum::GL_RELATIVE_SMALL_CW_ARC_TO_NV, "GL_RELATIVE_SMALL_CW_ARC_TO_NV" },
{ GLenum::GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV, "GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV, "GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV" },
{ GLenum::GL_RELATIVE_VERTICAL_LINE_TO_NV, "GL_RELATIVE_VERTICAL_LINE_TO_NV" },
{ GLenum::GL_RELEASED_APPLE, "GL_RELEASED_APPLE" },
{ GLenum::GL_RENDER, "GL_RENDER" },
{ GLenum::GL_RENDER_GPU_MASK_NV, "GL_RENDER_GPU_MASK_NV" },
{ GLenum::GL_RENDER_MODE, "GL_RENDER_MODE" },
{ GLenum::GL_RENDERBUFFER, "GL_RENDERBUFFER" },
{ GLenum::GL_RENDERBUFFER_ALPHA_SIZE, "GL_RENDERBUFFER_ALPHA_SIZE" },
{ GLenum::GL_RENDERBUFFER_ALPHA_SIZE_EXT, "GL_RENDERBUFFER_ALPHA_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_BINDING, "GL_RENDERBUFFER_BINDING" },
{ GLenum::GL_RENDERBUFFER_BINDING_EXT, "GL_RENDERBUFFER_BINDING_EXT" },
{ GLenum::GL_RENDERBUFFER_BLUE_SIZE, "GL_RENDERBUFFER_BLUE_SIZE" },
{ GLenum::GL_RENDERBUFFER_BLUE_SIZE_EXT, "GL_RENDERBUFFER_BLUE_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_COLOR_SAMPLES_NV, "GL_RENDERBUFFER_COLOR_SAMPLES_NV" },
{ GLenum::GL_RENDERBUFFER_COVERAGE_SAMPLES_NV, "GL_RENDERBUFFER_COVERAGE_SAMPLES_NV" },
{ GLenum::GL_RENDERBUFFER_DEPTH_SIZE, "GL_RENDERBUFFER_DEPTH_SIZE" },
{ GLenum::GL_RENDERBUFFER_DEPTH_SIZE_EXT, "GL_RENDERBUFFER_DEPTH_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_EXT, "GL_RENDERBUFFER_EXT" },
{ GLenum::GL_RENDERBUFFER_FREE_MEMORY_ATI, "GL_RENDERBUFFER_FREE_MEMORY_ATI" },
{ GLenum::GL_RENDERBUFFER_GREEN_SIZE, "GL_RENDERBUFFER_GREEN_SIZE" },
{ GLenum::GL_RENDERBUFFER_GREEN_SIZE_EXT, "GL_RENDERBUFFER_GREEN_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_HEIGHT, "GL_RENDERBUFFER_HEIGHT" },
{ GLenum::GL_RENDERBUFFER_HEIGHT_EXT, "GL_RENDERBUFFER_HEIGHT_EXT" },
{ GLenum::GL_RENDERBUFFER_INTERNAL_FORMAT, "GL_RENDERBUFFER_INTERNAL_FORMAT" },
{ GLenum::GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT" },
{ GLenum::GL_RENDERBUFFER_RED_SIZE, "GL_RENDERBUFFER_RED_SIZE" },
{ GLenum::GL_RENDERBUFFER_RED_SIZE_EXT, "GL_RENDERBUFFER_RED_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_SAMPLES, "GL_RENDERBUFFER_SAMPLES" },
{ GLenum::GL_RENDERBUFFER_SAMPLES_EXT, "GL_RENDERBUFFER_SAMPLES_EXT" },
{ GLenum::GL_RENDERBUFFER_STENCIL_SIZE, "GL_RENDERBUFFER_STENCIL_SIZE" },
{ GLenum::GL_RENDERBUFFER_STENCIL_SIZE_EXT, "GL_RENDERBUFFER_STENCIL_SIZE_EXT" },
{ GLenum::GL_RENDERBUFFER_STORAGE_SAMPLES_AMD, "GL_RENDERBUFFER_STORAGE_SAMPLES_AMD" },
{ GLenum::GL_RENDERBUFFER_WIDTH, "GL_RENDERBUFFER_WIDTH" },
{ GLenum::GL_RENDERBUFFER_WIDTH_EXT, "GL_RENDERBUFFER_WIDTH_EXT" },
{ GLenum::GL_RENDERER, "GL_RENDERER" },
{ GLenum::GL_REPEAT, "GL_REPEAT" },
{ GLenum::GL_REPLACE, "GL_REPLACE" },
{ GLenum::GL_REPLACE_EXT, "GL_REPLACE_EXT" },
{ GLenum::GL_REPLACE_MIDDLE_SUN, "GL_REPLACE_MIDDLE_SUN" },
{ GLenum::GL_REPLACE_OLDEST_SUN, "GL_REPLACE_OLDEST_SUN" },
{ GLenum::GL_REPLACE_VALUE_AMD, "GL_REPLACE_VALUE_AMD" },
{ GLenum::GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN, "GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN" },
{ GLenum::GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN, "GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN" },
{ GLenum::GL_REPLACEMENT_CODE_ARRAY_SUN, "GL_REPLACEMENT_CODE_ARRAY_SUN" },
{ GLenum::GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN, "GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN" },
{ GLenum::GL_REPLACEMENT_CODE_SUN, "GL_REPLACEMENT_CODE_SUN" },
{ GLenum::GL_REPLICATE_BORDER, "GL_REPLICATE_BORDER" },
{ GLenum::GL_REPLICATE_BORDER_HP, "GL_REPLICATE_BORDER_HP" },
{ GLenum::GL_REPRESENTATIVE_FRAGMENT_TEST_NV, "GL_REPRESENTATIVE_FRAGMENT_TEST_NV" },
{ GLenum::GL_RESAMPLE_AVERAGE_OML, "GL_RESAMPLE_AVERAGE_OML" },
{ GLenum::GL_RESAMPLE_DECIMATE_OML, "GL_RESAMPLE_DECIMATE_OML" },
{ GLenum::GL_RESAMPLE_DECIMATE_SGIX, "GL_RESAMPLE_DECIMATE_SGIX" },
{ GLenum::GL_RESAMPLE_REPLICATE_OML, "GL_RESAMPLE_REPLICATE_OML" },
{ GLenum::GL_RESAMPLE_REPLICATE_SGIX, "GL_RESAMPLE_REPLICATE_SGIX" },
{ GLenum::GL_RESAMPLE_ZERO_FILL_OML, "GL_RESAMPLE_ZERO_FILL_OML" },
{ GLenum::GL_RESAMPLE_ZERO_FILL_SGIX, "GL_RESAMPLE_ZERO_FILL_SGIX" },
{ GLenum::GL_RESCALE_NORMAL, "GL_RESCALE_NORMAL" },
{ GLenum::GL_RESCALE_NORMAL_EXT, "GL_RESCALE_NORMAL_EXT" },
{ GLenum::GL_RESET_NOTIFICATION_STRATEGY, "GL_RESET_NOTIFICATION_STRATEGY" },
{ GLenum::GL_RESET_NOTIFICATION_STRATEGY_ARB, "GL_RESET_NOTIFICATION_STRATEGY_ARB" },
{ GLenum::GL_RESET_NOTIFICATION_STRATEGY_KHR, "GL_RESET_NOTIFICATION_STRATEGY_KHR" },
{ GLenum::GL_RESTART_PATH_NV, "GL_RESTART_PATH_NV" },
{ GLenum::GL_RESTART_SUN, "GL_RESTART_SUN" },
{ GLenum::GL_RETAINED_APPLE, "GL_RETAINED_APPLE" },
{ GLenum::GL_RETURN, "GL_RETURN" },
{ GLenum::GL_RG, "GL_RG" },
{ GLenum::GL_RG16, "GL_RG16" },
{ GLenum::GL_RG16_SNORM, "GL_RG16_SNORM" },
{ GLenum::GL_RG16F, "GL_RG16F" },
{ GLenum::GL_RG16I, "GL_RG16I" },
{ GLenum::GL_RG16UI, "GL_RG16UI" },
{ GLenum::GL_RG32F, "GL_RG32F" },
{ GLenum::GL_RG32I, "GL_RG32I" },
{ GLenum::GL_RG32UI, "GL_RG32UI" },
{ GLenum::GL_RG8, "GL_RG8" },
{ GLenum::GL_RG8_SNORM, "GL_RG8_SNORM" },
{ GLenum::GL_RG8I, "GL_RG8I" },
{ GLenum::GL_RG8UI, "GL_RG8UI" },
{ GLenum::GL_RG_INTEGER, "GL_RG_INTEGER" },
{ GLenum::GL_RG_SNORM, "GL_RG_SNORM" },
{ GLenum::GL_RGB, "GL_RGB" },
{ GLenum::GL_RGB10, "GL_RGB10" },
{ GLenum::GL_RGB10_A2, "GL_RGB10_A2" },
{ GLenum::GL_RGB10_A2_EXT, "GL_RGB10_A2_EXT" },
{ GLenum::GL_RGB10_A2UI, "GL_RGB10_A2UI" },
{ GLenum::GL_RGB10_EXT, "GL_RGB10_EXT" },
{ GLenum::GL_RGB12, "GL_RGB12" },
{ GLenum::GL_RGB12_EXT, "GL_RGB12_EXT" },
{ GLenum::GL_RGB16, "GL_RGB16" },
{ GLenum::GL_RGB16_EXT, "GL_RGB16_EXT" },
{ GLenum::GL_RGB16_SNORM, "GL_RGB16_SNORM" },
{ GLenum::GL_RGB16F, "GL_RGB16F" },
{ GLenum::GL_RGB16F_ARB, "GL_RGB16F_ARB" },
{ GLenum::GL_RGB16I, "GL_RGB16I" },
{ GLenum::GL_RGB16I_EXT, "GL_RGB16I_EXT" },
{ GLenum::GL_RGB16UI, "GL_RGB16UI" },
{ GLenum::GL_RGB16UI_EXT, "GL_RGB16UI_EXT" },
{ GLenum::GL_RGB2_EXT, "GL_RGB2_EXT" },
{ GLenum::GL_RGB32F, "GL_RGB32F" },
{ GLenum::GL_RGB32F_ARB, "GL_RGB32F_ARB" },
{ GLenum::GL_RGB32I, "GL_RGB32I" },
{ GLenum::GL_RGB32I_EXT, "GL_RGB32I_EXT" },
{ GLenum::GL_RGB32UI, "GL_RGB32UI" },
{ GLenum::GL_RGB32UI_EXT, "GL_RGB32UI_EXT" },
{ GLenum::GL_RGB4, "GL_RGB4" },
{ GLenum::GL_RGB4_EXT, "GL_RGB4_EXT" },
{ GLenum::GL_RGB4_S3TC, "GL_RGB4_S3TC" },
{ GLenum::GL_RGB5, "GL_RGB5" },
{ GLenum::GL_RGB565, "GL_RGB565" },
{ GLenum::GL_RGB5_A1, "GL_RGB5_A1" },
{ GLenum::GL_RGB5_A1_EXT, "GL_RGB5_A1_EXT" },
{ GLenum::GL_RGB5_EXT, "GL_RGB5_EXT" },
{ GLenum::GL_RGB8, "GL_RGB8" },
{ GLenum::GL_RGB8_EXT, "GL_RGB8_EXT" },
{ GLenum::GL_RGB8_SNORM, "GL_RGB8_SNORM" },
{ GLenum::GL_RGB8I, "GL_RGB8I" },
{ GLenum::GL_RGB8I_EXT, "GL_RGB8I_EXT" },
{ GLenum::GL_RGB8UI, "GL_RGB8UI" },
{ GLenum::GL_RGB8UI_EXT, "GL_RGB8UI_EXT" },
{ GLenum::GL_RGB9_E5, "GL_RGB9_E5" },
{ GLenum::GL_RGB9_E5_EXT, "GL_RGB9_E5_EXT" },
{ GLenum::GL_RGB_422_APPLE, "GL_RGB_422_APPLE" },
{ GLenum::GL_RGB_FLOAT16_APPLE, "GL_RGB_FLOAT16_APPLE" },
{ GLenum::GL_RGB_FLOAT16_ATI, "GL_RGB_FLOAT16_ATI" },
{ GLenum::GL_RGB_FLOAT32_APPLE, "GL_RGB_FLOAT32_APPLE" },
{ GLenum::GL_RGB_FLOAT32_ATI, "GL_RGB_FLOAT32_ATI" },
{ GLenum::GL_RGB_INTEGER, "GL_RGB_INTEGER" },
{ GLenum::GL_RGB_INTEGER_EXT, "GL_RGB_INTEGER_EXT" },
{ GLenum::GL_RGB_RAW_422_APPLE, "GL_RGB_RAW_422_APPLE" },
{ GLenum::GL_RGB_S3TC, "GL_RGB_S3TC" },
{ GLenum::GL_RGB_SCALE, "GL_RGB_SCALE" },
{ GLenum::GL_RGB_SCALE_ARB, "GL_RGB_SCALE_ARB" },
{ GLenum::GL_RGB_SCALE_EXT, "GL_RGB_SCALE_EXT" },
{ GLenum::GL_RGB_SNORM, "GL_RGB_SNORM" },
{ GLenum::GL_RGBA, "GL_RGBA" },
{ GLenum::GL_RGBA12, "GL_RGBA12" },
{ GLenum::GL_RGBA12_EXT, "GL_RGBA12_EXT" },
{ GLenum::GL_RGBA16, "GL_RGBA16" },
{ GLenum::GL_RGBA16_EXT, "GL_RGBA16_EXT" },
{ GLenum::GL_RGBA16_SNORM, "GL_RGBA16_SNORM" },
{ GLenum::GL_RGBA16F, "GL_RGBA16F" },
{ GLenum::GL_RGBA16F_ARB, "GL_RGBA16F_ARB" },
{ GLenum::GL_RGBA16I, "GL_RGBA16I" },
{ GLenum::GL_RGBA16I_EXT, "GL_RGBA16I_EXT" },
{ GLenum::GL_RGBA16UI, "GL_RGBA16UI" },
{ GLenum::GL_RGBA16UI_EXT, "GL_RGBA16UI_EXT" },
{ GLenum::GL_RGBA2, "GL_RGBA2" },
{ GLenum::GL_RGBA2_EXT, "GL_RGBA2_EXT" },
{ GLenum::GL_RGBA32F, "GL_RGBA32F" },
{ GLenum::GL_RGBA32F_ARB, "GL_RGBA32F_ARB" },
{ GLenum::GL_RGBA32I, "GL_RGBA32I" },
{ GLenum::GL_RGBA32I_EXT, "GL_RGBA32I_EXT" },
{ GLenum::GL_RGBA32UI, "GL_RGBA32UI" },
{ GLenum::GL_RGBA32UI_EXT, "GL_RGBA32UI_EXT" },
{ GLenum::GL_RGBA4, "GL_RGBA4" },
{ GLenum::GL_RGBA4_DXT5_S3TC, "GL_RGBA4_DXT5_S3TC" },
{ GLenum::GL_RGBA4_EXT, "GL_RGBA4_EXT" },
{ GLenum::GL_RGBA4_S3TC, "GL_RGBA4_S3TC" },
{ GLenum::GL_RGBA8, "GL_RGBA8" },
{ GLenum::GL_RGBA8_EXT, "GL_RGBA8_EXT" },
{ GLenum::GL_RGBA8_SNORM, "GL_RGBA8_SNORM" },
{ GLenum::GL_RGBA8I, "GL_RGBA8I" },
{ GLenum::GL_RGBA8I_EXT, "GL_RGBA8I_EXT" },
{ GLenum::GL_RGBA8UI, "GL_RGBA8UI" },
{ GLenum::GL_RGBA8UI_EXT, "GL_RGBA8UI_EXT" },
{ GLenum::GL_RGBA_DXT5_S3TC, "GL_RGBA_DXT5_S3TC" },
{ GLenum::GL_RGBA_FLOAT16_APPLE, "GL_RGBA_FLOAT16_APPLE" },
{ GLenum::GL_RGBA_FLOAT16_ATI, "GL_RGBA_FLOAT16_ATI" },
{ GLenum::GL_RGBA_FLOAT32_APPLE, "GL_RGBA_FLOAT32_APPLE" },
{ GLenum::GL_RGBA_FLOAT32_ATI, "GL_RGBA_FLOAT32_ATI" },
{ GLenum::GL_RGBA_FLOAT_MODE_ARB, "GL_RGBA_FLOAT_MODE_ARB" },
{ GLenum::GL_RGBA_FLOAT_MODE_ATI, "GL_RGBA_FLOAT_MODE_ATI" },
{ GLenum::GL_RGBA_INTEGER, "GL_RGBA_INTEGER" },
{ GLenum::GL_RGBA_INTEGER_EXT, "GL_RGBA_INTEGER_EXT" },
{ GLenum::GL_RGBA_INTEGER_MODE_EXT, "GL_RGBA_INTEGER_MODE_EXT" },
{ GLenum::GL_RGBA_MODE, "GL_RGBA_MODE" },
{ GLenum::GL_RGBA_S3TC, "GL_RGBA_S3TC" },
{ GLenum::GL_RGBA_SIGNED_COMPONENTS_EXT, "GL_RGBA_SIGNED_COMPONENTS_EXT" },
{ GLenum::GL_RGBA_SNORM, "GL_RGBA_SNORM" },
{ GLenum::GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV" },
{ GLenum::GL_RIGHT, "GL_RIGHT" },
{ GLenum::GL_ROUND_NV, "GL_ROUND_NV" },
{ GLenum::GL_ROUNDED_RECT2_NV, "GL_ROUNDED_RECT2_NV" },
{ GLenum::GL_ROUNDED_RECT4_NV, "GL_ROUNDED_RECT4_NV" },
{ GLenum::GL_ROUNDED_RECT8_NV, "GL_ROUNDED_RECT8_NV" },
{ GLenum::GL_ROUNDED_RECT_NV, "GL_ROUNDED_RECT_NV" },
{ GLenum::GL_S, "GL_S" },
{ GLenum::GL_SAMPLE_ALPHA_TO_COVERAGE, "GL_SAMPLE_ALPHA_TO_COVERAGE" },
{ GLenum::GL_SAMPLE_ALPHA_TO_COVERAGE_ARB, "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB" },
{ GLenum::GL_SAMPLE_ALPHA_TO_MASK_EXT, "GL_SAMPLE_ALPHA_TO_MASK_EXT" },
{ GLenum::GL_SAMPLE_ALPHA_TO_MASK_SGIS, "GL_SAMPLE_ALPHA_TO_MASK_SGIS" },
{ GLenum::GL_SAMPLE_ALPHA_TO_ONE, "GL_SAMPLE_ALPHA_TO_ONE" },
{ GLenum::GL_SAMPLE_ALPHA_TO_ONE_ARB, "GL_SAMPLE_ALPHA_TO_ONE_ARB" },
{ GLenum::GL_SAMPLE_ALPHA_TO_ONE_EXT, "GL_SAMPLE_ALPHA_TO_ONE_EXT" },
{ GLenum::GL_SAMPLE_ALPHA_TO_ONE_SGIS, "GL_SAMPLE_ALPHA_TO_ONE_SGIS" },
{ GLenum::GL_SAMPLE_BUFFERS, "GL_SAMPLE_BUFFERS" },
{ GLenum::GL_SAMPLE_BUFFERS_3DFX, "GL_SAMPLE_BUFFERS_3DFX" },
{ GLenum::GL_SAMPLE_BUFFERS_ARB, "GL_SAMPLE_BUFFERS_ARB" },
{ GLenum::GL_SAMPLE_BUFFERS_EXT, "GL_SAMPLE_BUFFERS_EXT" },
{ GLenum::GL_SAMPLE_BUFFERS_SGIS, "GL_SAMPLE_BUFFERS_SGIS" },
{ GLenum::GL_SAMPLE_COVERAGE, "GL_SAMPLE_COVERAGE" },
{ GLenum::GL_SAMPLE_COVERAGE_ARB, "GL_SAMPLE_COVERAGE_ARB" },
{ GLenum::GL_SAMPLE_COVERAGE_INVERT, "GL_SAMPLE_COVERAGE_INVERT" },
{ GLenum::GL_SAMPLE_COVERAGE_INVERT_ARB, "GL_SAMPLE_COVERAGE_INVERT_ARB" },
{ GLenum::GL_SAMPLE_COVERAGE_VALUE, "GL_SAMPLE_COVERAGE_VALUE" },
{ GLenum::GL_SAMPLE_COVERAGE_VALUE_ARB, "GL_SAMPLE_COVERAGE_VALUE_ARB" },
{ GLenum::GL_SAMPLE_LOCATION_ARB, "GL_SAMPLE_LOCATION_ARB" },
{ GLenum::GL_SAMPLE_LOCATION_NV, "GL_SAMPLE_LOCATION_NV" },
{ GLenum::GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB, "GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB" },
{ GLenum::GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV, "GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV" },
{ GLenum::GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB, "GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB" },
{ GLenum::GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV, "GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV" },
{ GLenum::GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB, "GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB" },
{ GLenum::GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV, "GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV" },
{ GLenum::GL_SAMPLE_MASK, "GL_SAMPLE_MASK" },
{ GLenum::GL_SAMPLE_MASK_EXT, "GL_SAMPLE_MASK_EXT" },
{ GLenum::GL_SAMPLE_MASK_INVERT_EXT, "GL_SAMPLE_MASK_INVERT_EXT" },
{ GLenum::GL_SAMPLE_MASK_INVERT_SGIS, "GL_SAMPLE_MASK_INVERT_SGIS" },
{ GLenum::GL_SAMPLE_MASK_NV, "GL_SAMPLE_MASK_NV" },
{ GLenum::GL_SAMPLE_MASK_SGIS, "GL_SAMPLE_MASK_SGIS" },
{ GLenum::GL_SAMPLE_MASK_VALUE, "GL_SAMPLE_MASK_VALUE" },
{ GLenum::GL_SAMPLE_MASK_VALUE_EXT, "GL_SAMPLE_MASK_VALUE_EXT" },
{ GLenum::GL_SAMPLE_MASK_VALUE_NV, "GL_SAMPLE_MASK_VALUE_NV" },
{ GLenum::GL_SAMPLE_MASK_VALUE_SGIS, "GL_SAMPLE_MASK_VALUE_SGIS" },
{ GLenum::GL_SAMPLE_PATTERN_EXT, "GL_SAMPLE_PATTERN_EXT" },
{ GLenum::GL_SAMPLE_PATTERN_SGIS, "GL_SAMPLE_PATTERN_SGIS" },
{ GLenum::GL_SAMPLE_POSITION, "GL_SAMPLE_POSITION" },
{ GLenum::GL_SAMPLE_POSITION_NV, "GL_SAMPLE_POSITION_NV" },
{ GLenum::GL_SAMPLE_SHADING, "GL_SAMPLE_SHADING" },
{ GLenum::GL_SAMPLE_SHADING_ARB, "GL_SAMPLE_SHADING_ARB" },
{ GLenum::GL_SAMPLER, "GL_SAMPLER" },
{ GLenum::GL_SAMPLER_1D, "GL_SAMPLER_1D" },
{ GLenum::GL_SAMPLER_1D_ARB, "GL_SAMPLER_1D_ARB" },
{ GLenum::GL_SAMPLER_1D_ARRAY, "GL_SAMPLER_1D_ARRAY" },
{ GLenum::GL_SAMPLER_1D_ARRAY_EXT, "GL_SAMPLER_1D_ARRAY_EXT" },
{ GLenum::GL_SAMPLER_1D_ARRAY_SHADOW, "GL_SAMPLER_1D_ARRAY_SHADOW" },
{ GLenum::GL_SAMPLER_1D_ARRAY_SHADOW_EXT, "GL_SAMPLER_1D_ARRAY_SHADOW_EXT" },
{ GLenum::GL_SAMPLER_1D_SHADOW, "GL_SAMPLER_1D_SHADOW" },
{ GLenum::GL_SAMPLER_1D_SHADOW_ARB, "GL_SAMPLER_1D_SHADOW_ARB" },
{ GLenum::GL_SAMPLER_2D, "GL_SAMPLER_2D" },
{ GLenum::GL_SAMPLER_2D_ARB, "GL_SAMPLER_2D_ARB" },
{ GLenum::GL_SAMPLER_2D_ARRAY, "GL_SAMPLER_2D_ARRAY" },
{ GLenum::GL_SAMPLER_2D_ARRAY_EXT, "GL_SAMPLER_2D_ARRAY_EXT" },
{ GLenum::GL_SAMPLER_2D_ARRAY_SHADOW, "GL_SAMPLER_2D_ARRAY_SHADOW" },
{ GLenum::GL_SAMPLER_2D_ARRAY_SHADOW_EXT, "GL_SAMPLER_2D_ARRAY_SHADOW_EXT" },
{ GLenum::GL_SAMPLER_2D_MULTISAMPLE, "GL_SAMPLER_2D_MULTISAMPLE" },
{ GLenum::GL_SAMPLER_2D_MULTISAMPLE_ARRAY, "GL_SAMPLER_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_SAMPLER_2D_RECT, "GL_SAMPLER_2D_RECT" },
{ GLenum::GL_SAMPLER_2D_RECT_ARB, "GL_SAMPLER_2D_RECT_ARB" },
{ GLenum::GL_SAMPLER_2D_RECT_SHADOW, "GL_SAMPLER_2D_RECT_SHADOW" },
{ GLenum::GL_SAMPLER_2D_RECT_SHADOW_ARB, "GL_SAMPLER_2D_RECT_SHADOW_ARB" },
{ GLenum::GL_SAMPLER_2D_SHADOW, "GL_SAMPLER_2D_SHADOW" },
{ GLenum::GL_SAMPLER_2D_SHADOW_ARB, "GL_SAMPLER_2D_SHADOW_ARB" },
{ GLenum::GL_SAMPLER_3D, "GL_SAMPLER_3D" },
{ GLenum::GL_SAMPLER_3D_ARB, "GL_SAMPLER_3D_ARB" },
{ GLenum::GL_SAMPLER_BINDING, "GL_SAMPLER_BINDING" },
{ GLenum::GL_SAMPLER_BUFFER, "GL_SAMPLER_BUFFER" },
{ GLenum::GL_SAMPLER_BUFFER_AMD, "GL_SAMPLER_BUFFER_AMD" },
{ GLenum::GL_SAMPLER_BUFFER_EXT, "GL_SAMPLER_BUFFER_EXT" },
{ GLenum::GL_SAMPLER_CUBE, "GL_SAMPLER_CUBE" },
{ GLenum::GL_SAMPLER_CUBE_ARB, "GL_SAMPLER_CUBE_ARB" },
{ GLenum::GL_SAMPLER_CUBE_MAP_ARRAY, "GL_SAMPLER_CUBE_MAP_ARRAY" },
{ GLenum::GL_SAMPLER_CUBE_MAP_ARRAY_ARB, "GL_SAMPLER_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW" },
{ GLenum::GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB, "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB" },
{ GLenum::GL_SAMPLER_CUBE_SHADOW, "GL_SAMPLER_CUBE_SHADOW" },
{ GLenum::GL_SAMPLER_CUBE_SHADOW_EXT, "GL_SAMPLER_CUBE_SHADOW_EXT" },
{ GLenum::GL_SAMPLER_KHR, "GL_SAMPLER_KHR" },
{ GLenum::GL_SAMPLER_OBJECT_AMD, "GL_SAMPLER_OBJECT_AMD" },
{ GLenum::GL_SAMPLER_RENDERBUFFER_NV, "GL_SAMPLER_RENDERBUFFER_NV" },
{ GLenum::GL_SAMPLES, "GL_SAMPLES" },
{ GLenum::GL_SAMPLES_3DFX, "GL_SAMPLES_3DFX" },
{ GLenum::GL_SAMPLES_ARB, "GL_SAMPLES_ARB" },
{ GLenum::GL_SAMPLES_EXT, "GL_SAMPLES_EXT" },
{ GLenum::GL_SAMPLES_PASSED, "GL_SAMPLES_PASSED" },
{ GLenum::GL_SAMPLES_PASSED_ARB, "GL_SAMPLES_PASSED_ARB" },
{ GLenum::GL_SAMPLES_SGIS, "GL_SAMPLES_SGIS" },
{ GLenum::GL_SCALAR_EXT, "GL_SCALAR_EXT" },
{ GLenum::GL_SCALE_BY_FOUR_NV, "GL_SCALE_BY_FOUR_NV" },
{ GLenum::GL_SCALE_BY_ONE_HALF_NV, "GL_SCALE_BY_ONE_HALF_NV" },
{ GLenum::GL_SCALE_BY_TWO_NV, "GL_SCALE_BY_TWO_NV" },
{ GLenum::GL_SCALEBIAS_HINT_SGIX, "GL_SCALEBIAS_HINT_SGIX" },
{ GLenum::GL_SCALED_RESOLVE_FASTEST_EXT, "GL_SCALED_RESOLVE_FASTEST_EXT" },
{ GLenum::GL_SCALED_RESOLVE_NICEST_EXT, "GL_SCALED_RESOLVE_NICEST_EXT" },
{ GLenum::GL_SCISSOR_BOX, "GL_SCISSOR_BOX" },
{ GLenum::GL_SCISSOR_BOX_EXCLUSIVE_NV, "GL_SCISSOR_BOX_EXCLUSIVE_NV" },
{ GLenum::GL_SCISSOR_COMMAND_NV, "GL_SCISSOR_COMMAND_NV" },
{ GLenum::GL_SCISSOR_TEST, "GL_SCISSOR_TEST" },
{ GLenum::GL_SCISSOR_TEST_EXCLUSIVE_NV, "GL_SCISSOR_TEST_EXCLUSIVE_NV" },
{ GLenum::GL_SCREEN_COORDINATES_REND, "GL_SCREEN_COORDINATES_REND" },
{ GLenum::GL_SCREEN_KHR, "GL_SCREEN_KHR" },
{ GLenum::GL_SCREEN_NV, "GL_SCREEN_NV" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY, "GL_SECONDARY_COLOR_ARRAY" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV, "GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING, "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_EXT, "GL_SECONDARY_COLOR_ARRAY_EXT" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_LENGTH_NV, "GL_SECONDARY_COLOR_ARRAY_LENGTH_NV" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_LIST_IBM, "GL_SECONDARY_COLOR_ARRAY_LIST_IBM" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM, "GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_POINTER, "GL_SECONDARY_COLOR_ARRAY_POINTER" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_POINTER_EXT, "GL_SECONDARY_COLOR_ARRAY_POINTER_EXT" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_SIZE, "GL_SECONDARY_COLOR_ARRAY_SIZE" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, "GL_SECONDARY_COLOR_ARRAY_SIZE_EXT" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_STRIDE, "GL_SECONDARY_COLOR_ARRAY_STRIDE" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, "GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_TYPE, "GL_SECONDARY_COLOR_ARRAY_TYPE" },
{ GLenum::GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, "GL_SECONDARY_COLOR_ARRAY_TYPE_EXT" },
{ GLenum::GL_SECONDARY_COLOR_NV, "GL_SECONDARY_COLOR_NV" },
{ GLenum::GL_SECONDARY_INTERPOLATOR_ATI, "GL_SECONDARY_INTERPOLATOR_ATI" },
{ GLenum::GL_SELECT, "GL_SELECT" },
{ GLenum::GL_SELECTION_BUFFER_POINTER, "GL_SELECTION_BUFFER_POINTER" },
{ GLenum::GL_SELECTION_BUFFER_SIZE, "GL_SELECTION_BUFFER_SIZE" },
{ GLenum::GL_SEPARABLE_2D, "GL_SEPARABLE_2D" },
{ GLenum::GL_SEPARABLE_2D_EXT, "GL_SEPARABLE_2D_EXT" },
{ GLenum::GL_SEPARATE_ATTRIBS, "GL_SEPARATE_ATTRIBS" },
{ GLenum::GL_SEPARATE_ATTRIBS_EXT, "GL_SEPARATE_ATTRIBS_EXT" },
{ GLenum::GL_SEPARATE_ATTRIBS_NV, "GL_SEPARATE_ATTRIBS_NV" },
{ GLenum::GL_SEPARATE_SPECULAR_COLOR, "GL_SEPARATE_SPECULAR_COLOR" },
{ GLenum::GL_SEPARATE_SPECULAR_COLOR_EXT, "GL_SEPARATE_SPECULAR_COLOR_EXT" },
{ GLenum::GL_SET, "GL_SET" },
{ GLenum::GL_SET_AMD, "GL_SET_AMD" },
{ GLenum::GL_SHADE_MODEL, "GL_SHADE_MODEL" },
{ GLenum::GL_SHADER, "GL_SHADER" },
{ GLenum::GL_SHADER_BINARY_FORMAT_SPIR_V, "GL_SHADER_BINARY_FORMAT_SPIR_V" },
{ GLenum::GL_SHADER_BINARY_FORMAT_SPIR_V_ARB, "GL_SHADER_BINARY_FORMAT_SPIR_V_ARB" },
{ GLenum::GL_SHADER_BINARY_FORMATS, "GL_SHADER_BINARY_FORMATS" },
{ GLenum::GL_SHADER_COMPILER, "GL_SHADER_COMPILER" },
{ GLenum::GL_SHADER_CONSISTENT_NV, "GL_SHADER_CONSISTENT_NV" },
{ GLenum::GL_SHADER_IMAGE_ATOMIC, "GL_SHADER_IMAGE_ATOMIC" },
{ GLenum::GL_SHADER_IMAGE_LOAD, "GL_SHADER_IMAGE_LOAD" },
{ GLenum::GL_SHADER_IMAGE_STORE, "GL_SHADER_IMAGE_STORE" },
{ GLenum::GL_SHADER_INCLUDE_ARB, "GL_SHADER_INCLUDE_ARB" },
{ GLenum::GL_SHADER_KHR, "GL_SHADER_KHR" },
{ GLenum::GL_SHADER_OBJECT_ARB, "GL_SHADER_OBJECT_ARB" },
{ GLenum::GL_SHADER_OBJECT_EXT, "GL_SHADER_OBJECT_EXT" },
{ GLenum::GL_SHADER_OPERATION_NV, "GL_SHADER_OPERATION_NV" },
{ GLenum::GL_SHADER_SOURCE_LENGTH, "GL_SHADER_SOURCE_LENGTH" },
{ GLenum::GL_SHADER_STORAGE_BLOCK, "GL_SHADER_STORAGE_BLOCK" },
{ GLenum::GL_SHADER_STORAGE_BUFFER, "GL_SHADER_STORAGE_BUFFER" },
{ GLenum::GL_SHADER_STORAGE_BUFFER_BINDING, "GL_SHADER_STORAGE_BUFFER_BINDING" },
{ GLenum::GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT" },
{ GLenum::GL_SHADER_STORAGE_BUFFER_SIZE, "GL_SHADER_STORAGE_BUFFER_SIZE" },
{ GLenum::GL_SHADER_STORAGE_BUFFER_START, "GL_SHADER_STORAGE_BUFFER_START" },
{ GLenum::GL_SHADER_TYPE, "GL_SHADER_TYPE" },
{ GLenum::GL_SHADING_LANGUAGE_VERSION, "GL_SHADING_LANGUAGE_VERSION" },
{ GLenum::GL_SHADING_LANGUAGE_VERSION_ARB, "GL_SHADING_LANGUAGE_VERSION_ARB" },
{ GLenum::GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV, "GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV, "GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV" },
{ GLenum::GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV, "GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV" },
{ GLenum::GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, "GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV" },
{ GLenum::GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, "GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV" },
{ GLenum::GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, "GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV" },
{ GLenum::GL_SHADING_RATE_IMAGE_BINDING_NV, "GL_SHADING_RATE_IMAGE_BINDING_NV" },
{ GLenum::GL_SHADING_RATE_IMAGE_NV, "GL_SHADING_RATE_IMAGE_NV" },
{ GLenum::GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV, "GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV" },
{ GLenum::GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV, "GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV" },
{ GLenum::GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV, "GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV" },
{ GLenum::GL_SHADING_RATE_NO_INVOCATIONS_NV, "GL_SHADING_RATE_NO_INVOCATIONS_NV" },
{ GLenum::GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV, "GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV" },
{ GLenum::GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV, "GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV" },
{ GLenum::GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV, "GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV" },
{ GLenum::GL_SHADOW_AMBIENT_SGIX, "GL_SHADOW_AMBIENT_SGIX" },
{ GLenum::GL_SHADOW_ATTENUATION_EXT, "GL_SHADOW_ATTENUATION_EXT" },
{ GLenum::GL_SHARED_EDGE_NV, "GL_SHARED_EDGE_NV" },
{ GLenum::GL_SHARED_TEXTURE_PALETTE_EXT, "GL_SHARED_TEXTURE_PALETTE_EXT" },
{ GLenum::GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS, "GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS" },
{ GLenum::GL_SHININESS, "GL_SHININESS" },
{ GLenum::GL_SHORT, "GL_SHORT" },
{ GLenum::GL_SIGNALED, "GL_SIGNALED" },
{ GLenum::GL_SIGNED_ALPHA8_NV, "GL_SIGNED_ALPHA8_NV" },
{ GLenum::GL_SIGNED_ALPHA_NV, "GL_SIGNED_ALPHA_NV" },
{ GLenum::GL_SIGNED_HILO16_NV, "GL_SIGNED_HILO16_NV" },
{ GLenum::GL_SIGNED_HILO8_NV, "GL_SIGNED_HILO8_NV" },
{ GLenum::GL_SIGNED_HILO_NV, "GL_SIGNED_HILO_NV" },
{ GLenum::GL_SIGNED_IDENTITY_NV, "GL_SIGNED_IDENTITY_NV" },
{ GLenum::GL_SIGNED_INTENSITY8_NV, "GL_SIGNED_INTENSITY8_NV" },
{ GLenum::GL_SIGNED_INTENSITY_NV, "GL_SIGNED_INTENSITY_NV" },
{ GLenum::GL_SIGNED_LUMINANCE8_ALPHA8_NV, "GL_SIGNED_LUMINANCE8_ALPHA8_NV" },
{ GLenum::GL_SIGNED_LUMINANCE8_NV, "GL_SIGNED_LUMINANCE8_NV" },
{ GLenum::GL_SIGNED_LUMINANCE_ALPHA_NV, "GL_SIGNED_LUMINANCE_ALPHA_NV" },
{ GLenum::GL_SIGNED_LUMINANCE_NV, "GL_SIGNED_LUMINANCE_NV" },
{ GLenum::GL_SIGNED_NEGATE_NV, "GL_SIGNED_NEGATE_NV" },
{ GLenum::GL_SIGNED_NORMALIZED, "GL_SIGNED_NORMALIZED" },
{ GLenum::GL_SIGNED_RGB8_NV, "GL_SIGNED_RGB8_NV" },
{ GLenum::GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV, "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV" },
{ GLenum::GL_SIGNED_RGB_NV, "GL_SIGNED_RGB_NV" },
{ GLenum::GL_SIGNED_RGB_UNSIGNED_ALPHA_NV, "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV" },
{ GLenum::GL_SIGNED_RGBA8_NV, "GL_SIGNED_RGBA8_NV" },
{ GLenum::GL_SIGNED_RGBA_NV, "GL_SIGNED_RGBA_NV" },
{ GLenum::GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST, "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST" },
{ GLenum::GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE, "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE" },
{ GLenum::GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST, "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST" },
{ GLenum::GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE, "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE" },
{ GLenum::GL_SINGLE_COLOR, "GL_SINGLE_COLOR" },
{ GLenum::GL_SINGLE_COLOR_EXT, "GL_SINGLE_COLOR_EXT" },
{ GLenum::GL_SKIP_COMPONENTS1_NV, "GL_SKIP_COMPONENTS1_NV" },
{ GLenum::GL_SKIP_COMPONENTS2_NV, "GL_SKIP_COMPONENTS2_NV" },
{ GLenum::GL_SKIP_COMPONENTS3_NV, "GL_SKIP_COMPONENTS3_NV" },
{ GLenum::GL_SKIP_COMPONENTS4_NV, "GL_SKIP_COMPONENTS4_NV" },
{ GLenum::GL_SKIP_DECODE_EXT, "GL_SKIP_DECODE_EXT" },
{ GLenum::GL_SKIP_MISSING_GLYPH_NV, "GL_SKIP_MISSING_GLYPH_NV" },
{ GLenum::GL_SLICE_ACCUM_SUN, "GL_SLICE_ACCUM_SUN" },
{ GLenum::GL_SLUMINANCE, "GL_SLUMINANCE" },
{ GLenum::GL_SLUMINANCE8, "GL_SLUMINANCE8" },
{ GLenum::GL_SLUMINANCE8_ALPHA8, "GL_SLUMINANCE8_ALPHA8" },
{ GLenum::GL_SLUMINANCE8_ALPHA8_EXT, "GL_SLUMINANCE8_ALPHA8_EXT" },
{ GLenum::GL_SLUMINANCE8_EXT, "GL_SLUMINANCE8_EXT" },
{ GLenum::GL_SLUMINANCE_ALPHA, "GL_SLUMINANCE_ALPHA" },
{ GLenum::GL_SLUMINANCE_ALPHA_EXT, "GL_SLUMINANCE_ALPHA_EXT" },
{ GLenum::GL_SLUMINANCE_EXT, "GL_SLUMINANCE_EXT" },
{ GLenum::GL_SM_COUNT_NV, "GL_SM_COUNT_NV" },
{ GLenum::GL_SMALL_CCW_ARC_TO_NV, "GL_SMALL_CCW_ARC_TO_NV" },
{ GLenum::GL_SMALL_CW_ARC_TO_NV, "GL_SMALL_CW_ARC_TO_NV" },
{ GLenum::GL_SMOOTH, "GL_SMOOTH" },
{ GLenum::GL_SMOOTH_CUBIC_CURVE_TO_NV, "GL_SMOOTH_CUBIC_CURVE_TO_NV" },
{ GLenum::GL_SMOOTH_LINE_WIDTH_GRANULARITY, "GL_SMOOTH_LINE_WIDTH_GRANULARITY" },
{ GLenum::GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE" },
{ GLenum::GL_SMOOTH_POINT_SIZE_GRANULARITY, "GL_SMOOTH_POINT_SIZE_GRANULARITY" },
{ GLenum::GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE" },
{ GLenum::GL_SMOOTH_QUADRATIC_CURVE_TO_NV, "GL_SMOOTH_QUADRATIC_CURVE_TO_NV" },
{ GLenum::GL_SOFTLIGHT_KHR, "GL_SOFTLIGHT_KHR" },
{ GLenum::GL_SOFTLIGHT_NV, "GL_SOFTLIGHT_NV" },
{ GLenum::GL_SOURCE0_ALPHA, "GL_SOURCE0_ALPHA" },
{ GLenum::GL_SOURCE0_ALPHA_ARB, "GL_SOURCE0_ALPHA_ARB" },
{ GLenum::GL_SOURCE0_ALPHA_EXT, "GL_SOURCE0_ALPHA_EXT" },
{ GLenum::GL_SOURCE0_RGB, "GL_SOURCE0_RGB" },
{ GLenum::GL_SOURCE0_RGB_ARB, "GL_SOURCE0_RGB_ARB" },
{ GLenum::GL_SOURCE0_RGB_EXT, "GL_SOURCE0_RGB_EXT" },
{ GLenum::GL_SOURCE1_ALPHA, "GL_SOURCE1_ALPHA" },
{ GLenum::GL_SOURCE1_ALPHA_ARB, "GL_SOURCE1_ALPHA_ARB" },
{ GLenum::GL_SOURCE1_ALPHA_EXT, "GL_SOURCE1_ALPHA_EXT" },
{ GLenum::GL_SOURCE1_RGB, "GL_SOURCE1_RGB" },
{ GLenum::GL_SOURCE1_RGB_ARB, "GL_SOURCE1_RGB_ARB" },
{ GLenum::GL_SOURCE1_RGB_EXT, "GL_SOURCE1_RGB_EXT" },
{ GLenum::GL_SOURCE2_ALPHA, "GL_SOURCE2_ALPHA" },
{ GLenum::GL_SOURCE2_ALPHA_ARB, "GL_SOURCE2_ALPHA_ARB" },
{ GLenum::GL_SOURCE2_ALPHA_EXT, "GL_SOURCE2_ALPHA_EXT" },
{ GLenum::GL_SOURCE2_RGB, "GL_SOURCE2_RGB" },
{ GLenum::GL_SOURCE2_RGB_ARB, "GL_SOURCE2_RGB_ARB" },
{ GLenum::GL_SOURCE2_RGB_EXT, "GL_SOURCE2_RGB_EXT" },
{ GLenum::GL_SOURCE3_ALPHA_NV, "GL_SOURCE3_ALPHA_NV" },
{ GLenum::GL_SOURCE3_RGB_NV, "GL_SOURCE3_RGB_NV" },
{ GLenum::GL_SPARE0_NV, "GL_SPARE0_NV" },
{ GLenum::GL_SPARE0_PLUS_SECONDARY_COLOR_NV, "GL_SPARE0_PLUS_SECONDARY_COLOR_NV" },
{ GLenum::GL_SPARE1_NV, "GL_SPARE1_NV" },
{ GLenum::GL_SPARSE_BUFFER_PAGE_SIZE_ARB, "GL_SPARSE_BUFFER_PAGE_SIZE_ARB" },
{ GLenum::GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB, "GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB" },
{ GLenum::GL_SPECULAR, "GL_SPECULAR" },
{ GLenum::GL_SPHERE_MAP, "GL_SPHERE_MAP" },
{ GLenum::GL_SPIR_V_BINARY, "GL_SPIR_V_BINARY" },
{ GLenum::GL_SPIR_V_BINARY_ARB, "GL_SPIR_V_BINARY_ARB" },
{ GLenum::GL_SPIR_V_EXTENSIONS, "GL_SPIR_V_EXTENSIONS" },
{ GLenum::GL_SPOT_CUTOFF, "GL_SPOT_CUTOFF" },
{ GLenum::GL_SPOT_DIRECTION, "GL_SPOT_DIRECTION" },
{ GLenum::GL_SPOT_EXPONENT, "GL_SPOT_EXPONENT" },
{ GLenum::GL_SPRITE_AXIAL_SGIX, "GL_SPRITE_AXIAL_SGIX" },
{ GLenum::GL_SPRITE_AXIS_SGIX, "GL_SPRITE_AXIS_SGIX" },
{ GLenum::GL_SPRITE_EYE_ALIGNED_SGIX, "GL_SPRITE_EYE_ALIGNED_SGIX" },
{ GLenum::GL_SPRITE_MODE_SGIX, "GL_SPRITE_MODE_SGIX" },
{ GLenum::GL_SPRITE_OBJECT_ALIGNED_SGIX, "GL_SPRITE_OBJECT_ALIGNED_SGIX" },
{ GLenum::GL_SPRITE_SGIX, "GL_SPRITE_SGIX" },
{ GLenum::GL_SPRITE_TRANSLATION_SGIX, "GL_SPRITE_TRANSLATION_SGIX" },
{ GLenum::GL_SQUARE_NV, "GL_SQUARE_NV" },
{ GLenum::GL_SR8_EXT, "GL_SR8_EXT" },
{ GLenum::GL_SRC0_ALPHA, "GL_SRC0_ALPHA" },
{ GLenum::GL_SRC0_RGB, "GL_SRC0_RGB" },
{ GLenum::GL_SRC1_ALPHA, "GL_SRC1_ALPHA" },
{ GLenum::GL_SRC1_COLOR, "GL_SRC1_COLOR" },
{ GLenum::GL_SRC1_RGB, "GL_SRC1_RGB" },
{ GLenum::GL_SRC2_ALPHA, "GL_SRC2_ALPHA" },
{ GLenum::GL_SRC2_RGB, "GL_SRC2_RGB" },
{ GLenum::GL_SRC_ALPHA, "GL_SRC_ALPHA" },
{ GLenum::GL_SRC_ALPHA_SATURATE, "GL_SRC_ALPHA_SATURATE" },
{ GLenum::GL_SRC_ATOP_NV, "GL_SRC_ATOP_NV" },
{ GLenum::GL_SRC_COLOR, "GL_SRC_COLOR" },
{ GLenum::GL_SRC_IN_NV, "GL_SRC_IN_NV" },
{ GLenum::GL_SRC_NV, "GL_SRC_NV" },
{ GLenum::GL_SRC_OUT_NV, "GL_SRC_OUT_NV" },
{ GLenum::GL_SRC_OVER_NV, "GL_SRC_OVER_NV" },
{ GLenum::GL_SRGB, "GL_SRGB" },
{ GLenum::GL_SRGB8, "GL_SRGB8" },
{ GLenum::GL_SRGB8_ALPHA8, "GL_SRGB8_ALPHA8" },
{ GLenum::GL_SRGB8_ALPHA8_EXT, "GL_SRGB8_ALPHA8_EXT" },
{ GLenum::GL_SRGB8_EXT, "GL_SRGB8_EXT" },
{ GLenum::GL_SRGB_ALPHA, "GL_SRGB_ALPHA" },
{ GLenum::GL_SRGB_ALPHA_EXT, "GL_SRGB_ALPHA_EXT" },
{ GLenum::GL_SRGB_DECODE_ARB, "GL_SRGB_DECODE_ARB" },
{ GLenum::GL_SRGB_EXT, "GL_SRGB_EXT" },
{ GLenum::GL_SRGB_READ, "GL_SRGB_READ" },
{ GLenum::GL_SRGB_WRITE, "GL_SRGB_WRITE" },
{ GLenum::GL_STACK_OVERFLOW, "GL_STACK_OVERFLOW" },
{ GLenum::GL_STACK_OVERFLOW_KHR, "GL_STACK_OVERFLOW_KHR" },
{ GLenum::GL_STACK_UNDERFLOW, "GL_STACK_UNDERFLOW" },
{ GLenum::GL_STACK_UNDERFLOW_KHR, "GL_STACK_UNDERFLOW_KHR" },
{ GLenum::GL_STANDARD_FONT_FORMAT_NV, "GL_STANDARD_FONT_FORMAT_NV" },
{ GLenum::GL_STANDARD_FONT_NAME_NV, "GL_STANDARD_FONT_NAME_NV" },
{ GLenum::GL_STATIC_ATI, "GL_STATIC_ATI" },
{ GLenum::GL_STATIC_COPY, "GL_STATIC_COPY" },
{ GLenum::GL_STATIC_COPY_ARB, "GL_STATIC_COPY_ARB" },
{ GLenum::GL_STATIC_DRAW, "GL_STATIC_DRAW" },
{ GLenum::GL_STATIC_DRAW_ARB, "GL_STATIC_DRAW_ARB" },
{ GLenum::GL_STATIC_READ, "GL_STATIC_READ" },
{ GLenum::GL_STATIC_READ_ARB, "GL_STATIC_READ_ARB" },
{ GLenum::GL_STATIC_VERTEX_ARRAY_IBM, "GL_STATIC_VERTEX_ARRAY_IBM" },
{ GLenum::GL_STENCIL, "GL_STENCIL" },
{ GLenum::GL_STENCIL_ATTACHMENT, "GL_STENCIL_ATTACHMENT" },
{ GLenum::GL_STENCIL_ATTACHMENT_EXT, "GL_STENCIL_ATTACHMENT_EXT" },
{ GLenum::GL_STENCIL_BACK_FAIL, "GL_STENCIL_BACK_FAIL" },
{ GLenum::GL_STENCIL_BACK_FAIL_ATI, "GL_STENCIL_BACK_FAIL_ATI" },
{ GLenum::GL_STENCIL_BACK_FUNC, "GL_STENCIL_BACK_FUNC" },
{ GLenum::GL_STENCIL_BACK_FUNC_ATI, "GL_STENCIL_BACK_FUNC_ATI" },
{ GLenum::GL_STENCIL_BACK_OP_VALUE_AMD, "GL_STENCIL_BACK_OP_VALUE_AMD" },
{ GLenum::GL_STENCIL_BACK_PASS_DEPTH_FAIL, "GL_STENCIL_BACK_PASS_DEPTH_FAIL" },
{ GLenum::GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI, "GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI" },
{ GLenum::GL_STENCIL_BACK_PASS_DEPTH_PASS, "GL_STENCIL_BACK_PASS_DEPTH_PASS" },
{ GLenum::GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI, "GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI" },
{ GLenum::GL_STENCIL_BACK_REF, "GL_STENCIL_BACK_REF" },
{ GLenum::GL_STENCIL_BACK_VALUE_MASK, "GL_STENCIL_BACK_VALUE_MASK" },
{ GLenum::GL_STENCIL_BACK_WRITEMASK, "GL_STENCIL_BACK_WRITEMASK" },
{ GLenum::GL_STENCIL_BITS, "GL_STENCIL_BITS" },
{ GLenum::GL_STENCIL_CLEAR_TAG_VALUE_EXT, "GL_STENCIL_CLEAR_TAG_VALUE_EXT" },
{ GLenum::GL_STENCIL_CLEAR_VALUE, "GL_STENCIL_CLEAR_VALUE" },
{ GLenum::GL_STENCIL_COMPONENTS, "GL_STENCIL_COMPONENTS" },
{ GLenum::GL_STENCIL_FAIL, "GL_STENCIL_FAIL" },
{ GLenum::GL_STENCIL_FUNC, "GL_STENCIL_FUNC" },
{ GLenum::GL_STENCIL_INDEX, "GL_STENCIL_INDEX" },
{ GLenum::GL_STENCIL_INDEX1, "GL_STENCIL_INDEX1" },
{ GLenum::GL_STENCIL_INDEX16, "GL_STENCIL_INDEX16" },
{ GLenum::GL_STENCIL_INDEX16_EXT, "GL_STENCIL_INDEX16_EXT" },
{ GLenum::GL_STENCIL_INDEX1_EXT, "GL_STENCIL_INDEX1_EXT" },
{ GLenum::GL_STENCIL_INDEX4, "GL_STENCIL_INDEX4" },
{ GLenum::GL_STENCIL_INDEX4_EXT, "GL_STENCIL_INDEX4_EXT" },
{ GLenum::GL_STENCIL_INDEX8, "GL_STENCIL_INDEX8" },
{ GLenum::GL_STENCIL_INDEX8_EXT, "GL_STENCIL_INDEX8_EXT" },
{ GLenum::GL_STENCIL_OP_VALUE_AMD, "GL_STENCIL_OP_VALUE_AMD" },
{ GLenum::GL_STENCIL_PASS_DEPTH_FAIL, "GL_STENCIL_PASS_DEPTH_FAIL" },
{ GLenum::GL_STENCIL_PASS_DEPTH_PASS, "GL_STENCIL_PASS_DEPTH_PASS" },
{ GLenum::GL_STENCIL_REF, "GL_STENCIL_REF" },
{ GLenum::GL_STENCIL_REF_COMMAND_NV, "GL_STENCIL_REF_COMMAND_NV" },
{ GLenum::GL_STENCIL_RENDERABLE, "GL_STENCIL_RENDERABLE" },
{ GLenum::GL_STENCIL_SAMPLES_NV, "GL_STENCIL_SAMPLES_NV" },
{ GLenum::GL_STENCIL_TAG_BITS_EXT, "GL_STENCIL_TAG_BITS_EXT" },
{ GLenum::GL_STENCIL_TEST, "GL_STENCIL_TEST" },
{ GLenum::GL_STENCIL_TEST_TWO_SIDE_EXT, "GL_STENCIL_TEST_TWO_SIDE_EXT" },
{ GLenum::GL_STENCIL_VALUE_MASK, "GL_STENCIL_VALUE_MASK" },
{ GLenum::GL_STENCIL_WRITEMASK, "GL_STENCIL_WRITEMASK" },
{ GLenum::GL_STEREO, "GL_STEREO" },
{ GLenum::GL_STORAGE_CACHED_APPLE, "GL_STORAGE_CACHED_APPLE" },
{ GLenum::GL_STORAGE_CLIENT_APPLE, "GL_STORAGE_CLIENT_APPLE" },
{ GLenum::GL_STORAGE_PRIVATE_APPLE, "GL_STORAGE_PRIVATE_APPLE" },
{ GLenum::GL_STORAGE_SHARED_APPLE, "GL_STORAGE_SHARED_APPLE" },
{ GLenum::GL_STREAM_COPY, "GL_STREAM_COPY" },
{ GLenum::GL_STREAM_COPY_ARB, "GL_STREAM_COPY_ARB" },
{ GLenum::GL_STREAM_DRAW, "GL_STREAM_DRAW" },
{ GLenum::GL_STREAM_DRAW_ARB, "GL_STREAM_DRAW_ARB" },
{ GLenum::GL_STREAM_RASTERIZATION_AMD, "GL_STREAM_RASTERIZATION_AMD" },
{ GLenum::GL_STREAM_READ, "GL_STREAM_READ" },
{ GLenum::GL_STREAM_READ_ARB, "GL_STREAM_READ_ARB" },
{ GLenum::GL_STRICT_DEPTHFUNC_HINT_PGI, "GL_STRICT_DEPTHFUNC_HINT_PGI" },
{ GLenum::GL_STRICT_LIGHTING_HINT_PGI, "GL_STRICT_LIGHTING_HINT_PGI" },
{ GLenum::GL_STRICT_SCISSOR_HINT_PGI, "GL_STRICT_SCISSOR_HINT_PGI" },
{ GLenum::GL_SUB_ATI, "GL_SUB_ATI" },
{ GLenum::GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR, "GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR, "GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_BASIC_BIT_KHR, "GL_SUBGROUP_FEATURE_BASIC_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR, "GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV, "GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV" },
{ GLenum::GL_SUBGROUP_FEATURE_QUAD_BIT_KHR, "GL_SUBGROUP_FEATURE_QUAD_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR, "GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR, "GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR" },
{ GLenum::GL_SUBGROUP_FEATURE_VOTE_BIT_KHR, "GL_SUBGROUP_FEATURE_VOTE_BIT_KHR" },
{ GLenum::GL_SUBGROUP_QUAD_ALL_STAGES_KHR, "GL_SUBGROUP_QUAD_ALL_STAGES_KHR" },
{ GLenum::GL_SUBGROUP_SIZE_KHR, "GL_SUBGROUP_SIZE_KHR" },
{ GLenum::GL_SUBGROUP_SUPPORTED_FEATURES_KHR, "GL_SUBGROUP_SUPPORTED_FEATURES_KHR" },
{ GLenum::GL_SUBGROUP_SUPPORTED_STAGES_KHR, "GL_SUBGROUP_SUPPORTED_STAGES_KHR" },
{ GLenum::GL_SUBPIXEL_BITS, "GL_SUBPIXEL_BITS" },
{ GLenum::GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV, "GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV" },
{ GLenum::GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV, "GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV" },
{ GLenum::GL_SUBSAMPLE_DISTANCE_AMD, "GL_SUBSAMPLE_DISTANCE_AMD" },
{ GLenum::GL_SUBTRACT, "GL_SUBTRACT" },
{ GLenum::GL_SUBTRACT_ARB, "GL_SUBTRACT_ARB" },
{ GLenum::GL_SUCCESS_NV, "GL_SUCCESS_NV" },
{ GLenum::GL_SUPERSAMPLE_SCALE_X_NV, "GL_SUPERSAMPLE_SCALE_X_NV" },
{ GLenum::GL_SUPERSAMPLE_SCALE_Y_NV, "GL_SUPERSAMPLE_SCALE_Y_NV" },
{ GLenum::GL_SUPPORTED_MULTISAMPLE_MODES_AMD, "GL_SUPPORTED_MULTISAMPLE_MODES_AMD" },
{ GLenum::GL_SURFACE_MAPPED_NV, "GL_SURFACE_MAPPED_NV" },
{ GLenum::GL_SURFACE_REGISTERED_NV, "GL_SURFACE_REGISTERED_NV" },
{ GLenum::GL_SURFACE_STATE_NV, "GL_SURFACE_STATE_NV" },
{ GLenum::GL_SWIZZLE_STQ_ATI, "GL_SWIZZLE_STQ_ATI" },
{ GLenum::GL_SWIZZLE_STQ_DQ_ATI, "GL_SWIZZLE_STQ_DQ_ATI" },
{ GLenum::GL_SWIZZLE_STR_ATI, "GL_SWIZZLE_STR_ATI" },
{ GLenum::GL_SWIZZLE_STR_DR_ATI, "GL_SWIZZLE_STR_DR_ATI" },
{ GLenum::GL_SWIZZLE_STRQ_ATI, "GL_SWIZZLE_STRQ_ATI" },
{ GLenum::GL_SWIZZLE_STRQ_DQ_ATI, "GL_SWIZZLE_STRQ_DQ_ATI" },
{ GLenum::GL_SYNC_CL_EVENT_ARB, "GL_SYNC_CL_EVENT_ARB" },
{ GLenum::GL_SYNC_CL_EVENT_COMPLETE_ARB, "GL_SYNC_CL_EVENT_COMPLETE_ARB" },
{ GLenum::GL_SYNC_CONDITION, "GL_SYNC_CONDITION" },
{ GLenum::GL_SYNC_FENCE, "GL_SYNC_FENCE" },
{ GLenum::GL_SYNC_FLAGS, "GL_SYNC_FLAGS" },
{ GLenum::GL_SYNC_GPU_COMMANDS_COMPLETE, "GL_SYNC_GPU_COMMANDS_COMPLETE" },
{ GLenum::GL_SYNC_STATUS, "GL_SYNC_STATUS" },
{ GLenum::GL_SYNC_X11_FENCE_EXT, "GL_SYNC_X11_FENCE_EXT" },
{ GLenum::GL_SYSTEM_FONT_NAME_NV, "GL_SYSTEM_FONT_NAME_NV" },
{ GLenum::GL_T, "GL_T" },
{ GLenum::GL_T2F_C3F_V3F, "GL_T2F_C3F_V3F" },
{ GLenum::GL_T2F_C4F_N3F_V3F, "GL_T2F_C4F_N3F_V3F" },
{ GLenum::GL_T2F_C4UB_V3F, "GL_T2F_C4UB_V3F" },
{ GLenum::GL_T2F_IUI_N3F_V2F_EXT, "GL_T2F_IUI_N3F_V2F_EXT" },
{ GLenum::GL_T2F_IUI_N3F_V3F_EXT, "GL_T2F_IUI_N3F_V3F_EXT" },
{ GLenum::GL_T2F_IUI_V2F_EXT, "GL_T2F_IUI_V2F_EXT" },
{ GLenum::GL_T2F_IUI_V3F_EXT, "GL_T2F_IUI_V3F_EXT" },
{ GLenum::GL_T2F_N3F_V3F, "GL_T2F_N3F_V3F" },
{ GLenum::GL_T2F_V3F, "GL_T2F_V3F" },
{ GLenum::GL_T4F_C4F_N3F_V4F, "GL_T4F_C4F_N3F_V4F" },
{ GLenum::GL_T4F_V4F, "GL_T4F_V4F" },
{ GLenum::GL_TABLE_TOO_LARGE, "GL_TABLE_TOO_LARGE" },
{ GLenum::GL_TABLE_TOO_LARGE_EXT, "GL_TABLE_TOO_LARGE_EXT" },
{ GLenum::GL_TANGENT_ARRAY_EXT, "GL_TANGENT_ARRAY_EXT" },
{ GLenum::GL_TANGENT_ARRAY_POINTER_EXT, "GL_TANGENT_ARRAY_POINTER_EXT" },
{ GLenum::GL_TANGENT_ARRAY_STRIDE_EXT, "GL_TANGENT_ARRAY_STRIDE_EXT" },
{ GLenum::GL_TANGENT_ARRAY_TYPE_EXT, "GL_TANGENT_ARRAY_TYPE_EXT" },
{ GLenum::GL_TASK_SHADER_NV, "GL_TASK_SHADER_NV" },
{ GLenum::GL_TASK_SUBROUTINE_NV, "GL_TASK_SUBROUTINE_NV" },
{ GLenum::GL_TASK_SUBROUTINE_UNIFORM_NV, "GL_TASK_SUBROUTINE_UNIFORM_NV" },
{ GLenum::GL_TASK_WORK_GROUP_SIZE_NV, "GL_TASK_WORK_GROUP_SIZE_NV" },
{ GLenum::GL_TERMINATE_SEQUENCE_COMMAND_NV, "GL_TERMINATE_SEQUENCE_COMMAND_NV" },
{ GLenum::GL_TESS_CONTROL_OUTPUT_VERTICES, "GL_TESS_CONTROL_OUTPUT_VERTICES" },
{ GLenum::GL_TESS_CONTROL_PROGRAM_NV, "GL_TESS_CONTROL_PROGRAM_NV" },
{ GLenum::GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV, "GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_TESS_CONTROL_SHADER, "GL_TESS_CONTROL_SHADER" },
{ GLenum::GL_TESS_CONTROL_SHADER_PATCHES, "GL_TESS_CONTROL_SHADER_PATCHES" },
{ GLenum::GL_TESS_CONTROL_SHADER_PATCHES_ARB, "GL_TESS_CONTROL_SHADER_PATCHES_ARB" },
{ GLenum::GL_TESS_CONTROL_SUBROUTINE, "GL_TESS_CONTROL_SUBROUTINE" },
{ GLenum::GL_TESS_CONTROL_SUBROUTINE_UNIFORM, "GL_TESS_CONTROL_SUBROUTINE_UNIFORM" },
{ GLenum::GL_TESS_CONTROL_TEXTURE, "GL_TESS_CONTROL_TEXTURE" },
{ GLenum::GL_TESS_EVALUATION_PROGRAM_NV, "GL_TESS_EVALUATION_PROGRAM_NV" },
{ GLenum::GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV, "GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_TESS_EVALUATION_SHADER, "GL_TESS_EVALUATION_SHADER" },
{ GLenum::GL_TESS_EVALUATION_SHADER_INVOCATIONS, "GL_TESS_EVALUATION_SHADER_INVOCATIONS" },
{ GLenum::GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB, "GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB" },
{ GLenum::GL_TESS_EVALUATION_SUBROUTINE, "GL_TESS_EVALUATION_SUBROUTINE" },
{ GLenum::GL_TESS_EVALUATION_SUBROUTINE_UNIFORM, "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM" },
{ GLenum::GL_TESS_EVALUATION_TEXTURE, "GL_TESS_EVALUATION_TEXTURE" },
{ GLenum::GL_TESS_GEN_MODE, "GL_TESS_GEN_MODE" },
{ GLenum::GL_TESS_GEN_POINT_MODE, "GL_TESS_GEN_POINT_MODE" },
{ GLenum::GL_TESS_GEN_SPACING, "GL_TESS_GEN_SPACING" },
{ GLenum::GL_TESS_GEN_VERTEX_ORDER, "GL_TESS_GEN_VERTEX_ORDER" },
{ GLenum::GL_TESSELLATION_FACTOR_AMD, "GL_TESSELLATION_FACTOR_AMD" },
{ GLenum::GL_TESSELLATION_MODE_AMD, "GL_TESSELLATION_MODE_AMD" },
{ GLenum::GL_TEXT_FRAGMENT_SHADER_ATI, "GL_TEXT_FRAGMENT_SHADER_ATI" },
{ GLenum::GL_TEXTURE, "GL_TEXTURE" },
{ GLenum::GL_TEXTURE0, "GL_TEXTURE0" },
{ GLenum::GL_TEXTURE0_ARB, "GL_TEXTURE0_ARB" },
{ GLenum::GL_TEXTURE1, "GL_TEXTURE1" },
{ GLenum::GL_TEXTURE10, "GL_TEXTURE10" },
{ GLenum::GL_TEXTURE10_ARB, "GL_TEXTURE10_ARB" },
{ GLenum::GL_TEXTURE11, "GL_TEXTURE11" },
{ GLenum::GL_TEXTURE11_ARB, "GL_TEXTURE11_ARB" },
{ GLenum::GL_TEXTURE12, "GL_TEXTURE12" },
{ GLenum::GL_TEXTURE12_ARB, "GL_TEXTURE12_ARB" },
{ GLenum::GL_TEXTURE13, "GL_TEXTURE13" },
{ GLenum::GL_TEXTURE13_ARB, "GL_TEXTURE13_ARB" },
{ GLenum::GL_TEXTURE14, "GL_TEXTURE14" },
{ GLenum::GL_TEXTURE14_ARB, "GL_TEXTURE14_ARB" },
{ GLenum::GL_TEXTURE15, "GL_TEXTURE15" },
{ GLenum::GL_TEXTURE15_ARB, "GL_TEXTURE15_ARB" },
{ GLenum::GL_TEXTURE16, "GL_TEXTURE16" },
{ GLenum::GL_TEXTURE16_ARB, "GL_TEXTURE16_ARB" },
{ GLenum::GL_TEXTURE17, "GL_TEXTURE17" },
{ GLenum::GL_TEXTURE17_ARB, "GL_TEXTURE17_ARB" },
{ GLenum::GL_TEXTURE18, "GL_TEXTURE18" },
{ GLenum::GL_TEXTURE18_ARB, "GL_TEXTURE18_ARB" },
{ GLenum::GL_TEXTURE19, "GL_TEXTURE19" },
{ GLenum::GL_TEXTURE19_ARB, "GL_TEXTURE19_ARB" },
{ GLenum::GL_TEXTURE1_ARB, "GL_TEXTURE1_ARB" },
{ GLenum::GL_TEXTURE2, "GL_TEXTURE2" },
{ GLenum::GL_TEXTURE20, "GL_TEXTURE20" },
{ GLenum::GL_TEXTURE20_ARB, "GL_TEXTURE20_ARB" },
{ GLenum::GL_TEXTURE21, "GL_TEXTURE21" },
{ GLenum::GL_TEXTURE21_ARB, "GL_TEXTURE21_ARB" },
{ GLenum::GL_TEXTURE22, "GL_TEXTURE22" },
{ GLenum::GL_TEXTURE22_ARB, "GL_TEXTURE22_ARB" },
{ GLenum::GL_TEXTURE23, "GL_TEXTURE23" },
{ GLenum::GL_TEXTURE23_ARB, "GL_TEXTURE23_ARB" },
{ GLenum::GL_TEXTURE24, "GL_TEXTURE24" },
{ GLenum::GL_TEXTURE24_ARB, "GL_TEXTURE24_ARB" },
{ GLenum::GL_TEXTURE25, "GL_TEXTURE25" },
{ GLenum::GL_TEXTURE25_ARB, "GL_TEXTURE25_ARB" },
{ GLenum::GL_TEXTURE26, "GL_TEXTURE26" },
{ GLenum::GL_TEXTURE26_ARB, "GL_TEXTURE26_ARB" },
{ GLenum::GL_TEXTURE27, "GL_TEXTURE27" },
{ GLenum::GL_TEXTURE27_ARB, "GL_TEXTURE27_ARB" },
{ GLenum::GL_TEXTURE28, "GL_TEXTURE28" },
{ GLenum::GL_TEXTURE28_ARB, "GL_TEXTURE28_ARB" },
{ GLenum::GL_TEXTURE29, "GL_TEXTURE29" },
{ GLenum::GL_TEXTURE29_ARB, "GL_TEXTURE29_ARB" },
{ GLenum::GL_TEXTURE2_ARB, "GL_TEXTURE2_ARB" },
{ GLenum::GL_TEXTURE3, "GL_TEXTURE3" },
{ GLenum::GL_TEXTURE30, "GL_TEXTURE30" },
{ GLenum::GL_TEXTURE30_ARB, "GL_TEXTURE30_ARB" },
{ GLenum::GL_TEXTURE31, "GL_TEXTURE31" },
{ GLenum::GL_TEXTURE31_ARB, "GL_TEXTURE31_ARB" },
{ GLenum::GL_TEXTURE3_ARB, "GL_TEXTURE3_ARB" },
{ GLenum::GL_TEXTURE4, "GL_TEXTURE4" },
{ GLenum::GL_TEXTURE4_ARB, "GL_TEXTURE4_ARB" },
{ GLenum::GL_TEXTURE5, "GL_TEXTURE5" },
{ GLenum::GL_TEXTURE5_ARB, "GL_TEXTURE5_ARB" },
{ GLenum::GL_TEXTURE6, "GL_TEXTURE6" },
{ GLenum::GL_TEXTURE6_ARB, "GL_TEXTURE6_ARB" },
{ GLenum::GL_TEXTURE7, "GL_TEXTURE7" },
{ GLenum::GL_TEXTURE7_ARB, "GL_TEXTURE7_ARB" },
{ GLenum::GL_TEXTURE8, "GL_TEXTURE8" },
{ GLenum::GL_TEXTURE8_ARB, "GL_TEXTURE8_ARB" },
{ GLenum::GL_TEXTURE9, "GL_TEXTURE9" },
{ GLenum::GL_TEXTURE9_ARB, "GL_TEXTURE9_ARB" },
{ GLenum::GL_TEXTURE_1D, "GL_TEXTURE_1D" },
{ GLenum::GL_TEXTURE_1D_ARRAY, "GL_TEXTURE_1D_ARRAY" },
{ GLenum::GL_TEXTURE_1D_ARRAY_EXT, "GL_TEXTURE_1D_ARRAY_EXT" },
{ GLenum::GL_TEXTURE_1D_BINDING_EXT, "GL_TEXTURE_1D_BINDING_EXT" },
{ GLenum::GL_TEXTURE_1D_STACK_BINDING_MESAX, "GL_TEXTURE_1D_STACK_BINDING_MESAX" },
{ GLenum::GL_TEXTURE_1D_STACK_MESAX, "GL_TEXTURE_1D_STACK_MESAX" },
{ GLenum::GL_TEXTURE_2D, "GL_TEXTURE_2D" },
{ GLenum::GL_TEXTURE_2D_ARRAY, "GL_TEXTURE_2D_ARRAY" },
{ GLenum::GL_TEXTURE_2D_ARRAY_EXT, "GL_TEXTURE_2D_ARRAY_EXT" },
{ GLenum::GL_TEXTURE_2D_BINDING_EXT, "GL_TEXTURE_2D_BINDING_EXT" },
{ GLenum::GL_TEXTURE_2D_MULTISAMPLE, "GL_TEXTURE_2D_MULTISAMPLE" },
{ GLenum::GL_TEXTURE_2D_MULTISAMPLE_ARRAY, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_TEXTURE_2D_STACK_BINDING_MESAX, "GL_TEXTURE_2D_STACK_BINDING_MESAX" },
{ GLenum::GL_TEXTURE_2D_STACK_MESAX, "GL_TEXTURE_2D_STACK_MESAX" },
{ GLenum::GL_TEXTURE_3D, "GL_TEXTURE_3D" },
{ GLenum::GL_TEXTURE_3D_BINDING_EXT, "GL_TEXTURE_3D_BINDING_EXT" },
{ GLenum::GL_TEXTURE_3D_EXT, "GL_TEXTURE_3D_EXT" },
{ GLenum::GL_TEXTURE_4D_BINDING_SGIS, "GL_TEXTURE_4D_BINDING_SGIS" },
{ GLenum::GL_TEXTURE_4D_SGIS, "GL_TEXTURE_4D_SGIS" },
{ GLenum::GL_TEXTURE_4DSIZE_SGIS, "GL_TEXTURE_4DSIZE_SGIS" },
{ GLenum::GL_TEXTURE_ALPHA_SIZE, "GL_TEXTURE_ALPHA_SIZE" },
{ GLenum::GL_TEXTURE_ALPHA_SIZE_EXT, "GL_TEXTURE_ALPHA_SIZE_EXT" },
{ GLenum::GL_TEXTURE_ALPHA_TYPE, "GL_TEXTURE_ALPHA_TYPE" },
{ GLenum::GL_TEXTURE_ALPHA_TYPE_ARB, "GL_TEXTURE_ALPHA_TYPE_ARB" },
{ GLenum::GL_TEXTURE_APPLICATION_MODE_EXT, "GL_TEXTURE_APPLICATION_MODE_EXT" },
{ GLenum::GL_TEXTURE_BASE_LEVEL, "GL_TEXTURE_BASE_LEVEL" },
{ GLenum::GL_TEXTURE_BASE_LEVEL_SGIS, "GL_TEXTURE_BASE_LEVEL_SGIS" },
{ GLenum::GL_TEXTURE_BINDING_1D, "GL_TEXTURE_BINDING_1D" },
{ GLenum::GL_TEXTURE_BINDING_1D_ARRAY, "GL_TEXTURE_BINDING_1D_ARRAY" },
{ GLenum::GL_TEXTURE_BINDING_1D_ARRAY_EXT, "GL_TEXTURE_BINDING_1D_ARRAY_EXT" },
{ GLenum::GL_TEXTURE_BINDING_2D, "GL_TEXTURE_BINDING_2D" },
{ GLenum::GL_TEXTURE_BINDING_2D_ARRAY, "GL_TEXTURE_BINDING_2D_ARRAY" },
{ GLenum::GL_TEXTURE_BINDING_2D_ARRAY_EXT, "GL_TEXTURE_BINDING_2D_ARRAY_EXT" },
{ GLenum::GL_TEXTURE_BINDING_2D_MULTISAMPLE, "GL_TEXTURE_BINDING_2D_MULTISAMPLE" },
{ GLenum::GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_TEXTURE_BINDING_3D, "GL_TEXTURE_BINDING_3D" },
{ GLenum::GL_TEXTURE_BINDING_BUFFER, "GL_TEXTURE_BINDING_BUFFER" },
{ GLenum::GL_TEXTURE_BINDING_BUFFER_ARB, "GL_TEXTURE_BINDING_BUFFER_ARB" },
{ GLenum::GL_TEXTURE_BINDING_BUFFER_EXT, "GL_TEXTURE_BINDING_BUFFER_EXT" },
{ GLenum::GL_TEXTURE_BINDING_CUBE_MAP, "GL_TEXTURE_BINDING_CUBE_MAP" },
{ GLenum::GL_TEXTURE_BINDING_CUBE_MAP_ARB, "GL_TEXTURE_BINDING_CUBE_MAP_ARB" },
{ GLenum::GL_TEXTURE_BINDING_CUBE_MAP_ARRAY, "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY" },
{ GLenum::GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB, "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_TEXTURE_BINDING_CUBE_MAP_EXT, "GL_TEXTURE_BINDING_CUBE_MAP_EXT" },
{ GLenum::GL_TEXTURE_BINDING_RECTANGLE, "GL_TEXTURE_BINDING_RECTANGLE" },
{ GLenum::GL_TEXTURE_BINDING_RECTANGLE_ARB, "GL_TEXTURE_BINDING_RECTANGLE_ARB" },
{ GLenum::GL_TEXTURE_BINDING_RECTANGLE_NV, "GL_TEXTURE_BINDING_RECTANGLE_NV" },
{ GLenum::GL_TEXTURE_BINDING_RENDERBUFFER_NV, "GL_TEXTURE_BINDING_RENDERBUFFER_NV" },
{ GLenum::GL_TEXTURE_BLUE_SIZE, "GL_TEXTURE_BLUE_SIZE" },
{ GLenum::GL_TEXTURE_BLUE_SIZE_EXT, "GL_TEXTURE_BLUE_SIZE_EXT" },
{ GLenum::GL_TEXTURE_BLUE_TYPE, "GL_TEXTURE_BLUE_TYPE" },
{ GLenum::GL_TEXTURE_BLUE_TYPE_ARB, "GL_TEXTURE_BLUE_TYPE_ARB" },
{ GLenum::GL_TEXTURE_BORDER, "GL_TEXTURE_BORDER" },
{ GLenum::GL_TEXTURE_BORDER_COLOR, "GL_TEXTURE_BORDER_COLOR" },
{ GLenum::GL_TEXTURE_BORDER_VALUES_NV, "GL_TEXTURE_BORDER_VALUES_NV" },
{ GLenum::GL_TEXTURE_BUFFER, "GL_TEXTURE_BUFFER" },
{ GLenum::GL_TEXTURE_BUFFER_ARB, "GL_TEXTURE_BUFFER_ARB" },
{ GLenum::GL_TEXTURE_BUFFER_BINDING, "GL_TEXTURE_BUFFER_BINDING" },
{ GLenum::GL_TEXTURE_BUFFER_DATA_STORE_BINDING, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING" },
{ GLenum::GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB" },
{ GLenum::GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT" },
{ GLenum::GL_TEXTURE_BUFFER_EXT, "GL_TEXTURE_BUFFER_EXT" },
{ GLenum::GL_TEXTURE_BUFFER_FORMAT_ARB, "GL_TEXTURE_BUFFER_FORMAT_ARB" },
{ GLenum::GL_TEXTURE_BUFFER_FORMAT_EXT, "GL_TEXTURE_BUFFER_FORMAT_EXT" },
{ GLenum::GL_TEXTURE_BUFFER_OFFSET, "GL_TEXTURE_BUFFER_OFFSET" },
{ GLenum::GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT" },
{ GLenum::GL_TEXTURE_BUFFER_SIZE, "GL_TEXTURE_BUFFER_SIZE" },
{ GLenum::GL_TEXTURE_CLIPMAP_CENTER_SGIX, "GL_TEXTURE_CLIPMAP_CENTER_SGIX" },
{ GLenum::GL_TEXTURE_CLIPMAP_DEPTH_SGIX, "GL_TEXTURE_CLIPMAP_DEPTH_SGIX" },
{ GLenum::GL_TEXTURE_CLIPMAP_FRAME_SGIX, "GL_TEXTURE_CLIPMAP_FRAME_SGIX" },
{ GLenum::GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX, "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX" },
{ GLenum::GL_TEXTURE_CLIPMAP_OFFSET_SGIX, "GL_TEXTURE_CLIPMAP_OFFSET_SGIX" },
{ GLenum::GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX, "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX" },
{ GLenum::GL_TEXTURE_COLOR_SAMPLES_NV, "GL_TEXTURE_COLOR_SAMPLES_NV" },
{ GLenum::GL_TEXTURE_COLOR_TABLE_SGI, "GL_TEXTURE_COLOR_TABLE_SGI" },
{ GLenum::GL_TEXTURE_COLOR_WRITEMASK_SGIS, "GL_TEXTURE_COLOR_WRITEMASK_SGIS" },
{ GLenum::GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB" },
{ GLenum::GL_TEXTURE_COMPARE_FUNC, "GL_TEXTURE_COMPARE_FUNC" },
{ GLenum::GL_TEXTURE_COMPARE_FUNC_ARB, "GL_TEXTURE_COMPARE_FUNC_ARB" },
{ GLenum::GL_TEXTURE_COMPARE_MODE, "GL_TEXTURE_COMPARE_MODE" },
{ GLenum::GL_TEXTURE_COMPARE_MODE_ARB, "GL_TEXTURE_COMPARE_MODE_ARB" },
{ GLenum::GL_TEXTURE_COMPARE_OPERATOR_SGIX, "GL_TEXTURE_COMPARE_OPERATOR_SGIX" },
{ GLenum::GL_TEXTURE_COMPARE_SGIX, "GL_TEXTURE_COMPARE_SGIX" },
{ GLenum::GL_TEXTURE_COMPONENTS, "GL_TEXTURE_COMPONENTS" },
{ GLenum::GL_TEXTURE_COMPRESSED, "GL_TEXTURE_COMPRESSED" },
{ GLenum::GL_TEXTURE_COMPRESSED_ARB, "GL_TEXTURE_COMPRESSED_ARB" },
{ GLenum::GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT, "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT" },
{ GLenum::GL_TEXTURE_COMPRESSED_BLOCK_SIZE, "GL_TEXTURE_COMPRESSED_BLOCK_SIZE" },
{ GLenum::GL_TEXTURE_COMPRESSED_BLOCK_WIDTH, "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH" },
{ GLenum::GL_TEXTURE_COMPRESSED_IMAGE_SIZE, "GL_TEXTURE_COMPRESSED_IMAGE_SIZE" },
{ GLenum::GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB" },
{ GLenum::GL_TEXTURE_COMPRESSION_HINT, "GL_TEXTURE_COMPRESSION_HINT" },
{ GLenum::GL_TEXTURE_COMPRESSION_HINT_ARB, "GL_TEXTURE_COMPRESSION_HINT_ARB" },
{ GLenum::GL_TEXTURE_CONSTANT_DATA_SUNX, "GL_TEXTURE_CONSTANT_DATA_SUNX" },
{ GLenum::GL_TEXTURE_COORD_ARRAY, "GL_TEXTURE_COORD_ARRAY" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_ADDRESS_NV, "GL_TEXTURE_COORD_ARRAY_ADDRESS_NV" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_COUNT_EXT, "GL_TEXTURE_COORD_ARRAY_COUNT_EXT" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_EXT, "GL_TEXTURE_COORD_ARRAY_EXT" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_LENGTH_NV, "GL_TEXTURE_COORD_ARRAY_LENGTH_NV" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_LIST_IBM, "GL_TEXTURE_COORD_ARRAY_LIST_IBM" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM, "GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL, "GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_POINTER, "GL_TEXTURE_COORD_ARRAY_POINTER" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_POINTER_EXT, "GL_TEXTURE_COORD_ARRAY_POINTER_EXT" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_SIZE, "GL_TEXTURE_COORD_ARRAY_SIZE" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_SIZE_EXT, "GL_TEXTURE_COORD_ARRAY_SIZE_EXT" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_STRIDE, "GL_TEXTURE_COORD_ARRAY_STRIDE" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_STRIDE_EXT, "GL_TEXTURE_COORD_ARRAY_STRIDE_EXT" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_TYPE, "GL_TEXTURE_COORD_ARRAY_TYPE" },
{ GLenum::GL_TEXTURE_COORD_ARRAY_TYPE_EXT, "GL_TEXTURE_COORD_ARRAY_TYPE_EXT" },
{ GLenum::GL_TEXTURE_COORD_NV, "GL_TEXTURE_COORD_NV" },
{ GLenum::GL_TEXTURE_COVERAGE_SAMPLES_NV, "GL_TEXTURE_COVERAGE_SAMPLES_NV" },
{ GLenum::GL_TEXTURE_CUBE_MAP, "GL_TEXTURE_CUBE_MAP" },
{ GLenum::GL_TEXTURE_CUBE_MAP_ARB, "GL_TEXTURE_CUBE_MAP_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_ARRAY, "GL_TEXTURE_CUBE_MAP_ARRAY" },
{ GLenum::GL_TEXTURE_CUBE_MAP_ARRAY_ARB, "GL_TEXTURE_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_EXT, "GL_TEXTURE_CUBE_MAP_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_X, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_X, "GL_TEXTURE_CUBE_MAP_POSITIVE_X" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT, "GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Y, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Z, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB" },
{ GLenum::GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT" },
{ GLenum::GL_TEXTURE_CUBE_MAP_SEAMLESS, "GL_TEXTURE_CUBE_MAP_SEAMLESS" },
{ GLenum::GL_TEXTURE_DEFORMATION_SGIX, "GL_TEXTURE_DEFORMATION_SGIX" },
{ GLenum::GL_TEXTURE_DEPTH, "GL_TEXTURE_DEPTH" },
{ GLenum::GL_TEXTURE_DEPTH_EXT, "GL_TEXTURE_DEPTH_EXT" },
{ GLenum::GL_TEXTURE_DEPTH_SIZE, "GL_TEXTURE_DEPTH_SIZE" },
{ GLenum::GL_TEXTURE_DEPTH_SIZE_ARB, "GL_TEXTURE_DEPTH_SIZE_ARB" },
{ GLenum::GL_TEXTURE_DEPTH_TYPE, "GL_TEXTURE_DEPTH_TYPE" },
{ GLenum::GL_TEXTURE_DEPTH_TYPE_ARB, "GL_TEXTURE_DEPTH_TYPE_ARB" },
{ GLenum::GL_TEXTURE_DS_SIZE_NV, "GL_TEXTURE_DS_SIZE_NV" },
{ GLenum::GL_TEXTURE_DT_SIZE_NV, "GL_TEXTURE_DT_SIZE_NV" },
{ GLenum::GL_TEXTURE_ENV, "GL_TEXTURE_ENV" },
{ GLenum::GL_TEXTURE_ENV_BIAS_SGIX, "GL_TEXTURE_ENV_BIAS_SGIX" },
{ GLenum::GL_TEXTURE_ENV_COLOR, "GL_TEXTURE_ENV_COLOR" },
{ GLenum::GL_TEXTURE_ENV_MODE, "GL_TEXTURE_ENV_MODE" },
{ GLenum::GL_TEXTURE_FILTER4_SIZE_SGIS, "GL_TEXTURE_FILTER4_SIZE_SGIS" },
{ GLenum::GL_TEXTURE_FILTER_CONTROL, "GL_TEXTURE_FILTER_CONTROL" },
{ GLenum::GL_TEXTURE_FILTER_CONTROL_EXT, "GL_TEXTURE_FILTER_CONTROL_EXT" },
{ GLenum::GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS" },
{ GLenum::GL_TEXTURE_FLOAT_COMPONENTS_NV, "GL_TEXTURE_FLOAT_COMPONENTS_NV" },
{ GLenum::GL_TEXTURE_FREE_MEMORY_ATI, "GL_TEXTURE_FREE_MEMORY_ATI" },
{ GLenum::GL_TEXTURE_GATHER, "GL_TEXTURE_GATHER" },
{ GLenum::GL_TEXTURE_GATHER_SHADOW, "GL_TEXTURE_GATHER_SHADOW" },
{ GLenum::GL_TEXTURE_GEN_MODE, "GL_TEXTURE_GEN_MODE" },
{ GLenum::GL_TEXTURE_GEN_Q, "GL_TEXTURE_GEN_Q" },
{ GLenum::GL_TEXTURE_GEN_R, "GL_TEXTURE_GEN_R" },
{ GLenum::GL_TEXTURE_GEN_S, "GL_TEXTURE_GEN_S" },
{ GLenum::GL_TEXTURE_GEN_T, "GL_TEXTURE_GEN_T" },
{ GLenum::GL_TEXTURE_GEQUAL_R_SGIX, "GL_TEXTURE_GEQUAL_R_SGIX" },
{ GLenum::GL_TEXTURE_GREEN_SIZE, "GL_TEXTURE_GREEN_SIZE" },
{ GLenum::GL_TEXTURE_GREEN_SIZE_EXT, "GL_TEXTURE_GREEN_SIZE_EXT" },
{ GLenum::GL_TEXTURE_GREEN_TYPE, "GL_TEXTURE_GREEN_TYPE" },
{ GLenum::GL_TEXTURE_GREEN_TYPE_ARB, "GL_TEXTURE_GREEN_TYPE_ARB" },
{ GLenum::GL_TEXTURE_HEIGHT, "GL_TEXTURE_HEIGHT" },
{ GLenum::GL_TEXTURE_HI_SIZE_NV, "GL_TEXTURE_HI_SIZE_NV" },
{ GLenum::GL_TEXTURE_IMAGE_FORMAT, "GL_TEXTURE_IMAGE_FORMAT" },
{ GLenum::GL_TEXTURE_IMAGE_TYPE, "GL_TEXTURE_IMAGE_TYPE" },
{ GLenum::GL_TEXTURE_IMMUTABLE_FORMAT, "GL_TEXTURE_IMMUTABLE_FORMAT" },
{ GLenum::GL_TEXTURE_IMMUTABLE_LEVELS, "GL_TEXTURE_IMMUTABLE_LEVELS" },
{ GLenum::GL_TEXTURE_INDEX_SIZE_EXT, "GL_TEXTURE_INDEX_SIZE_EXT" },
{ GLenum::GL_TEXTURE_INTENSITY_SIZE, "GL_TEXTURE_INTENSITY_SIZE" },
{ GLenum::GL_TEXTURE_INTENSITY_SIZE_EXT, "GL_TEXTURE_INTENSITY_SIZE_EXT" },
{ GLenum::GL_TEXTURE_INTENSITY_TYPE, "GL_TEXTURE_INTENSITY_TYPE" },
{ GLenum::GL_TEXTURE_INTENSITY_TYPE_ARB, "GL_TEXTURE_INTENSITY_TYPE_ARB" },
{ GLenum::GL_TEXTURE_INTERNAL_FORMAT, "GL_TEXTURE_INTERNAL_FORMAT" },
{ GLenum::GL_TEXTURE_LEQUAL_R_SGIX, "GL_TEXTURE_LEQUAL_R_SGIX" },
{ GLenum::GL_TEXTURE_LIGHT_EXT, "GL_TEXTURE_LIGHT_EXT" },
{ GLenum::GL_TEXTURE_LIGHTING_MODE_HP, "GL_TEXTURE_LIGHTING_MODE_HP" },
{ GLenum::GL_TEXTURE_LO_SIZE_NV, "GL_TEXTURE_LO_SIZE_NV" },
{ GLenum::GL_TEXTURE_LOD_BIAS, "GL_TEXTURE_LOD_BIAS" },
{ GLenum::GL_TEXTURE_LOD_BIAS_EXT, "GL_TEXTURE_LOD_BIAS_EXT" },
{ GLenum::GL_TEXTURE_LOD_BIAS_R_SGIX, "GL_TEXTURE_LOD_BIAS_R_SGIX" },
{ GLenum::GL_TEXTURE_LOD_BIAS_S_SGIX, "GL_TEXTURE_LOD_BIAS_S_SGIX" },
{ GLenum::GL_TEXTURE_LOD_BIAS_T_SGIX, "GL_TEXTURE_LOD_BIAS_T_SGIX" },
{ GLenum::GL_TEXTURE_LUMINANCE_SIZE, "GL_TEXTURE_LUMINANCE_SIZE" },
{ GLenum::GL_TEXTURE_LUMINANCE_SIZE_EXT, "GL_TEXTURE_LUMINANCE_SIZE_EXT" },
{ GLenum::GL_TEXTURE_LUMINANCE_TYPE, "GL_TEXTURE_LUMINANCE_TYPE" },
{ GLenum::GL_TEXTURE_LUMINANCE_TYPE_ARB, "GL_TEXTURE_LUMINANCE_TYPE_ARB" },
{ GLenum::GL_TEXTURE_MAG_FILTER, "GL_TEXTURE_MAG_FILTER" },
{ GLenum::GL_TEXTURE_MAG_SIZE_NV, "GL_TEXTURE_MAG_SIZE_NV" },
{ GLenum::GL_TEXTURE_MATERIAL_FACE_EXT, "GL_TEXTURE_MATERIAL_FACE_EXT" },
{ GLenum::GL_TEXTURE_MATERIAL_PARAMETER_EXT, "GL_TEXTURE_MATERIAL_PARAMETER_EXT" },
{ GLenum::GL_TEXTURE_MATRIX, "GL_TEXTURE_MATRIX" },
{ GLenum::GL_TEXTURE_MAX_ANISOTROPY, "GL_TEXTURE_MAX_ANISOTROPY" },
{ GLenum::GL_TEXTURE_MAX_ANISOTROPY_EXT, "GL_TEXTURE_MAX_ANISOTROPY_EXT" },
{ GLenum::GL_TEXTURE_MAX_CLAMP_R_SGIX, "GL_TEXTURE_MAX_CLAMP_R_SGIX" },
{ GLenum::GL_TEXTURE_MAX_CLAMP_S_SGIX, "GL_TEXTURE_MAX_CLAMP_S_SGIX" },
{ GLenum::GL_TEXTURE_MAX_CLAMP_T_SGIX, "GL_TEXTURE_MAX_CLAMP_T_SGIX" },
{ GLenum::GL_TEXTURE_MAX_LEVEL, "GL_TEXTURE_MAX_LEVEL" },
{ GLenum::GL_TEXTURE_MAX_LEVEL_SGIS, "GL_TEXTURE_MAX_LEVEL_SGIS" },
{ GLenum::GL_TEXTURE_MAX_LOD, "GL_TEXTURE_MAX_LOD" },
{ GLenum::GL_TEXTURE_MAX_LOD_SGIS, "GL_TEXTURE_MAX_LOD_SGIS" },
{ GLenum::GL_TEXTURE_MEMORY_LAYOUT_INTEL, "GL_TEXTURE_MEMORY_LAYOUT_INTEL" },
{ GLenum::GL_TEXTURE_MIN_FILTER, "GL_TEXTURE_MIN_FILTER" },
{ GLenum::GL_TEXTURE_MIN_LOD, "GL_TEXTURE_MIN_LOD" },
{ GLenum::GL_TEXTURE_MIN_LOD_SGIS, "GL_TEXTURE_MIN_LOD_SGIS" },
{ GLenum::GL_TEXTURE_MULTI_BUFFER_HINT_SGIX, "GL_TEXTURE_MULTI_BUFFER_HINT_SGIX" },
{ GLenum::GL_TEXTURE_NORMAL_EXT, "GL_TEXTURE_NORMAL_EXT" },
{ GLenum::GL_TEXTURE_POST_SPECULAR_HP, "GL_TEXTURE_POST_SPECULAR_HP" },
{ GLenum::GL_TEXTURE_PRE_SPECULAR_HP, "GL_TEXTURE_PRE_SPECULAR_HP" },
{ GLenum::GL_TEXTURE_PRIORITY, "GL_TEXTURE_PRIORITY" },
{ GLenum::GL_TEXTURE_PRIORITY_EXT, "GL_TEXTURE_PRIORITY_EXT" },
{ GLenum::GL_TEXTURE_RANGE_LENGTH_APPLE, "GL_TEXTURE_RANGE_LENGTH_APPLE" },
{ GLenum::GL_TEXTURE_RANGE_POINTER_APPLE, "GL_TEXTURE_RANGE_POINTER_APPLE" },
{ GLenum::GL_TEXTURE_RECTANGLE, "GL_TEXTURE_RECTANGLE" },
{ GLenum::GL_TEXTURE_RECTANGLE_ARB, "GL_TEXTURE_RECTANGLE_ARB" },
{ GLenum::GL_TEXTURE_RECTANGLE_NV, "GL_TEXTURE_RECTANGLE_NV" },
{ GLenum::GL_TEXTURE_RED_SIZE, "GL_TEXTURE_RED_SIZE" },
{ GLenum::GL_TEXTURE_RED_SIZE_EXT, "GL_TEXTURE_RED_SIZE_EXT" },
{ GLenum::GL_TEXTURE_RED_TYPE, "GL_TEXTURE_RED_TYPE" },
{ GLenum::GL_TEXTURE_RED_TYPE_ARB, "GL_TEXTURE_RED_TYPE_ARB" },
{ GLenum::GL_TEXTURE_REDUCTION_MODE_ARB, "GL_TEXTURE_REDUCTION_MODE_ARB" },
{ GLenum::GL_TEXTURE_REDUCTION_MODE_EXT, "GL_TEXTURE_REDUCTION_MODE_EXT" },
{ GLenum::GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV, "GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV" },
{ GLenum::GL_TEXTURE_RENDERBUFFER_NV, "GL_TEXTURE_RENDERBUFFER_NV" },
{ GLenum::GL_TEXTURE_RESIDENT, "GL_TEXTURE_RESIDENT" },
{ GLenum::GL_TEXTURE_RESIDENT_EXT, "GL_TEXTURE_RESIDENT_EXT" },
{ GLenum::GL_TEXTURE_SAMPLES, "GL_TEXTURE_SAMPLES" },
{ GLenum::GL_TEXTURE_SHADER_NV, "GL_TEXTURE_SHADER_NV" },
{ GLenum::GL_TEXTURE_SHADOW, "GL_TEXTURE_SHADOW" },
{ GLenum::GL_TEXTURE_SHARED_SIZE, "GL_TEXTURE_SHARED_SIZE" },
{ GLenum::GL_TEXTURE_SHARED_SIZE_EXT, "GL_TEXTURE_SHARED_SIZE_EXT" },
{ GLenum::GL_TEXTURE_SPARSE_ARB, "GL_TEXTURE_SPARSE_ARB" },
{ GLenum::GL_TEXTURE_SRGB_DECODE_EXT, "GL_TEXTURE_SRGB_DECODE_EXT" },
{ GLenum::GL_TEXTURE_STACK_DEPTH, "GL_TEXTURE_STACK_DEPTH" },
{ GLenum::GL_TEXTURE_STENCIL_SIZE, "GL_TEXTURE_STENCIL_SIZE" },
{ GLenum::GL_TEXTURE_STENCIL_SIZE_EXT, "GL_TEXTURE_STENCIL_SIZE_EXT" },
{ GLenum::GL_TEXTURE_STORAGE_HINT_APPLE, "GL_TEXTURE_STORAGE_HINT_APPLE" },
{ GLenum::GL_TEXTURE_SWIZZLE_A, "GL_TEXTURE_SWIZZLE_A" },
{ GLenum::GL_TEXTURE_SWIZZLE_A_EXT, "GL_TEXTURE_SWIZZLE_A_EXT" },
{ GLenum::GL_TEXTURE_SWIZZLE_B, "GL_TEXTURE_SWIZZLE_B" },
{ GLenum::GL_TEXTURE_SWIZZLE_B_EXT, "GL_TEXTURE_SWIZZLE_B_EXT" },
{ GLenum::GL_TEXTURE_SWIZZLE_G, "GL_TEXTURE_SWIZZLE_G" },
{ GLenum::GL_TEXTURE_SWIZZLE_G_EXT, "GL_TEXTURE_SWIZZLE_G_EXT" },
{ GLenum::GL_TEXTURE_SWIZZLE_R, "GL_TEXTURE_SWIZZLE_R" },
{ GLenum::GL_TEXTURE_SWIZZLE_R_EXT, "GL_TEXTURE_SWIZZLE_R_EXT" },
{ GLenum::GL_TEXTURE_SWIZZLE_RGBA, "GL_TEXTURE_SWIZZLE_RGBA" },
{ GLenum::GL_TEXTURE_SWIZZLE_RGBA_EXT, "GL_TEXTURE_SWIZZLE_RGBA_EXT" },
{ GLenum::GL_TEXTURE_TARGET, "GL_TEXTURE_TARGET" },
{ GLenum::GL_TEXTURE_TILING_EXT, "GL_TEXTURE_TILING_EXT" },
{ GLenum::GL_TEXTURE_TOO_LARGE_EXT, "GL_TEXTURE_TOO_LARGE_EXT" },
{ GLenum::GL_TEXTURE_UNSIGNED_REMAP_MODE_NV, "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV" },
{ GLenum::GL_TEXTURE_VIEW, "GL_TEXTURE_VIEW" },
{ GLenum::GL_TEXTURE_VIEW_MIN_LAYER, "GL_TEXTURE_VIEW_MIN_LAYER" },
{ GLenum::GL_TEXTURE_VIEW_MIN_LEVEL, "GL_TEXTURE_VIEW_MIN_LEVEL" },
{ GLenum::GL_TEXTURE_VIEW_NUM_LAYERS, "GL_TEXTURE_VIEW_NUM_LAYERS" },
{ GLenum::GL_TEXTURE_VIEW_NUM_LEVELS, "GL_TEXTURE_VIEW_NUM_LEVELS" },
{ GLenum::GL_TEXTURE_WIDTH, "GL_TEXTURE_WIDTH" },
{ GLenum::GL_TEXTURE_WRAP_Q_SGIS, "GL_TEXTURE_WRAP_Q_SGIS" },
{ GLenum::GL_TEXTURE_WRAP_R, "GL_TEXTURE_WRAP_R" },
{ GLenum::GL_TEXTURE_WRAP_R_EXT, "GL_TEXTURE_WRAP_R_EXT" },
{ GLenum::GL_TEXTURE_WRAP_S, "GL_TEXTURE_WRAP_S" },
{ GLenum::GL_TEXTURE_WRAP_T, "GL_TEXTURE_WRAP_T" },
{ GLenum::GL_TILE_RASTER_ORDER_FIXED_MESA, "GL_TILE_RASTER_ORDER_FIXED_MESA" },
{ GLenum::GL_TILE_RASTER_ORDER_INCREASING_X_MESA, "GL_TILE_RASTER_ORDER_INCREASING_X_MESA" },
{ GLenum::GL_TILE_RASTER_ORDER_INCREASING_Y_MESA, "GL_TILE_RASTER_ORDER_INCREASING_Y_MESA" },
{ GLenum::GL_TILING_TYPES_EXT, "GL_TILING_TYPES_EXT" },
{ GLenum::GL_TIME_ELAPSED, "GL_TIME_ELAPSED" },
{ GLenum::GL_TIME_ELAPSED_EXT, "GL_TIME_ELAPSED_EXT" },
{ GLenum::GL_TIMEOUT_EXPIRED, "GL_TIMEOUT_EXPIRED" },
{ GLenum::GL_TIMESTAMP, "GL_TIMESTAMP" },
{ GLenum::GL_TOP_LEVEL_ARRAY_SIZE, "GL_TOP_LEVEL_ARRAY_SIZE" },
{ GLenum::GL_TOP_LEVEL_ARRAY_STRIDE, "GL_TOP_LEVEL_ARRAY_STRIDE" },
{ GLenum::GL_TRACK_MATRIX_NV, "GL_TRACK_MATRIX_NV" },
{ GLenum::GL_TRACK_MATRIX_TRANSFORM_NV, "GL_TRACK_MATRIX_TRANSFORM_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK, "GL_TRANSFORM_FEEDBACK" },
{ GLenum::GL_TRANSFORM_FEEDBACK_ACTIVE, "GL_TRANSFORM_FEEDBACK_ACTIVE" },
{ GLenum::GL_TRANSFORM_FEEDBACK_ATTRIBS_NV, "GL_TRANSFORM_FEEDBACK_ATTRIBS_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BINDING, "GL_TRANSFORM_FEEDBACK_BINDING" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BINDING_NV, "GL_TRANSFORM_FEEDBACK_BINDING_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER, "GL_TRANSFORM_FEEDBACK_BUFFER" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_EXT, "GL_TRANSFORM_FEEDBACK_BUFFER_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_INDEX, "GL_TRANSFORM_FEEDBACK_BUFFER_INDEX" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_MODE, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_START, "GL_TRANSFORM_FEEDBACK_BUFFER_START" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT, "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_START_NV, "GL_TRANSFORM_FEEDBACK_BUFFER_START_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE, "GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE" },
{ GLenum::GL_TRANSFORM_FEEDBACK_NV, "GL_TRANSFORM_FEEDBACK_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_OVERFLOW, "GL_TRANSFORM_FEEDBACK_OVERFLOW" },
{ GLenum::GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB, "GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB" },
{ GLenum::GL_TRANSFORM_FEEDBACK_PAUSED, "GL_TRANSFORM_FEEDBACK_PAUSED" },
{ GLenum::GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN" },
{ GLenum::GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_RECORD_NV, "GL_TRANSFORM_FEEDBACK_RECORD_NV" },
{ GLenum::GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW, "GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW" },
{ GLenum::GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB, "GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYING, "GL_TRANSFORM_FEEDBACK_VARYING" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT, "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYINGS, "GL_TRANSFORM_FEEDBACK_VARYINGS" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYINGS_EXT, "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT" },
{ GLenum::GL_TRANSFORM_FEEDBACK_VARYINGS_NV, "GL_TRANSFORM_FEEDBACK_VARYINGS_NV" },
{ GLenum::GL_TRANSFORM_HINT_APPLE, "GL_TRANSFORM_HINT_APPLE" },
{ GLenum::GL_TRANSLATE_2D_NV, "GL_TRANSLATE_2D_NV" },
{ GLenum::GL_TRANSLATE_3D_NV, "GL_TRANSLATE_3D_NV" },
{ GLenum::GL_TRANSLATE_X_NV, "GL_TRANSLATE_X_NV" },
{ GLenum::GL_TRANSLATE_Y_NV, "GL_TRANSLATE_Y_NV" },
{ GLenum::GL_TRANSPOSE_AFFINE_2D_NV, "GL_TRANSPOSE_AFFINE_2D_NV" },
{ GLenum::GL_TRANSPOSE_AFFINE_3D_NV, "GL_TRANSPOSE_AFFINE_3D_NV" },
{ GLenum::GL_TRANSPOSE_COLOR_MATRIX, "GL_TRANSPOSE_COLOR_MATRIX" },
{ GLenum::GL_TRANSPOSE_COLOR_MATRIX_ARB, "GL_TRANSPOSE_COLOR_MATRIX_ARB" },
{ GLenum::GL_TRANSPOSE_CURRENT_MATRIX_ARB, "GL_TRANSPOSE_CURRENT_MATRIX_ARB" },
{ GLenum::GL_TRANSPOSE_MODELVIEW_MATRIX, "GL_TRANSPOSE_MODELVIEW_MATRIX" },
{ GLenum::GL_TRANSPOSE_MODELVIEW_MATRIX_ARB, "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB" },
{ GLenum::GL_TRANSPOSE_NV, "GL_TRANSPOSE_NV" },
{ GLenum::GL_TRANSPOSE_PROGRAM_MATRIX_EXT, "GL_TRANSPOSE_PROGRAM_MATRIX_EXT" },
{ GLenum::GL_TRANSPOSE_PROJECTION_MATRIX, "GL_TRANSPOSE_PROJECTION_MATRIX" },
{ GLenum::GL_TRANSPOSE_PROJECTION_MATRIX_ARB, "GL_TRANSPOSE_PROJECTION_MATRIX_ARB" },
{ GLenum::GL_TRANSPOSE_TEXTURE_MATRIX, "GL_TRANSPOSE_TEXTURE_MATRIX" },
{ GLenum::GL_TRANSPOSE_TEXTURE_MATRIX_ARB, "GL_TRANSPOSE_TEXTURE_MATRIX_ARB" },
{ GLenum::GL_TRIANGLE_FAN, "GL_TRIANGLE_FAN" },
{ GLenum::GL_TRIANGLE_LIST_SUN, "GL_TRIANGLE_LIST_SUN" },
{ GLenum::GL_TRIANGLE_MESH_SUN, "GL_TRIANGLE_MESH_SUN" },
{ GLenum::GL_TRIANGLE_STRIP, "GL_TRIANGLE_STRIP" },
{ GLenum::GL_TRIANGLE_STRIP_ADJACENCY, "GL_TRIANGLE_STRIP_ADJACENCY" },
{ GLenum::GL_TRIANGLE_STRIP_ADJACENCY_ARB, "GL_TRIANGLE_STRIP_ADJACENCY_ARB" },
{ GLenum::GL_TRIANGLE_STRIP_ADJACENCY_EXT, "GL_TRIANGLE_STRIP_ADJACENCY_EXT" },
{ GLenum::GL_TRIANGLES, "GL_TRIANGLES" },
{ GLenum::GL_TRIANGLES_ADJACENCY, "GL_TRIANGLES_ADJACENCY" },
{ GLenum::GL_TRIANGLES_ADJACENCY_ARB, "GL_TRIANGLES_ADJACENCY_ARB" },
{ GLenum::GL_TRIANGLES_ADJACENCY_EXT, "GL_TRIANGLES_ADJACENCY_EXT" },
{ GLenum::GL_TRIANGULAR_NV, "GL_TRIANGULAR_NV" },
{ GLenum::GL_TYPE, "GL_TYPE" },
{ GLenum::GL_UNCORRELATED_NV, "GL_UNCORRELATED_NV" },
{ GLenum::GL_UNDEFINED_APPLE, "GL_UNDEFINED_APPLE" },
{ GLenum::GL_UNDEFINED_VERTEX, "GL_UNDEFINED_VERTEX" },
{ GLenum::GL_UNIFORM, "GL_UNIFORM" },
{ GLenum::GL_UNIFORM_ADDRESS_COMMAND_NV, "GL_UNIFORM_ADDRESS_COMMAND_NV" },
{ GLenum::GL_UNIFORM_ARRAY_STRIDE, "GL_UNIFORM_ARRAY_STRIDE" },
{ GLenum::GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX, "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX" },
{ GLenum::GL_UNIFORM_BLOCK, "GL_UNIFORM_BLOCK" },
{ GLenum::GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES" },
{ GLenum::GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS" },
{ GLenum::GL_UNIFORM_BLOCK_BINDING, "GL_UNIFORM_BLOCK_BINDING" },
{ GLenum::GL_UNIFORM_BLOCK_DATA_SIZE, "GL_UNIFORM_BLOCK_DATA_SIZE" },
{ GLenum::GL_UNIFORM_BLOCK_INDEX, "GL_UNIFORM_BLOCK_INDEX" },
{ GLenum::GL_UNIFORM_BLOCK_NAME_LENGTH, "GL_UNIFORM_BLOCK_NAME_LENGTH" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV, "GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV, "GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER" },
{ GLenum::GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER" },
{ GLenum::GL_UNIFORM_BUFFER, "GL_UNIFORM_BUFFER" },
{ GLenum::GL_UNIFORM_BUFFER_ADDRESS_NV, "GL_UNIFORM_BUFFER_ADDRESS_NV" },
{ GLenum::GL_UNIFORM_BUFFER_BINDING, "GL_UNIFORM_BUFFER_BINDING" },
{ GLenum::GL_UNIFORM_BUFFER_BINDING_EXT, "GL_UNIFORM_BUFFER_BINDING_EXT" },
{ GLenum::GL_UNIFORM_BUFFER_EXT, "GL_UNIFORM_BUFFER_EXT" },
{ GLenum::GL_UNIFORM_BUFFER_LENGTH_NV, "GL_UNIFORM_BUFFER_LENGTH_NV" },
{ GLenum::GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT" },
{ GLenum::GL_UNIFORM_BUFFER_SIZE, "GL_UNIFORM_BUFFER_SIZE" },
{ GLenum::GL_UNIFORM_BUFFER_START, "GL_UNIFORM_BUFFER_START" },
{ GLenum::GL_UNIFORM_BUFFER_UNIFIED_NV, "GL_UNIFORM_BUFFER_UNIFIED_NV" },
{ GLenum::GL_UNIFORM_IS_ROW_MAJOR, "GL_UNIFORM_IS_ROW_MAJOR" },
{ GLenum::GL_UNIFORM_MATRIX_STRIDE, "GL_UNIFORM_MATRIX_STRIDE" },
{ GLenum::GL_UNIFORM_NAME_LENGTH, "GL_UNIFORM_NAME_LENGTH" },
{ GLenum::GL_UNIFORM_OFFSET, "GL_UNIFORM_OFFSET" },
{ GLenum::GL_UNIFORM_SIZE, "GL_UNIFORM_SIZE" },
{ GLenum::GL_UNIFORM_TYPE, "GL_UNIFORM_TYPE" },
{ GLenum::GL_UNKNOWN_CONTEXT_RESET, "GL_UNKNOWN_CONTEXT_RESET" },
{ GLenum::GL_UNKNOWN_CONTEXT_RESET_ARB, "GL_UNKNOWN_CONTEXT_RESET_ARB" },
{ GLenum::GL_UNKNOWN_CONTEXT_RESET_KHR, "GL_UNKNOWN_CONTEXT_RESET_KHR" },
{ GLenum::GL_UNPACK_ALIGNMENT, "GL_UNPACK_ALIGNMENT" },
{ GLenum::GL_UNPACK_CLIENT_STORAGE_APPLE, "GL_UNPACK_CLIENT_STORAGE_APPLE" },
{ GLenum::GL_UNPACK_CMYK_HINT_EXT, "GL_UNPACK_CMYK_HINT_EXT" },
{ GLenum::GL_UNPACK_COMPRESSED_BLOCK_DEPTH, "GL_UNPACK_COMPRESSED_BLOCK_DEPTH" },
{ GLenum::GL_UNPACK_COMPRESSED_BLOCK_HEIGHT, "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT" },
{ GLenum::GL_UNPACK_COMPRESSED_BLOCK_SIZE, "GL_UNPACK_COMPRESSED_BLOCK_SIZE" },
{ GLenum::GL_UNPACK_COMPRESSED_BLOCK_WIDTH, "GL_UNPACK_COMPRESSED_BLOCK_WIDTH" },
{ GLenum::GL_UNPACK_CONSTANT_DATA_SUNX, "GL_UNPACK_CONSTANT_DATA_SUNX" },
{ GLenum::GL_UNPACK_IMAGE_DEPTH_SGIS, "GL_UNPACK_IMAGE_DEPTH_SGIS" },
{ GLenum::GL_UNPACK_IMAGE_HEIGHT, "GL_UNPACK_IMAGE_HEIGHT" },
{ GLenum::GL_UNPACK_IMAGE_HEIGHT_EXT, "GL_UNPACK_IMAGE_HEIGHT_EXT" },
{ GLenum::GL_UNPACK_LSB_FIRST, "GL_UNPACK_LSB_FIRST" },
{ GLenum::GL_UNPACK_RESAMPLE_OML, "GL_UNPACK_RESAMPLE_OML" },
{ GLenum::GL_UNPACK_RESAMPLE_SGIX, "GL_UNPACK_RESAMPLE_SGIX" },
{ GLenum::GL_UNPACK_ROW_BYTES_APPLE, "GL_UNPACK_ROW_BYTES_APPLE" },
{ GLenum::GL_UNPACK_ROW_LENGTH, "GL_UNPACK_ROW_LENGTH" },
{ GLenum::GL_UNPACK_SKIP_IMAGES, "GL_UNPACK_SKIP_IMAGES" },
{ GLenum::GL_UNPACK_SKIP_IMAGES_EXT, "GL_UNPACK_SKIP_IMAGES_EXT" },
{ GLenum::GL_UNPACK_SKIP_PIXELS, "GL_UNPACK_SKIP_PIXELS" },
{ GLenum::GL_UNPACK_SKIP_ROWS, "GL_UNPACK_SKIP_ROWS" },
{ GLenum::GL_UNPACK_SKIP_VOLUMES_SGIS, "GL_UNPACK_SKIP_VOLUMES_SGIS" },
{ GLenum::GL_UNPACK_SUBSAMPLE_RATE_SGIX, "GL_UNPACK_SUBSAMPLE_RATE_SGIX" },
{ GLenum::GL_UNPACK_SWAP_BYTES, "GL_UNPACK_SWAP_BYTES" },
{ GLenum::GL_UNSIGNALED, "GL_UNSIGNALED" },
{ GLenum::GL_UNSIGNED_BYTE, "GL_UNSIGNED_BYTE" },
{ GLenum::GL_UNSIGNED_BYTE_2_3_3_REV, "GL_UNSIGNED_BYTE_2_3_3_REV" },
{ GLenum::GL_UNSIGNED_BYTE_3_3_2, "GL_UNSIGNED_BYTE_3_3_2" },
{ GLenum::GL_UNSIGNED_BYTE_3_3_2_EXT, "GL_UNSIGNED_BYTE_3_3_2_EXT" },
{ GLenum::GL_UNSIGNED_IDENTITY_NV, "GL_UNSIGNED_IDENTITY_NV" },
{ GLenum::GL_UNSIGNED_INT, "GL_UNSIGNED_INT" },
{ GLenum::GL_UNSIGNED_INT16_NV, "GL_UNSIGNED_INT16_NV" },
{ GLenum::GL_UNSIGNED_INT16_VEC2_NV, "GL_UNSIGNED_INT16_VEC2_NV" },
{ GLenum::GL_UNSIGNED_INT16_VEC3_NV, "GL_UNSIGNED_INT16_VEC3_NV" },
{ GLenum::GL_UNSIGNED_INT16_VEC4_NV, "GL_UNSIGNED_INT16_VEC4_NV" },
{ GLenum::GL_UNSIGNED_INT64_AMD, "GL_UNSIGNED_INT64_AMD" },
{ GLenum::GL_UNSIGNED_INT64_ARB, "GL_UNSIGNED_INT64_ARB" },
{ GLenum::GL_UNSIGNED_INT64_NV, "GL_UNSIGNED_INT64_NV" },
{ GLenum::GL_UNSIGNED_INT64_VEC2_ARB, "GL_UNSIGNED_INT64_VEC2_ARB" },
{ GLenum::GL_UNSIGNED_INT64_VEC2_NV, "GL_UNSIGNED_INT64_VEC2_NV" },
{ GLenum::GL_UNSIGNED_INT64_VEC3_ARB, "GL_UNSIGNED_INT64_VEC3_ARB" },
{ GLenum::GL_UNSIGNED_INT64_VEC3_NV, "GL_UNSIGNED_INT64_VEC3_NV" },
{ GLenum::GL_UNSIGNED_INT64_VEC4_ARB, "GL_UNSIGNED_INT64_VEC4_ARB" },
{ GLenum::GL_UNSIGNED_INT64_VEC4_NV, "GL_UNSIGNED_INT64_VEC4_NV" },
{ GLenum::GL_UNSIGNED_INT8_NV, "GL_UNSIGNED_INT8_NV" },
{ GLenum::GL_UNSIGNED_INT8_VEC2_NV, "GL_UNSIGNED_INT8_VEC2_NV" },
{ GLenum::GL_UNSIGNED_INT8_VEC3_NV, "GL_UNSIGNED_INT8_VEC3_NV" },
{ GLenum::GL_UNSIGNED_INT8_VEC4_NV, "GL_UNSIGNED_INT8_VEC4_NV" },
{ GLenum::GL_UNSIGNED_INT_10_10_10_2, "GL_UNSIGNED_INT_10_10_10_2" },
{ GLenum::GL_UNSIGNED_INT_10_10_10_2_EXT, "GL_UNSIGNED_INT_10_10_10_2_EXT" },
{ GLenum::GL_UNSIGNED_INT_10F_11F_11F_REV, "GL_UNSIGNED_INT_10F_11F_11F_REV" },
{ GLenum::GL_UNSIGNED_INT_10F_11F_11F_REV_EXT, "GL_UNSIGNED_INT_10F_11F_11F_REV_EXT" },
{ GLenum::GL_UNSIGNED_INT_24_8, "GL_UNSIGNED_INT_24_8" },
{ GLenum::GL_UNSIGNED_INT_24_8_EXT, "GL_UNSIGNED_INT_24_8_EXT" },
{ GLenum::GL_UNSIGNED_INT_24_8_NV, "GL_UNSIGNED_INT_24_8_NV" },
{ GLenum::GL_UNSIGNED_INT_2_10_10_10_REV, "GL_UNSIGNED_INT_2_10_10_10_REV" },
{ GLenum::GL_UNSIGNED_INT_5_9_9_9_REV, "GL_UNSIGNED_INT_5_9_9_9_REV" },
{ GLenum::GL_UNSIGNED_INT_5_9_9_9_REV_EXT, "GL_UNSIGNED_INT_5_9_9_9_REV_EXT" },
{ GLenum::GL_UNSIGNED_INT_8_8_8_8, "GL_UNSIGNED_INT_8_8_8_8" },
{ GLenum::GL_UNSIGNED_INT_8_8_8_8_EXT, "GL_UNSIGNED_INT_8_8_8_8_EXT" },
{ GLenum::GL_UNSIGNED_INT_8_8_8_8_REV, "GL_UNSIGNED_INT_8_8_8_8_REV" },
{ GLenum::GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV" },
{ GLenum::GL_UNSIGNED_INT_ATOMIC_COUNTER, "GL_UNSIGNED_INT_ATOMIC_COUNTER" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_1D, "GL_UNSIGNED_INT_IMAGE_1D" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_1D_ARRAY, "GL_UNSIGNED_INT_IMAGE_1D_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT, "GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_1D_EXT, "GL_UNSIGNED_INT_IMAGE_1D_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D, "GL_UNSIGNED_INT_IMAGE_2D" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_ARRAY, "GL_UNSIGNED_INT_IMAGE_2D_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT, "GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_EXT, "GL_UNSIGNED_INT_IMAGE_2D_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_RECT, "GL_UNSIGNED_INT_IMAGE_2D_RECT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT, "GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_3D, "GL_UNSIGNED_INT_IMAGE_3D" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_3D_EXT, "GL_UNSIGNED_INT_IMAGE_3D_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_BUFFER, "GL_UNSIGNED_INT_IMAGE_BUFFER" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_BUFFER_EXT, "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_CUBE, "GL_UNSIGNED_INT_IMAGE_CUBE" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_CUBE_EXT, "GL_UNSIGNED_INT_IMAGE_CUBE_EXT" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_S8_S8_8_8_NV, "GL_UNSIGNED_INT_S8_S8_8_8_NV" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_1D, "GL_UNSIGNED_INT_SAMPLER_1D" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_1D_ARRAY, "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT, "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_1D_EXT, "GL_UNSIGNED_INT_SAMPLER_1D_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D, "GL_UNSIGNED_INT_SAMPLER_2D" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT, "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_EXT, "GL_UNSIGNED_INT_SAMPLER_2D_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_RECT, "GL_UNSIGNED_INT_SAMPLER_2D_RECT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT, "GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_3D, "GL_UNSIGNED_INT_SAMPLER_3D" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_3D_EXT, "GL_UNSIGNED_INT_SAMPLER_3D_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_BUFFER, "GL_UNSIGNED_INT_SAMPLER_BUFFER" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD, "GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT, "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_CUBE, "GL_UNSIGNED_INT_SAMPLER_CUBE" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_CUBE_EXT, "GL_UNSIGNED_INT_SAMPLER_CUBE_EXT" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY, "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB, "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB" },
{ GLenum::GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV, "GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV" },
{ GLenum::GL_UNSIGNED_INT_VEC2, "GL_UNSIGNED_INT_VEC2" },
{ GLenum::GL_UNSIGNED_INT_VEC2_EXT, "GL_UNSIGNED_INT_VEC2_EXT" },
{ GLenum::GL_UNSIGNED_INT_VEC3, "GL_UNSIGNED_INT_VEC3" },
{ GLenum::GL_UNSIGNED_INT_VEC3_EXT, "GL_UNSIGNED_INT_VEC3_EXT" },
{ GLenum::GL_UNSIGNED_INT_VEC4, "GL_UNSIGNED_INT_VEC4" },
{ GLenum::GL_UNSIGNED_INT_VEC4_EXT, "GL_UNSIGNED_INT_VEC4_EXT" },
{ GLenum::GL_UNSIGNED_INVERT_NV, "GL_UNSIGNED_INVERT_NV" },
{ GLenum::GL_UNSIGNED_NORMALIZED, "GL_UNSIGNED_NORMALIZED" },
{ GLenum::GL_UNSIGNED_NORMALIZED_ARB, "GL_UNSIGNED_NORMALIZED_ARB" },
{ GLenum::GL_UNSIGNED_SHORT, "GL_UNSIGNED_SHORT" },
{ GLenum::GL_UNSIGNED_SHORT_1_5_5_5_REV, "GL_UNSIGNED_SHORT_1_5_5_5_REV" },
{ GLenum::GL_UNSIGNED_SHORT_4_4_4_4, "GL_UNSIGNED_SHORT_4_4_4_4" },
{ GLenum::GL_UNSIGNED_SHORT_4_4_4_4_EXT, "GL_UNSIGNED_SHORT_4_4_4_4_EXT" },
{ GLenum::GL_UNSIGNED_SHORT_4_4_4_4_REV, "GL_UNSIGNED_SHORT_4_4_4_4_REV" },
{ GLenum::GL_UNSIGNED_SHORT_5_5_5_1, "GL_UNSIGNED_SHORT_5_5_5_1" },
{ GLenum::GL_UNSIGNED_SHORT_5_5_5_1_EXT, "GL_UNSIGNED_SHORT_5_5_5_1_EXT" },
{ GLenum::GL_UNSIGNED_SHORT_5_6_5, "GL_UNSIGNED_SHORT_5_6_5" },
{ GLenum::GL_UNSIGNED_SHORT_5_6_5_REV, "GL_UNSIGNED_SHORT_5_6_5_REV" },
{ GLenum::GL_UNSIGNED_SHORT_8_8_APPLE, "GL_UNSIGNED_SHORT_8_8_APPLE" },
{ GLenum::GL_UNSIGNED_SHORT_8_8_MESA, "GL_UNSIGNED_SHORT_8_8_MESA" },
{ GLenum::GL_UNSIGNED_SHORT_8_8_REV_APPLE, "GL_UNSIGNED_SHORT_8_8_REV_APPLE" },
{ GLenum::GL_UNSIGNED_SHORT_8_8_REV_MESA, "GL_UNSIGNED_SHORT_8_8_REV_MESA" },
{ GLenum::GL_UPLOAD_GPU_MASK_NVX, "GL_UPLOAD_GPU_MASK_NVX" },
{ GLenum::GL_UPPER_LEFT, "GL_UPPER_LEFT" },
{ GLenum::GL_USE_MISSING_GLYPH_NV, "GL_USE_MISSING_GLYPH_NV" },
{ GLenum::GL_UTF16_NV, "GL_UTF16_NV" },
{ GLenum::GL_UTF8_NV, "GL_UTF8_NV" },
{ GLenum::GL_V2F, "GL_V2F" },
{ GLenum::GL_V3F, "GL_V3F" },
{ GLenum::GL_VALIDATE_STATUS, "GL_VALIDATE_STATUS" },
{ GLenum::GL_VARIABLE_A_NV, "GL_VARIABLE_A_NV" },
{ GLenum::GL_VARIABLE_B_NV, "GL_VARIABLE_B_NV" },
{ GLenum::GL_VARIABLE_C_NV, "GL_VARIABLE_C_NV" },
{ GLenum::GL_VARIABLE_D_NV, "GL_VARIABLE_D_NV" },
{ GLenum::GL_VARIABLE_E_NV, "GL_VARIABLE_E_NV" },
{ GLenum::GL_VARIABLE_F_NV, "GL_VARIABLE_F_NV" },
{ GLenum::GL_VARIABLE_G_NV, "GL_VARIABLE_G_NV" },
{ GLenum::GL_VARIANT_ARRAY_EXT, "GL_VARIANT_ARRAY_EXT" },
{ GLenum::GL_VARIANT_ARRAY_POINTER_EXT, "GL_VARIANT_ARRAY_POINTER_EXT" },
{ GLenum::GL_VARIANT_ARRAY_STRIDE_EXT, "GL_VARIANT_ARRAY_STRIDE_EXT" },
{ GLenum::GL_VARIANT_ARRAY_TYPE_EXT, "GL_VARIANT_ARRAY_TYPE_EXT" },
{ GLenum::GL_VARIANT_DATATYPE_EXT, "GL_VARIANT_DATATYPE_EXT" },
{ GLenum::GL_VARIANT_EXT, "GL_VARIANT_EXT" },
{ GLenum::GL_VARIANT_VALUE_EXT, "GL_VARIANT_VALUE_EXT" },
{ GLenum::GL_VBO_FREE_MEMORY_ATI, "GL_VBO_FREE_MEMORY_ATI" },
{ GLenum::GL_VECTOR_EXT, "GL_VECTOR_EXT" },
{ GLenum::GL_VENDOR, "GL_VENDOR" },
{ GLenum::GL_VERSION, "GL_VERSION" },
{ GLenum::GL_VERTEX_ARRAY, "GL_VERTEX_ARRAY" },
{ GLenum::GL_VERTEX_ARRAY_ADDRESS_NV, "GL_VERTEX_ARRAY_ADDRESS_NV" },
{ GLenum::GL_VERTEX_ARRAY_BINDING, "GL_VERTEX_ARRAY_BINDING" },
{ GLenum::GL_VERTEX_ARRAY_BINDING_APPLE, "GL_VERTEX_ARRAY_BINDING_APPLE" },
{ GLenum::GL_VERTEX_ARRAY_BUFFER_BINDING, "GL_VERTEX_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_VERTEX_ARRAY_COUNT_EXT, "GL_VERTEX_ARRAY_COUNT_EXT" },
{ GLenum::GL_VERTEX_ARRAY_EXT, "GL_VERTEX_ARRAY_EXT" },
{ GLenum::GL_VERTEX_ARRAY_KHR, "GL_VERTEX_ARRAY_KHR" },
{ GLenum::GL_VERTEX_ARRAY_LENGTH_NV, "GL_VERTEX_ARRAY_LENGTH_NV" },
{ GLenum::GL_VERTEX_ARRAY_LIST_IBM, "GL_VERTEX_ARRAY_LIST_IBM" },
{ GLenum::GL_VERTEX_ARRAY_LIST_STRIDE_IBM, "GL_VERTEX_ARRAY_LIST_STRIDE_IBM" },
{ GLenum::GL_VERTEX_ARRAY_OBJECT_AMD, "GL_VERTEX_ARRAY_OBJECT_AMD" },
{ GLenum::GL_VERTEX_ARRAY_OBJECT_EXT, "GL_VERTEX_ARRAY_OBJECT_EXT" },
{ GLenum::GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL, "GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL" },
{ GLenum::GL_VERTEX_ARRAY_POINTER, "GL_VERTEX_ARRAY_POINTER" },
{ GLenum::GL_VERTEX_ARRAY_POINTER_EXT, "GL_VERTEX_ARRAY_POINTER_EXT" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_APPLE, "GL_VERTEX_ARRAY_RANGE_APPLE" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE, "GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_LENGTH_NV, "GL_VERTEX_ARRAY_RANGE_LENGTH_NV" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_NV, "GL_VERTEX_ARRAY_RANGE_NV" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_POINTER_APPLE, "GL_VERTEX_ARRAY_RANGE_POINTER_APPLE" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_POINTER_NV, "GL_VERTEX_ARRAY_RANGE_POINTER_NV" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_VALID_NV, "GL_VERTEX_ARRAY_RANGE_VALID_NV" },
{ GLenum::GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV, "GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV" },
{ GLenum::GL_VERTEX_ARRAY_SIZE, "GL_VERTEX_ARRAY_SIZE" },
{ GLenum::GL_VERTEX_ARRAY_SIZE_EXT, "GL_VERTEX_ARRAY_SIZE_EXT" },
{ GLenum::GL_VERTEX_ARRAY_STORAGE_HINT_APPLE, "GL_VERTEX_ARRAY_STORAGE_HINT_APPLE" },
{ GLenum::GL_VERTEX_ARRAY_STRIDE, "GL_VERTEX_ARRAY_STRIDE" },
{ GLenum::GL_VERTEX_ARRAY_STRIDE_EXT, "GL_VERTEX_ARRAY_STRIDE_EXT" },
{ GLenum::GL_VERTEX_ARRAY_TYPE, "GL_VERTEX_ARRAY_TYPE" },
{ GLenum::GL_VERTEX_ARRAY_TYPE_EXT, "GL_VERTEX_ARRAY_TYPE_EXT" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY0_NV, "GL_VERTEX_ATTRIB_ARRAY0_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY10_NV, "GL_VERTEX_ATTRIB_ARRAY10_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY11_NV, "GL_VERTEX_ATTRIB_ARRAY11_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY12_NV, "GL_VERTEX_ATTRIB_ARRAY12_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY13_NV, "GL_VERTEX_ATTRIB_ARRAY13_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY14_NV, "GL_VERTEX_ATTRIB_ARRAY14_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY15_NV, "GL_VERTEX_ATTRIB_ARRAY15_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY1_NV, "GL_VERTEX_ATTRIB_ARRAY1_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY2_NV, "GL_VERTEX_ATTRIB_ARRAY2_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY3_NV, "GL_VERTEX_ATTRIB_ARRAY3_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY4_NV, "GL_VERTEX_ATTRIB_ARRAY4_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY5_NV, "GL_VERTEX_ATTRIB_ARRAY5_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY6_NV, "GL_VERTEX_ATTRIB_ARRAY6_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY7_NV, "GL_VERTEX_ATTRIB_ARRAY7_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY8_NV, "GL_VERTEX_ATTRIB_ARRAY8_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY9_NV, "GL_VERTEX_ATTRIB_ARRAY9_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, "GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_DIVISOR, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_ENABLED, "GL_VERTEX_ATTRIB_ARRAY_ENABLED" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_INTEGER, "GL_VERTEX_ATTRIB_ARRAY_INTEGER" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT, "GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV, "GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV, "GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_LONG, "GL_VERTEX_ATTRIB_ARRAY_LONG" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_POINTER, "GL_VERTEX_ATTRIB_ARRAY_POINTER" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_SIZE, "GL_VERTEX_ATTRIB_ARRAY_SIZE" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB, "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_STRIDE, "GL_VERTEX_ATTRIB_ARRAY_STRIDE" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB, "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_TYPE, "GL_VERTEX_ATTRIB_ARRAY_TYPE" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB, "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB" },
{ GLenum::GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV, "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV" },
{ GLenum::GL_VERTEX_ATTRIB_BINDING, "GL_VERTEX_ATTRIB_BINDING" },
{ GLenum::GL_VERTEX_ATTRIB_MAP1_APPLE, "GL_VERTEX_ATTRIB_MAP1_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE, "GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE, "GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE, "GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE, "GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP2_APPLE, "GL_VERTEX_ATTRIB_MAP2_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE, "GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE, "GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE, "GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE, "GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE" },
{ GLenum::GL_VERTEX_ATTRIB_RELATIVE_OFFSET, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET" },
{ GLenum::GL_VERTEX_BINDING_BUFFER, "GL_VERTEX_BINDING_BUFFER" },
{ GLenum::GL_VERTEX_BINDING_DIVISOR, "GL_VERTEX_BINDING_DIVISOR" },
{ GLenum::GL_VERTEX_BINDING_OFFSET, "GL_VERTEX_BINDING_OFFSET" },
{ GLenum::GL_VERTEX_BINDING_STRIDE, "GL_VERTEX_BINDING_STRIDE" },
{ GLenum::GL_VERTEX_BLEND_ARB, "GL_VERTEX_BLEND_ARB" },
{ GLenum::GL_VERTEX_CONSISTENT_HINT_PGI, "GL_VERTEX_CONSISTENT_HINT_PGI" },
{ GLenum::GL_VERTEX_DATA_HINT_PGI, "GL_VERTEX_DATA_HINT_PGI" },
{ GLenum::GL_VERTEX_ELEMENT_SWIZZLE_AMD, "GL_VERTEX_ELEMENT_SWIZZLE_AMD" },
{ GLenum::GL_VERTEX_ID_NV, "GL_VERTEX_ID_NV" },
{ GLenum::GL_VERTEX_ID_SWIZZLE_AMD, "GL_VERTEX_ID_SWIZZLE_AMD" },
{ GLenum::GL_VERTEX_PRECLIP_HINT_SGIX, "GL_VERTEX_PRECLIP_HINT_SGIX" },
{ GLenum::GL_VERTEX_PRECLIP_SGIX, "GL_VERTEX_PRECLIP_SGIX" },
{ GLenum::GL_VERTEX_PROGRAM_ARB, "GL_VERTEX_PROGRAM_ARB" },
{ GLenum::GL_VERTEX_PROGRAM_BINDING_NV, "GL_VERTEX_PROGRAM_BINDING_NV" },
{ GLenum::GL_VERTEX_PROGRAM_NV, "GL_VERTEX_PROGRAM_NV" },
{ GLenum::GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV, "GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV" },
{ GLenum::GL_VERTEX_PROGRAM_POINT_SIZE, "GL_VERTEX_PROGRAM_POINT_SIZE" },
{ GLenum::GL_VERTEX_PROGRAM_POINT_SIZE_ARB, "GL_VERTEX_PROGRAM_POINT_SIZE_ARB" },
{ GLenum::GL_VERTEX_PROGRAM_POINT_SIZE_NV, "GL_VERTEX_PROGRAM_POINT_SIZE_NV" },
{ GLenum::GL_VERTEX_PROGRAM_TWO_SIDE, "GL_VERTEX_PROGRAM_TWO_SIDE" },
{ GLenum::GL_VERTEX_PROGRAM_TWO_SIDE_ARB, "GL_VERTEX_PROGRAM_TWO_SIDE_ARB" },
{ GLenum::GL_VERTEX_PROGRAM_TWO_SIDE_NV, "GL_VERTEX_PROGRAM_TWO_SIDE_NV" },
{ GLenum::GL_VERTEX_SHADER, "GL_VERTEX_SHADER" },
{ GLenum::GL_VERTEX_SHADER_ARB, "GL_VERTEX_SHADER_ARB" },
{ GLenum::GL_VERTEX_SHADER_BINDING_EXT, "GL_VERTEX_SHADER_BINDING_EXT" },
{ GLenum::GL_VERTEX_SHADER_EXT, "GL_VERTEX_SHADER_EXT" },
{ GLenum::GL_VERTEX_SHADER_INSTRUCTIONS_EXT, "GL_VERTEX_SHADER_INSTRUCTIONS_EXT" },
{ GLenum::GL_VERTEX_SHADER_INVARIANTS_EXT, "GL_VERTEX_SHADER_INVARIANTS_EXT" },
{ GLenum::GL_VERTEX_SHADER_INVOCATIONS, "GL_VERTEX_SHADER_INVOCATIONS" },
{ GLenum::GL_VERTEX_SHADER_INVOCATIONS_ARB, "GL_VERTEX_SHADER_INVOCATIONS_ARB" },
{ GLenum::GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, "GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT" },
{ GLenum::GL_VERTEX_SHADER_LOCALS_EXT, "GL_VERTEX_SHADER_LOCALS_EXT" },
{ GLenum::GL_VERTEX_SHADER_OPTIMIZED_EXT, "GL_VERTEX_SHADER_OPTIMIZED_EXT" },
{ GLenum::GL_VERTEX_SHADER_VARIANTS_EXT, "GL_VERTEX_SHADER_VARIANTS_EXT" },
{ GLenum::GL_VERTEX_SOURCE_ATI, "GL_VERTEX_SOURCE_ATI" },
{ GLenum::GL_VERTEX_STATE_PROGRAM_NV, "GL_VERTEX_STATE_PROGRAM_NV" },
{ GLenum::GL_VERTEX_STREAM0_ATI, "GL_VERTEX_STREAM0_ATI" },
{ GLenum::GL_VERTEX_STREAM1_ATI, "GL_VERTEX_STREAM1_ATI" },
{ GLenum::GL_VERTEX_STREAM2_ATI, "GL_VERTEX_STREAM2_ATI" },
{ GLenum::GL_VERTEX_STREAM3_ATI, "GL_VERTEX_STREAM3_ATI" },
{ GLenum::GL_VERTEX_STREAM4_ATI, "GL_VERTEX_STREAM4_ATI" },
{ GLenum::GL_VERTEX_STREAM5_ATI, "GL_VERTEX_STREAM5_ATI" },
{ GLenum::GL_VERTEX_STREAM6_ATI, "GL_VERTEX_STREAM6_ATI" },
{ GLenum::GL_VERTEX_STREAM7_ATI, "GL_VERTEX_STREAM7_ATI" },
{ GLenum::GL_VERTEX_SUBROUTINE, "GL_VERTEX_SUBROUTINE" },
{ GLenum::GL_VERTEX_SUBROUTINE_UNIFORM, "GL_VERTEX_SUBROUTINE_UNIFORM" },
{ GLenum::GL_VERTEX_TEXTURE, "GL_VERTEX_TEXTURE" },
{ GLenum::GL_VERTEX_WEIGHT_ARRAY_EXT, "GL_VERTEX_WEIGHT_ARRAY_EXT" },
{ GLenum::GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT, "GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT" },
{ GLenum::GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT, "GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT" },
{ GLenum::GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT, "GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT" },
{ GLenum::GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT, "GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT" },
{ GLenum::GL_VERTEX_WEIGHTING_EXT, "GL_VERTEX_WEIGHTING_EXT" },
{ GLenum::GL_VERTICAL_LINE_TO_NV, "GL_VERTICAL_LINE_TO_NV" },
{ GLenum::GL_VERTICES_SUBMITTED, "GL_VERTICES_SUBMITTED" },
{ GLenum::GL_VERTICES_SUBMITTED_ARB, "GL_VERTICES_SUBMITTED_ARB" },
{ GLenum::GL_VIBRANCE_BIAS_NV, "GL_VIBRANCE_BIAS_NV" },
{ GLenum::GL_VIBRANCE_SCALE_NV, "GL_VIBRANCE_SCALE_NV" },
{ GLenum::GL_VIDEO_BUFFER_BINDING_NV, "GL_VIDEO_BUFFER_BINDING_NV" },
{ GLenum::GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV, "GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV" },
{ GLenum::GL_VIDEO_BUFFER_NV, "GL_VIDEO_BUFFER_NV" },
{ GLenum::GL_VIDEO_BUFFER_PITCH_NV, "GL_VIDEO_BUFFER_PITCH_NV" },
{ GLenum::GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV, "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV" },
{ GLenum::GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV, "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV" },
{ GLenum::GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV, "GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV" },
{ GLenum::GL_VIDEO_CAPTURE_FRAME_WIDTH_NV, "GL_VIDEO_CAPTURE_FRAME_WIDTH_NV" },
{ GLenum::GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV, "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV" },
{ GLenum::GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV, "GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV" },
{ GLenum::GL_VIDEO_COLOR_CONVERSION_MATRIX_NV, "GL_VIDEO_COLOR_CONVERSION_MATRIX_NV" },
{ GLenum::GL_VIDEO_COLOR_CONVERSION_MAX_NV, "GL_VIDEO_COLOR_CONVERSION_MAX_NV" },
{ GLenum::GL_VIDEO_COLOR_CONVERSION_MIN_NV, "GL_VIDEO_COLOR_CONVERSION_MIN_NV" },
{ GLenum::GL_VIDEO_COLOR_CONVERSION_OFFSET_NV, "GL_VIDEO_COLOR_CONVERSION_OFFSET_NV" },
{ GLenum::GL_VIEW_CLASS_128_BITS, "GL_VIEW_CLASS_128_BITS" },
{ GLenum::GL_VIEW_CLASS_16_BITS, "GL_VIEW_CLASS_16_BITS" },
{ GLenum::GL_VIEW_CLASS_24_BITS, "GL_VIEW_CLASS_24_BITS" },
{ GLenum::GL_VIEW_CLASS_32_BITS, "GL_VIEW_CLASS_32_BITS" },
{ GLenum::GL_VIEW_CLASS_48_BITS, "GL_VIEW_CLASS_48_BITS" },
{ GLenum::GL_VIEW_CLASS_64_BITS, "GL_VIEW_CLASS_64_BITS" },
{ GLenum::GL_VIEW_CLASS_8_BITS, "GL_VIEW_CLASS_8_BITS" },
{ GLenum::GL_VIEW_CLASS_96_BITS, "GL_VIEW_CLASS_96_BITS" },
{ GLenum::GL_VIEW_CLASS_ASTC_10x10_RGBA, "GL_VIEW_CLASS_ASTC_10x10_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_10x5_RGBA, "GL_VIEW_CLASS_ASTC_10x5_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_10x6_RGBA, "GL_VIEW_CLASS_ASTC_10x6_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_10x8_RGBA, "GL_VIEW_CLASS_ASTC_10x8_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_12x10_RGBA, "GL_VIEW_CLASS_ASTC_12x10_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_12x12_RGBA, "GL_VIEW_CLASS_ASTC_12x12_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_4x4_RGBA, "GL_VIEW_CLASS_ASTC_4x4_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_5x4_RGBA, "GL_VIEW_CLASS_ASTC_5x4_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_5x5_RGBA, "GL_VIEW_CLASS_ASTC_5x5_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_6x5_RGBA, "GL_VIEW_CLASS_ASTC_6x5_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_6x6_RGBA, "GL_VIEW_CLASS_ASTC_6x6_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_8x5_RGBA, "GL_VIEW_CLASS_ASTC_8x5_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_8x6_RGBA, "GL_VIEW_CLASS_ASTC_8x6_RGBA" },
{ GLenum::GL_VIEW_CLASS_ASTC_8x8_RGBA, "GL_VIEW_CLASS_ASTC_8x8_RGBA" },
{ GLenum::GL_VIEW_CLASS_BPTC_FLOAT, "GL_VIEW_CLASS_BPTC_FLOAT" },
{ GLenum::GL_VIEW_CLASS_BPTC_UNORM, "GL_VIEW_CLASS_BPTC_UNORM" },
{ GLenum::GL_VIEW_CLASS_EAC_R11, "GL_VIEW_CLASS_EAC_R11" },
{ GLenum::GL_VIEW_CLASS_EAC_RG11, "GL_VIEW_CLASS_EAC_RG11" },
{ GLenum::GL_VIEW_CLASS_ETC2_EAC_RGBA, "GL_VIEW_CLASS_ETC2_EAC_RGBA" },
{ GLenum::GL_VIEW_CLASS_ETC2_RGB, "GL_VIEW_CLASS_ETC2_RGB" },
{ GLenum::GL_VIEW_CLASS_ETC2_RGBA, "GL_VIEW_CLASS_ETC2_RGBA" },
{ GLenum::GL_VIEW_CLASS_RGTC1_RED, "GL_VIEW_CLASS_RGTC1_RED" },
{ GLenum::GL_VIEW_CLASS_RGTC2_RG, "GL_VIEW_CLASS_RGTC2_RG" },
{ GLenum::GL_VIEW_CLASS_S3TC_DXT1_RGB, "GL_VIEW_CLASS_S3TC_DXT1_RGB" },
{ GLenum::GL_VIEW_CLASS_S3TC_DXT1_RGBA, "GL_VIEW_CLASS_S3TC_DXT1_RGBA" },
{ GLenum::GL_VIEW_CLASS_S3TC_DXT3_RGBA, "GL_VIEW_CLASS_S3TC_DXT3_RGBA" },
{ GLenum::GL_VIEW_CLASS_S3TC_DXT5_RGBA, "GL_VIEW_CLASS_S3TC_DXT5_RGBA" },
{ GLenum::GL_VIEW_COMPATIBILITY_CLASS, "GL_VIEW_COMPATIBILITY_CLASS" },
{ GLenum::GL_VIEWPORT, "GL_VIEWPORT" },
{ GLenum::GL_VIEWPORT_BOUNDS_RANGE, "GL_VIEWPORT_BOUNDS_RANGE" },
{ GLenum::GL_VIEWPORT_COMMAND_NV, "GL_VIEWPORT_COMMAND_NV" },
{ GLenum::GL_VIEWPORT_INDEX_PROVOKING_VERTEX, "GL_VIEWPORT_INDEX_PROVOKING_VERTEX" },
{ GLenum::GL_VIEWPORT_POSITION_W_SCALE_NV, "GL_VIEWPORT_POSITION_W_SCALE_NV" },
{ GLenum::GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV, "GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV" },
{ GLenum::GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV, "GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV" },
{ GLenum::GL_VIEWPORT_SUBPIXEL_BITS, "GL_VIEWPORT_SUBPIXEL_BITS" },
{ GLenum::GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV, "GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV, "GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV, "GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV, "GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV, "GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV, "GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV, "GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV, "GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_W_NV, "GL_VIEWPORT_SWIZZLE_W_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_X_NV, "GL_VIEWPORT_SWIZZLE_X_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_Y_NV, "GL_VIEWPORT_SWIZZLE_Y_NV" },
{ GLenum::GL_VIEWPORT_SWIZZLE_Z_NV, "GL_VIEWPORT_SWIZZLE_Z_NV" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, "GL_VIRTUAL_PAGE_SIZE_INDEX_ARB" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_X_AMD, "GL_VIRTUAL_PAGE_SIZE_X_AMD" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_X_ARB, "GL_VIRTUAL_PAGE_SIZE_X_ARB" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_Y_AMD, "GL_VIRTUAL_PAGE_SIZE_Y_AMD" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_Y_ARB, "GL_VIRTUAL_PAGE_SIZE_Y_ARB" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_Z_AMD, "GL_VIRTUAL_PAGE_SIZE_Z_AMD" },
{ GLenum::GL_VIRTUAL_PAGE_SIZE_Z_ARB, "GL_VIRTUAL_PAGE_SIZE_Z_ARB" },
{ GLenum::GL_VIVIDLIGHT_NV, "GL_VIVIDLIGHT_NV" },
{ GLenum::GL_VOLATILE_APPLE, "GL_VOLATILE_APPLE" },
{ GLenum::GL_W_EXT, "GL_W_EXT" },
{ GLenum::GL_WAIT_FAILED, "GL_WAIT_FAILED" },
{ GLenum::GL_WARP_SIZE_NV, "GL_WARP_SIZE_NV" },
{ GLenum::GL_WARPS_PER_SM_NV, "GL_WARPS_PER_SM_NV" },
{ GLenum::GL_WEIGHT_ARRAY_ARB, "GL_WEIGHT_ARRAY_ARB" },
{ GLenum::GL_WEIGHT_ARRAY_BUFFER_BINDING, "GL_WEIGHT_ARRAY_BUFFER_BINDING" },
{ GLenum::GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB, "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB" },
{ GLenum::GL_WEIGHT_ARRAY_POINTER_ARB, "GL_WEIGHT_ARRAY_POINTER_ARB" },
{ GLenum::GL_WEIGHT_ARRAY_SIZE_ARB, "GL_WEIGHT_ARRAY_SIZE_ARB" },
{ GLenum::GL_WEIGHT_ARRAY_STRIDE_ARB, "GL_WEIGHT_ARRAY_STRIDE_ARB" },
{ GLenum::GL_WEIGHT_ARRAY_TYPE_ARB, "GL_WEIGHT_ARRAY_TYPE_ARB" },
{ GLenum::GL_WEIGHT_SUM_UNITY_ARB, "GL_WEIGHT_SUM_UNITY_ARB" },
{ GLenum::GL_WEIGHTED_AVERAGE_ARB, "GL_WEIGHTED_AVERAGE_ARB" },
{ GLenum::GL_WEIGHTED_AVERAGE_EXT, "GL_WEIGHTED_AVERAGE_EXT" },
{ GLenum::GL_WIDE_LINE_HINT_PGI, "GL_WIDE_LINE_HINT_PGI" },
{ GLenum::GL_WINDOW_RECTANGLE_EXT, "GL_WINDOW_RECTANGLE_EXT" },
{ GLenum::GL_WINDOW_RECTANGLE_MODE_EXT, "GL_WINDOW_RECTANGLE_MODE_EXT" },
{ GLenum::GL_WRAP_BORDER_SUN, "GL_WRAP_BORDER_SUN" },
{ GLenum::GL_WRITE_DISCARD_NV, "GL_WRITE_DISCARD_NV" },
{ GLenum::GL_WRITE_ONLY, "GL_WRITE_ONLY" },
{ GLenum::GL_WRITE_ONLY_ARB, "GL_WRITE_ONLY_ARB" },
{ GLenum::GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV, "GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV" },
{ GLenum::GL_WRITE_PIXEL_DATA_RANGE_NV, "GL_WRITE_PIXEL_DATA_RANGE_NV" },
{ GLenum::GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV, "GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV" },
{ GLenum::GL_X_EXT, "GL_X_EXT" },
{ GLenum::GL_XOR, "GL_XOR" },
{ GLenum::GL_XOR_NV, "GL_XOR_NV" },
{ GLenum::GL_Y_EXT, "GL_Y_EXT" },
{ GLenum::GL_YCBAYCR8A_4224_NV, "GL_YCBAYCR8A_4224_NV" },
{ GLenum::GL_YCBCR_422_APPLE, "GL_YCBCR_422_APPLE" },
{ GLenum::GL_YCBCR_MESA, "GL_YCBCR_MESA" },
{ GLenum::GL_YCBYCR8_422_NV, "GL_YCBYCR8_422_NV" },
{ GLenum::GL_YCRCB_422_SGIX, "GL_YCRCB_422_SGIX" },
{ GLenum::GL_YCRCB_444_SGIX, "GL_YCRCB_444_SGIX" },
{ GLenum::GL_YCRCB_SGIX, "GL_YCRCB_SGIX" },
{ GLenum::GL_YCRCBA_SGIX, "GL_YCRCBA_SGIX" },
{ GLenum::GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV, "GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV" },
{ GLenum::GL_Z4Y12Z4CB12Z4CR12_444_NV, "GL_Z4Y12Z4CB12Z4CR12_444_NV" },
{ GLenum::GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV, "GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV" },
{ GLenum::GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV, "GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV" },
{ GLenum::GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV, "GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV" },
{ GLenum::GL_Z_EXT, "GL_Z_EXT" },
{ GLenum::GL_ZERO, "GL_ZERO" },
{ GLenum::GL_ZERO_EXT, "GL_ZERO_EXT" },
{ GLenum::GL_ZERO_TO_ONE, "GL_ZERO_TO_ONE" },
{ GLenum::GL_ZOOM_X, "GL_ZOOM_X" },
{ GLenum::GL_ZOOM_Y, "GL_ZOOM_Y" }
};
} } // namespace glbinding::aux | 68.985855 | 143 | 0.768785 | sagpant |
a33939937f0e5327979204334bdaa92c6b3191cd | 5,861 | hpp | C++ | vec-kernels/include/sctl/morton.hpp | ejyoo921/FMM3D | 6aeb4031340c1aeca0754f0fd2b7ef8e754a449e | [
"Apache-2.0"
] | 71 | 2019-06-03T21:22:37.000Z | 2022-03-03T01:15:45.000Z | vec-kernels/include/sctl/morton.hpp | ejyoo921/FMM3D | 6aeb4031340c1aeca0754f0fd2b7ef8e754a449e | [
"Apache-2.0"
] | 14 | 2019-08-22T19:58:36.000Z | 2022-02-08T19:01:06.000Z | vec-kernels/include/sctl/morton.hpp | ejyoo921/FMM3D | 6aeb4031340c1aeca0754f0fd2b7ef8e754a449e | [
"Apache-2.0"
] | 23 | 2019-09-13T21:30:35.000Z | 2022-02-26T12:34:42.000Z | #ifndef _SCTL_MORTON_
#define _SCTL_MORTON_
#include SCTL_INCLUDE(common.hpp)
#include <cstdint>
#ifndef SCTL_MAX_DEPTH
#define SCTL_MAX_DEPTH 15
#endif
namespace SCTL_NAMESPACE {
template <class ValueType> class Vector;
template <Integer DIM = 3> class Morton {
public:
#if SCTL_MAX_DEPTH < 7
typedef uint8_t UINT_T;
#elif SCTL_MAX_DEPTH < 15
typedef uint16_t UINT_T;
#elif SCTL_MAX_DEPTH < 31
typedef uint32_t UINT_T;
#elif SCTL_MAX_DEPTH < 63
typedef uint64_t UINT_T;
#endif
static const Integer MAX_DEPTH = SCTL_MAX_DEPTH;
Morton() {
depth = 0;
for (Integer i = 0; i < DIM; i++) x[i] = 0;
}
template <class T> Morton(ConstIterator<T> coord, uint8_t depth_ = MAX_DEPTH) {
depth = depth_;
assert(depth <= MAX_DEPTH);
UINT_T mask = ~((((UINT_T)1) << (MAX_DEPTH - depth)) - 1);
for (Integer i = 0; i < DIM; i++) x[i] = mask & (UINT_T)floor(coord[i] * maxCoord);
}
uint8_t Depth() const { return depth; }
template <class T> void Coord(Iterator<T> coord) const {
static const T s = 1.0 / ((T)maxCoord);
for (Integer i = 0; i < DIM; i++) coord[i] = x[i] * s;
}
Morton Next() const {
UINT_T mask = ((UINT_T)1) << (MAX_DEPTH - depth);
Integer d, i;
Morton m = *this;
for (d = depth; d >= 0; d--) {
for (i = 0; i < DIM; i++) {
m.x[i] = (m.x[i] ^ mask);
if ((m.x[i] & mask)) break;
}
if (i < DIM) break;
mask = (mask << 1);
}
if (d < 0) d = 0;
m.depth = (uint8_t)d;
return m;
}
Morton Ancestor(uint8_t ancestor_level) const {
UINT_T mask = ~((((UINT_T)1) << (MAX_DEPTH - ancestor_level)) - 1);
Morton m;
for (Integer i = 0; i < DIM; i++) m.x[i] = x[i] & mask;
m.depth = ancestor_level;
return m;
}
/**
* \brief Returns the deepest first descendant.
*/
Morton DFD(uint8_t level = MAX_DEPTH) const {
Morton m = *this;
m.depth = level;
return m;
}
void NbrList(Vector<Morton> &nlst, uint8_t level, bool periodic) const {
nlst.ReInit(1);
UINT_T mask = ~((((UINT_T)1) << (MAX_DEPTH - level)) - 1);
for (Integer i = 0; i < DIM; i++) nlst[0].x[i] = x[i] & mask;
nlst[0].depth = level;
Morton m;
Integer k = 1;
mask = (((UINT_T)1) << (MAX_DEPTH - level));
if (periodic) {
for (Integer i = 0; i < DIM; i++) {
for (Integer j = 0; j < k; j++) {
m = nlst[j];
m.x[i] = (m.x[i] + mask) & (maxCoord - 1);
nlst.PushBack(m);
}
for (Integer j = 0; j < k; j++) {
m = nlst[j];
m.x[i] = (m.x[i] - mask) & (maxCoord - 1);
nlst.PushBack(m);
}
k = nlst.Dim();
}
} else {
for (Integer i = 0; i < DIM; i++) {
for (Integer j = 0; j < k; j++) {
m = nlst[j];
if (m.x[i] + mask < maxCoord) {
m.x[i] += mask;
nlst.PushBack(m);
}
}
for (Integer j = 0; j < k; j++) {
m = nlst[j];
if (m.x[i] >= mask) {
m.x[i] -= mask;
nlst.PushBack(m);
}
}
k = nlst.Dim();
}
}
}
void Children(Vector<Morton> &nlst) const {
static const Integer cnt = (1UL << DIM);
if (nlst.Dim() != cnt) nlst.ReInit(cnt);
for (Integer i = 0; i < DIM; i++) nlst[0].x[i] = x[i];
nlst[0].depth = (uint8_t)(depth + 1);
Integer k = 1;
UINT_T mask = (((UINT_T)1) << (MAX_DEPTH - (depth + 1)));
for (Integer i = 0; i < DIM; i++) {
for (Integer j = 0; j < k; j++) {
nlst[j + k] = nlst[j];
nlst[j + k].x[i] += mask;
}
k = (k << 1);
}
}
bool operator<(const Morton &m) const {
UINT_T diff = 0;
for (Integer i = 0; i < DIM; i++) diff = diff | (x[i] ^ m.x[i]);
if (!diff) return depth < m.depth;
UINT_T mask = 1;
for (Integer i = 4 * sizeof(UINT_T); i > 0; i = (i >> 1)) {
UINT_T mask_ = (mask << i);
if (mask_ <= diff) mask = mask_;
}
for (Integer i = DIM - 1; i >= 0; i--) {
if (mask & (x[i] ^ m.x[i])) return x[i] < m.x[i];
}
return false; // TODO: check
}
bool operator>(const Morton &m) const { return m < (*this); }
bool operator!=(const Morton &m) const {
for (Integer i = 0; i < DIM; i++)
if (x[i] != m.x[i]) return true;
return (depth != m.depth);
}
bool operator==(const Morton &m) const { return !(*this != m); }
bool operator<=(const Morton &m) const { return !(*this > m); }
bool operator>=(const Morton &m) const { return !(*this < m); }
bool isAncestor(Morton const &descendant) const { return descendant.depth > depth && descendant.Ancestor(depth) == *this; }
Long operator-(const Morton<DIM> &I) const {
// Intersecting -1
// Touching 0
Long offset0 = 1 << (MAX_DEPTH - depth - 1);
Long offset1 = 1 << (MAX_DEPTH - I.depth - 1);
Long diff = 0;
for (Integer i = 0; i < DIM; i++) {
diff = std::max<Long>(diff, abs(((Long)x[i] + offset0) - ((Long)I.x[i] + offset1)));
}
if (diff < offset0 + offset1) return -1;
Integer max_depth = std::max(depth, I.depth);
diff = (diff - offset0 - offset1) >> (MAX_DEPTH - max_depth);
return diff;
}
friend std::ostream &operator<<(std::ostream &out, const Morton &mid) {
double a = 0;
double s = 1u << DIM;
for (Integer j = MAX_DEPTH; j >= 0; j--) {
for (Integer i = DIM - 1; i >= 0; i--) {
s = s * 0.5;
if (mid.x[i] & (((UINT_T)1) << j)) a += s;
}
}
out << "(";
for (Integer i = 0; i < DIM; i++) {
out << mid.x[i] * 1.0 / maxCoord << ",";
}
out << (int)mid.depth << "," << a << ")";
return out;
}
private:
static constexpr UINT_T maxCoord = ((UINT_T)1) << (MAX_DEPTH);
// StaticArray<UINT_T,DIM> x;
UINT_T x[DIM];
uint8_t depth;
};
}
#endif //_SCTL_MORTON_
| 25.933628 | 125 | 0.513394 | ejyoo921 |
a3396b65c3e10ce5516a854f199e6cf4da3f28f3 | 9,814 | cpp | C++ | Win32.Carberp.b/source - absource/pro/all source/Demo_cur/Source/DllLoader.cpp | 010001111/Vx-Suites | 6b4b90a60512cce48aa7b87aec5e5ac1c4bb9a79 | [
"MIT"
] | 2 | 2021-02-04T06:47:45.000Z | 2021-07-28T10:02:10.000Z | Win32.Carberp/all source/DllLoaderHook1/DllInject/DllLoader.cpp | 010001111/Vx-Suites | 6b4b90a60512cce48aa7b87aec5e5ac1c4bb9a79 | [
"MIT"
] | null | null | null | Win32.Carberp/all source/DllLoaderHook1/DllInject/DllLoader.cpp | 010001111/Vx-Suites | 6b4b90a60512cce48aa7b87aec5e5ac1c4bb9a79 | [
"MIT"
] | null | null | null | #include <windows.h>
#include "DllLoader.h"
#include "Memory.h"
typedef struct
{
PIMAGE_NT_HEADERS headers;
unsigned char *codeBase;
HMODULE *modules;
int numModules;
int initialized;
} MEMORYMODULE, *PMEMORYMODULE;
#define IMAGE_SIZEOF_BASE_RELOCATION 8
typedef BOOL ( WINAPI *DllEntryProc )( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved );
#define GET_HEADER_DICTIONARY( module, idx ) &(module)->headers->OptionalHeader.DataDirectory[idx]
void CopySections( const unsigned char *data, PIMAGE_NT_HEADERS old_headers, PMEMORYMODULE module )
{
int i, size;
unsigned char *codeBase = module->codeBase;
unsigned char *dest;
PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION( module->headers );
for ( i = 0; i < module->headers->FileHeader.NumberOfSections; i++, section++ )
{
if ( section->SizeOfRawData == 0 )
{
size = old_headers->OptionalHeader.SectionAlignment;
if ( size > 0 )
{
dest = (unsigned char *)VirtualAlloc( codeBase + section->VirtualAddress, size, MEM_COMMIT, PAGE_READWRITE );
section->Misc.PhysicalAddress = (DWORD)dest;
m_memset( dest, 0, size );
}
continue;
}
dest = (unsigned char *)VirtualAlloc( codeBase + section->VirtualAddress,
section->SizeOfRawData,
MEM_COMMIT,
PAGE_READWRITE );
m_memcpy( dest, data + section->PointerToRawData, section->SizeOfRawData );
section->Misc.PhysicalAddress = (DWORD)dest;
}
}
int ProtectionFlags[2][2][2] = {
{
{PAGE_NOACCESS, PAGE_WRITECOPY},
{PAGE_READONLY, PAGE_READWRITE},
},
{
{PAGE_EXECUTE, PAGE_EXECUTE_WRITECOPY},
{PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE},
},
};
void FinalizeSections( PMEMORYMODULE module )
{
int i;
PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION( module->headers );
for ( i = 0; i < module->headers->FileHeader.NumberOfSections; i++, section++ )
{
DWORD protect, oldProtect, size;
int executable = (section->Characteristics & IMAGE_SCN_MEM_EXECUTE) != 0;
int readable = (section->Characteristics & IMAGE_SCN_MEM_READ) != 0;
int writeable = (section->Characteristics & IMAGE_SCN_MEM_WRITE) != 0;
if ( section->Characteristics & IMAGE_SCN_MEM_DISCARDABLE )
{
VirtualFree((LPVOID)section->Misc.PhysicalAddress, section->SizeOfRawData, MEM_DECOMMIT);
continue;
}
protect = ProtectionFlags[executable][readable][writeable];
if ( section->Characteristics & IMAGE_SCN_MEM_NOT_CACHED )
{
protect |= PAGE_NOCACHE;
}
size = section->SizeOfRawData;
if ( size == 0 )
{
if ( section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA )
{
size = module->headers->OptionalHeader.SizeOfInitializedData;
}
else if ( section->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA )
{
size = module->headers->OptionalHeader.SizeOfUninitializedData;
}
}
if ( size > 0 )
{
if ( VirtualProtect((LPVOID)section->Misc.PhysicalAddress, section->SizeOfRawData, protect, &oldProtect) == 0 )
{
return;
}
}
}
}
void PerformBaseRelocation( PMEMORYMODULE module, DWORD delta )
{
DWORD i;
unsigned char *codeBase = module->codeBase;
PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY( module, IMAGE_DIRECTORY_ENTRY_BASERELOC );
if ( directory->Size > 0 )
{
PIMAGE_BASE_RELOCATION relocation = (PIMAGE_BASE_RELOCATION)( codeBase + directory->VirtualAddress );
for (; relocation->VirtualAddress > 0; )
{
unsigned char *dest = (unsigned char *)(codeBase + relocation->VirtualAddress);
unsigned short *relInfo = (unsigned short *)((unsigned char *)relocation + IMAGE_SIZEOF_BASE_RELOCATION);
for ( i = 0; i < ((relocation->SizeOfBlock-IMAGE_SIZEOF_BASE_RELOCATION) / 2 ); i++, relInfo++ )
{
DWORD *patchAddrHL;
int type, offset;
type = *relInfo >> 12;
offset = *relInfo & 0xfff;
switch ( type )
{
case IMAGE_REL_BASED_ABSOLUTE:
break;
case IMAGE_REL_BASED_HIGHLOW:
patchAddrHL = (DWORD *)(dest + offset);
*patchAddrHL += delta;
break;
default:
break;
}
}
relocation = (PIMAGE_BASE_RELOCATION)(((DWORD)relocation) + relocation->SizeOfBlock);
}
}
}
int BuildImportTable(PMEMORYMODULE module)
{
int result=1;
unsigned char *codeBase = module->codeBase;
PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_IMPORT);
if ( directory->Size > 0 )
{
PIMAGE_IMPORT_DESCRIPTOR importDesc = (PIMAGE_IMPORT_DESCRIPTOR)(codeBase + directory->VirtualAddress);
for ( ; !IsBadReadPtr(importDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR)) && importDesc->Name; importDesc++ )
{
DWORD *thunkRef, *funcRef;
HMODULE handle = (HMODULE)LoadLibrary( (LPCSTR)(codeBase + importDesc->Name) );
if (handle == INVALID_HANDLE_VALUE)
{
result = 0;
break;
}
HMODULE *p = (HMODULE*)MemRealloc( module->modules, (module->numModules+1)*(sizeof(HMODULE)) );
module->modules = p;
if (module->modules == NULL)
{
result = 0;
break;
}
module->modules[module->numModules++] = handle;
if (importDesc->OriginalFirstThunk)
{
thunkRef = (DWORD *)(codeBase + importDesc->OriginalFirstThunk);
funcRef = (DWORD *)(codeBase + importDesc->FirstThunk);
} else {
thunkRef = (DWORD *)(codeBase + importDesc->FirstThunk);
funcRef = (DWORD *)(codeBase + importDesc->FirstThunk);
}
for (; *thunkRef; thunkRef++, funcRef++)
{
if IMAGE_SNAP_BY_ORDINAL(*thunkRef)
{
*funcRef = (DWORD)GetProcAddress( handle, (LPCSTR)IMAGE_ORDINAL(*thunkRef) );
}
else
{
PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME)(codeBase + *thunkRef);
*funcRef = (DWORD)GetProcAddress( handle, (LPCSTR)&thunkData->Name );
}
if (*funcRef == 0)
{
result = 0;
break;
}
}
if (!result)
break;
}
}
return result;
}
void MemoryFreeLibrary(HMEMORYMODULE mod)
{
int i;
PMEMORYMODULE module = (PMEMORYMODULE)mod;
if (module != NULL)
{
if (module->initialized != 0)
{
DllEntryProc DllEntry = (DllEntryProc)(module->codeBase + module->headers->OptionalHeader.AddressOfEntryPoint);
(*DllEntry)((HINSTANCE)module->codeBase, DLL_PROCESS_DETACH, 0);
module->initialized = 0;
}
if (module->modules != NULL)
{
for (i=0; i<module->numModules; i++)
if (module->modules[i] != INVALID_HANDLE_VALUE)
FreeLibrary(module->modules[i]);
MemFree(module->modules);
}
if (module->codeBase != NULL)
VirtualFree(module->codeBase, 0, MEM_RELEASE);
MemFree( module);
}
}
#pragma optimize("", off)
HMEMORYMODULE MemoryLoadLibrary(const void *data)
{
PMEMORYMODULE result;
PIMAGE_DOS_HEADER dos_header;
PIMAGE_NT_HEADERS old_header;
unsigned char *code, *headers;
DWORD locationDelta;
DllEntryProc DllEntry;
BOOL successfull;
dos_header = (PIMAGE_DOS_HEADER)data;
if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
{
return NULL;
}
old_header = (PIMAGE_NT_HEADERS)&((const unsigned char *)(data))[dos_header->e_lfanew];
if (old_header->Signature != IMAGE_NT_SIGNATURE)
{
return NULL;
}
code = (unsigned char *)VirtualAlloc((LPVOID)(old_header->OptionalHeader.ImageBase),
old_header->OptionalHeader.SizeOfImage,
MEM_RESERVE,
PAGE_READWRITE);
if (code == NULL)
code = (unsigned char *)VirtualAlloc(NULL,
old_header->OptionalHeader.SizeOfImage,
MEM_RESERVE,
PAGE_READWRITE);
if (code == NULL)
{
return NULL;
}
result = (PMEMORYMODULE)MemAlloc( sizeof(MEMORYMODULE) );
result->codeBase = code;
result->numModules = 0;
result->modules = NULL;
result->initialized = 0;
VirtualAlloc(code,
old_header->OptionalHeader.SizeOfImage,
MEM_COMMIT,
PAGE_READWRITE);
headers = (unsigned char *)VirtualAlloc(code,
old_header->OptionalHeader.SizeOfHeaders,
MEM_COMMIT,
PAGE_READWRITE);
m_memcpy(headers, dos_header, dos_header->e_lfanew + old_header->OptionalHeader.SizeOfHeaders);
result->headers = (PIMAGE_NT_HEADERS)&((const unsigned char *)(headers))[dos_header->e_lfanew];
result->headers->OptionalHeader.ImageBase = (DWORD)code;
CopySections((const unsigned char*)data, old_header, result);
locationDelta = (DWORD)(code - old_header->OptionalHeader.ImageBase);
if (locationDelta != 0)
PerformBaseRelocation(result, locationDelta);
if (!BuildImportTable(result))
goto error;
FinalizeSections(result);
if (result->headers->OptionalHeader.AddressOfEntryPoint != 0)
{
DllEntry = (DllEntryProc)(code + result->headers->OptionalHeader.AddressOfEntryPoint);
if (DllEntry == 0)
{
goto error;
}
successfull = (*DllEntry)((HINSTANCE)code, DLL_PROCESS_ATTACH, 0);
if (!successfull)
{
goto error;
}
result->initialized = 1;
}
return (HMEMORYMODULE)result;
error:
MemoryFreeLibrary(result);
return NULL;
}
FARPROC MemoryGetProcAddress(HMEMORYMODULE module, const char *name)
{
unsigned char *codeBase = ((PMEMORYMODULE)module)->codeBase;
int idx=-1;
DWORD i, *nameRef;
WORD *ordinal;
PIMAGE_EXPORT_DIRECTORY exports;
PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY((PMEMORYMODULE)module, IMAGE_DIRECTORY_ENTRY_EXPORT);
if (directory->Size == 0)
return NULL;
exports = (PIMAGE_EXPORT_DIRECTORY)(codeBase + directory->VirtualAddress);
if (exports->NumberOfNames == 0 || exports->NumberOfFunctions == 0)
return NULL;
nameRef = (DWORD *)(codeBase + exports->AddressOfNames);
ordinal = (WORD *)(codeBase + exports->AddressOfNameOrdinals);
for (i=0; i<exports->NumberOfNames; i++, nameRef++, ordinal++)
if ( lstrcmpi(name, (const char *)(codeBase + *nameRef)) == 0 )
{
idx = *ordinal;
break;
}
if (idx == -1)
return NULL;
if ((DWORD)idx > exports->NumberOfFunctions)
return NULL;
return (FARPROC)(codeBase + *(DWORD *)(codeBase + exports->AddressOfFunctions + (idx*4)));
}
| 25.164103 | 114 | 0.695028 | 010001111 |
a339fc4732c9173612ee2dc0011a9e451d9caf35 | 3,857 | cpp | C++ | test/test_ref_results/formatter_test.cpp | mdegirolami/stay | b47676e5340c2bbd93fe97d52a12a895a3492b22 | [
"BSD-3-Clause"
] | 2 | 2021-08-13T01:00:49.000Z | 2021-09-07T17:31:14.000Z | test/test_ref_results/formatter_test.cpp | mdegirolami/sing | 7f674d3a1d5787b3f4016dc28c14e997149fc9f6 | [
"BSD-3-Clause"
] | null | null | null | test/test_ref_results/formatter_test.cpp | mdegirolami/sing | 7f674d3a1d5787b3f4016dc28c14e997149fc9f6 | [
"BSD-3-Clause"
] | null | null | null | #include "formatter_test.h"
static const int32_t veryveryveryveryveryverylong1 = 100;
static const int32_t veryveryveryveryveryverylong2 = 100;
static const int32_t veryveryveryveryveryverylong3 = 100;
static const int32_t veryveryveryveryveryverylong4 = 100;
// before class
class tc final { // on class
public:
tc();
// on ff1
void ff1();
int32_t pub_; // on pub
private:
// on ff0
void ff0();
int32_t priv1_;
int32_t priv2_; // on priv2
};
class xxx { // on if
public:
virtual ~xxx() {}
virtual void *get__id() const = 0;
virtual void dostuff() const = 0; // on fun
virtual void dootherstuff() const = 0;
};
static void manyargs(std::complex<float> veryveryveryveryveryverylongarg1, std::complex<float> veryveryveryveryveryverylongarg2,
std::complex<float> veryveryveryveryveryverylongarg3, std::complex<float> veryveryveryveryveryverylongarg4);
static void fn1(int32_t a, int32_t b, int32_t *c);
static void fn2(int32_t a, int32_t b, int32_t *c);
// attached to next
static const sing::array<sing::array<int32_t, 3>, 6> table = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, // hand formatted !!
{1, 2, 3}, {1, 2, 3}, {1, 2, 3}
};
// attached to table4
static const sing::array<sing::array<int32_t, 3>, 6> table4 = {
{1, 2, 3}, {1, 2, 3}, {1, 2, 3},
{1, 2, 3}, {1, 2, 3}, {1, 2, 3}
};
static const sing::array<sing::array<sing::array<std::string, 3>, 3>, 3> table2 = {{{"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}}, {{"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}}, {{"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}, {"akjhdfk", "askjfhsad", "hgfksahgjh"}}};
static const sing::array<sing::array<int32_t, 3>, 6> table3 = {
{1, 2, 3}, {1, 2, 3}, {1, 2, 3},
{1, 2, 3}, {1, 2, 3}, {1, 2, 3}
};
static const std::string stest = "kjdhfkhfdkhskdfhkshghkhl" // rem1
"hfdslkjflkjasdlkfjlksdjflkj";
static void manyargs(std::complex<float> veryveryveryveryveryverylongarg1, std::complex<float> veryveryveryveryveryverylongarg2,
std::complex<float> veryveryveryveryveryverylongarg3, std::complex<float> veryveryveryveryveryverylongarg4)
{
}
static void fn1(int32_t a, int32_t b, int32_t *c) // rem1
{
// of statement
*c = a + b; // post
*c = 100 + 123 * sing::pow2(12) + 12345 / (veryveryveryveryveryverylong1 / veryveryveryveryveryverylong2) - // rem
(veryveryveryveryveryverylong3 & veryveryveryveryveryverylong4);
manyargs(12.6526546f + std::complex<float>(0.0f, 12.925985478f), 12.6526546f + std::complex<float>(0.0f, 12.925985478f), // xyz
12.6526546f + std::complex<float>(0.0f, 12.925985478f), 12.6526546f + std::complex<float>(0.0f, 12.925985478f));
manyargs(12.6526546f + std::complex<float>(0.0f, 12.925985478f), 12.6526546f + std::complex<float>(0.0f, 12.925985478f), //xyz
12.6526546f + std::complex<float>(0.0f, 12.925985478f), 12.6526546f + std::complex<float>(0.0f, 12.925985478f));
// note: the next line has blanks but must be handled as empty
for(int32_t it = 0; it < 10; ++it) { // onfor
++(*c);
break; // inner
}
}
static void fn2(int32_t a, int32_t b, int32_t *c) // rem0
{
}
tc::tc()
{
priv1_ = 0;
priv2_ = 0;
pub_ = 0;
}
void tc::ff0()
{
priv1_ = 0;
}
void tc::ff1()
{
switch (priv2_) { // on switch
case 0:
++pub_; // on statement 0
break;
case 1:
case 2:
{ // on case2
ff0();
}
break;
}
}
| 33.25 | 449 | 0.600985 | mdegirolami |
a33a1f5edb4a1df7c78e3166bf2c5f0447f6fd4c | 24,173 | cpp | C++ | src/parser.cpp | AllanCameron/PDFR | 15abe85d853295258a30f63a8aaa09f40c772e6f | [
"MIT"
] | 20 | 2019-02-14T12:22:17.000Z | 2022-02-17T02:52:01.000Z | src/parser.cpp | AllanCameron/PDFR | 15abe85d853295258a30f63a8aaa09f40c772e6f | [
"MIT"
] | 2 | 2018-12-04T21:36:01.000Z | 2019-07-25T21:17:02.000Z | src/parser.cpp | AllanCameron/PDFR | 15abe85d853295258a30f63a8aaa09f40c772e6f | [
"MIT"
] | 1 | 2020-03-19T20:16:59.000Z | 2020-03-19T20:16:59.000Z | //---------------------------------------------------------------------------//
// //
// PDFR Parser implementation file //
// //
// Copyright (C) 2018 - 2019 by Allan Cameron //
// //
// Licensed under the MIT license - see https://mit-license.org //
// or the LICENSE file in the project root directory //
// //
//---------------------------------------------------------------------------//
#include "utilities.h"
#include "font.h"
#include "text_element.h"
#include "page.h"
#include "parser.h"
#include<iostream>
//---------------------------------------------------------------------------//
using namespace std;
using namespace Token;
//---------------------------------------------------------------------------//
// This typedef declares fptr as a function pointer
typedef void (Parser::*FunctionPointer)();
//---------------------------------------------------------------------------//
// This statically-declared map allows functions to be called based on strings
// passed to it from the tokenizer
std::unordered_map<std::string, FunctionPointer> Parser::function_map_ =
{
{"Q", &Parser::Q_ }, {"q", &Parser::q_ }, {"BT", &Parser::BT_ },
{"ET", &Parser::ET_ }, {"cm", &Parser::cm_}, {"Tm", &Parser::Tm_ },
{"Tf", &Parser::Tf_ }, {"Td", &Parser::Td_}, {"Th", &Parser::TH_ },
{"Tw", &Parser::TW_ }, {"Tc", &Parser::TC_}, {"TL", &Parser::TL_ },
{"T*", &Parser::T__ }, {"TD", &Parser::TD_}, {"'", &Parser::Ap_ },
{"TJ", &Parser::TJ_ }, {"Tj", &Parser::TJ_}, {"re", &Parser::re_ },
{"l", &Parser::l_ }, {"m", &Parser::m_ }, {"w", &Parser::w_ },
{"f", &Parser::f_ }, {"F", &Parser::f_ }, {"f*", &Parser::f_ },
{"s", &Parser::s_ }, {"S", &Parser::S_ }, {"CS", &Parser::CS_ },
{"cs", &Parser::cs_ }, {"SC", &Parser::SC_}, {"sc", &Parser::sc_ },
{"h", &Parser::h_ }, {"rg", &Parser::rg_}, {"RG", &Parser::RG_ },
{"G", &Parser::G_ }, {"g", &Parser::g_ }, {"scn", &Parser::scn_},
{"SCN", &Parser::SCN_}, {"K", &Parser::K_ }, {"k", &Parser::k_ },
{"c", &Parser::c_ }, {"v", &Parser::v_ }, {"y", &Parser::y_ },
{"B", &Parser::B_ }, {"B*", &Parser::B_ }, {"b", &Parser::b_ },
{"b*", &Parser::b_ }, {"n", &Parser::n_ }
};
//---------------------------------------------------------------------------//
// Creates a 100 point Bezier interpolation for start point p1, end point p4
// and control points p2 and p3. Used only in implementing Bezier operators.
// This has to be used once for the x co-ordinates and once for the y
// co-ordinates.
std::vector<float> bezier(float p1, float p2, float p3, float p4) {
std::vector<float> result(100);
for(int i = 0; i < 100; i++)
{
float t1 = (i + 1) * 0.01;
float t2 = 1 - t1;
result[i] = 1 * t2 * t2 * t2 * p1 +
3 * t1 * t2 * t2 * p2 +
3 * t1 * t1 * t2 * p3 +
1 * t1 * t1 * t1 * p4;
}
return result;
}
//---------------------------------------------------------------------------//
// The Parser constructor has to initialize many variables that allow
// it to track state once instructions are passed to it. After these are set,
// it does no work unless passed instructions by the tokenizer
Parser::Parser(shared_ptr<Page> page_ptr) :
page_(page_ptr),
text_box_(unique_ptr<TextBox>(new TextBox(Box(*(page_->GetMinbox()))))),
graphics_state_({GraphicsState(page_ptr)}), // Graphics state stack
kerning_(0)
{
graphics_.emplace_back(std::make_shared<Path>());
}
/*---------------------------------------------------------------------------*/
// re operator - defines a rectangle
void Parser::re_()
{
graphics_.back()->NewSubpath();
float left = std::stof(operands_[0]);
float width = std::stof(operands_[2]);
float right = left + width;
float bottom = std::stof(operands_[1]);
float height = std::stof(operands_[3]);
float top = bottom + height;
auto lb = graphics_state_.back().CTM.transformXY(left, bottom);
auto rb = graphics_state_.back().CTM.transformXY(right, bottom);
auto lt = graphics_state_.back().CTM.transformXY(left, top);
auto rt = graphics_state_.back().CTM.transformXY(right, top);
graphics_.back()->AppendX({lb[0], lt[0], rt[0], rb[0]});
graphics_.back()->AppendY({lb[1], lt[1], rt[1], rb[1]});
graphics_.back()->CloseSubpath();
}
/*---------------------------------------------------------------------------*/
// m operator moves the current graphics co-ordinate
void Parser::m_() {
graphics_.back()->NewSubpath();
auto xy = graphics_state_.back().CTM.transformXY(std::stof(operands_[0]),
std::stof(operands_[1]));
graphics_.back()->AppendX({xy[0]});
graphics_.back()->AppendY({xy[1]});
}
/*---------------------------------------------------------------------------*/
// CS operator sets current color space for strokes
void Parser::CS_() {
graphics_state_.back().colour_space_stroke = {operands_[0]};
}
/*---------------------------------------------------------------------------*/
// cs operator sets current color space for fills
void Parser::cs_() {
graphics_state_.back().colour_space_fill = {operands_[0]};
}
/*---------------------------------------------------------------------------*/
// SC operator sets stroke colour
void Parser::SC_() {
size_t n = operands_.size();
if(n == 1) G_();
if(n == 3) RG_();
if(n == 4) K_();
}
/*---------------------------------------------------------------------------*/
// SCN operator sets stroke colour via CMYK
void Parser::K_() {
graphics_state_.back().colour_space_stroke = {"/DeviceCMYK"};
// CMYK approximation
float black = 1 - std::stof(operands_[3]);
graphics_state_.back().colour = {
(1 - std::stof(operands_[0])) * black,
(1 - std::stof(operands_[1])) * black,
(1 - std::stof(operands_[2])) * black
};
}
/*---------------------------------------------------------------------------*/
// SCN operator sets stroke colour or pattern
void Parser::SCN_() {
SC_();
}
/*---------------------------------------------------------------------------*/
// SCN operator sets fill colour or pattern
void Parser::scn_() {
sc_();
}
/*---------------------------------------------------------------------------*/
// RG operator sets stroke colour
void Parser::RG_() {
graphics_state_.back().colour_space_stroke = {"/DeviceRGB"};
graphics_state_.back().colour = { std::stof(operands_[0]),
std::stof(operands_[1]),
std::stof(operands_[2])
};
}
/*---------------------------------------------------------------------------*/
// rg operator sets fill colour
void Parser::rg_() {
graphics_state_.back().colour_space_fill = {"/DeviceRGB"};
graphics_state_.back().fill = { std::stof(operands_[0]),
std::stof(operands_[1]),
std::stof(operands_[2])
};
}
/*---------------------------------------------------------------------------*/
// RG operator sets stroke colour
void Parser::G_() {
graphics_state_.back().colour_space_stroke = {"/DeviceGray"};
graphics_state_.back().colour = { std::stof(operands_[0]),
std::stof(operands_[0]),
std::stof(operands_[0])
};
}
/*---------------------------------------------------------------------------*/
// g operator sets fill colour
void Parser::g_() {
graphics_state_.back().colour_space_fill = {"/DeviceGray"};
graphics_state_.back().fill = { std::stof(operands_[0]),
std::stof(operands_[0]),
std::stof(operands_[0])
};
}
/*---------------------------------------------------------------------------*/
// sc operator sets fill colour
void Parser::sc_() {
size_t n = operands_.size();
if(n == 1) g_();
if(n == 3) rg_();
if(n == 4) k_();
}
/*---------------------------------------------------------------------------*/
// k operator sets fill colour
void::Parser::k_() {
graphics_state_.back().colour_space_fill = {"/DeviceCMYK"};
float black = 1 - std::stof(operands_[3]);
graphics_state_.back().fill = {
(1 - std::stof(operands_[0])) * black,
(1 - std::stof(operands_[1])) * black,
(1 - std::stof(operands_[2])) * black
};
}
void Parser::B_() {
graphics_.back()->SetFilled(true);
graphics_.back()->SetFillColour(graphics_state_.back().fill);
S_();
}
void Parser::b_() {
h_();
B_();
}
/*---------------------------------------------------------------------------*/
// l operator constructs a path segment
void Parser::l_() {
auto xy = graphics_state_.back().CTM.transformXY(std::stof(operands_[0]),
std::stof(operands_[1]));
graphics_.back()->SetLineWidth(graphics_state_.back().line_width *
graphics_state_.back().CTM[0]);
graphics_.back()->AppendX({xy[0]});
graphics_.back()->AppendY({xy[1]});
}
/*---------------------------------------------------------------------------*/
// c operator constructs a bezier curve with two control points
void Parser::c_() {
std::array<float, 2> xy0 = {graphics_.back()->GetX().back(),
graphics_.back()->GetY().back()};
auto xy1 = graphics_state_.back().CTM.transformXY(std::stof(operands_[0]),
std::stof(operands_[1]));
auto xy2 = graphics_state_.back().CTM.transformXY(std::stof(operands_[2]),
std::stof(operands_[3]));
auto xy3 = graphics_state_.back().CTM.transformXY(std::stof(operands_[4]),
std::stof(operands_[5]));
auto new_x = bezier(xy0[0], xy1[0], xy2[0], xy3[0]);
auto new_y = bezier(xy0[1], xy1[1], xy2[1], xy3[1]);
graphics_.back()->AppendX(new_x);
graphics_.back()->AppendY(new_y);
}
/*---------------------------------------------------------------------------*/
// v operator constructs a bezier curve with single control point (first point
// also acting as control point)
void Parser::v_() {
std::array<float, 2> xy0 = {graphics_.back()->GetX().back(),
graphics_.back()->GetY().back()};
auto xy1 = xy0;
auto xy2 = graphics_state_.back().CTM.transformXY(std::stof(operands_[0]),
std::stof(operands_[1]));
auto xy3 = graphics_state_.back().CTM.transformXY(std::stof(operands_[2]),
std::stof(operands_[3]));
auto new_x = bezier(xy0[0], xy1[0], xy2[0], xy3[0]);
auto new_y = bezier(xy0[1], xy1[1], xy2[1], xy3[1]);
graphics_.back()->AppendX(new_x);
graphics_.back()->AppendY(new_y);
}
/*---------------------------------------------------------------------------*/
// y operator constructs a bezier curve with single control point (last point
// also acting as control point)
void Parser::y_() {
std::array<float, 2> xy0 = {graphics_.back()->GetX().back(),
graphics_.back()->GetY().back()};
auto xy1 = graphics_state_.back().CTM.transformXY(std::stof(operands_[0]),
std::stof(operands_[1]));
auto xy2 = graphics_state_.back().CTM.transformXY(std::stof(operands_[2]),
std::stof(operands_[3]));
auto xy3 = xy2;
auto new_x = bezier(xy0[0], xy1[0], xy2[0], xy3[0]);
auto new_y = bezier(xy0[1], xy1[1], xy2[1], xy3[1]);
graphics_.back()->AppendX(new_x);
graphics_.back()->AppendY(new_y);
}
/*---------------------------------------------------------------------------*/
// h operator closes path
void Parser::h_() {
graphics_.back()->CloseSubpath();
}
/*---------------------------------------------------------------------------*/
// w operator sets line width
void Parser::w_() {
graphics_state_.back().line_width = std::stof(operands_[0]);
}
/*---------------------------------------------------------------------------*/
// f operator fills the previous path
void Parser::f_() {
graphics_.back()->SetFilled(true);
graphics_.back()->SetFillColour(graphics_state_.back().fill);
graphics_.push_back(std::make_shared<Path>());
}
void Parser::n_() {
graphics_.push_back(std::make_shared<Path>());
}
/*---------------------------------------------------------------------------*/
// S operator strokes the path
void Parser::S_() {
graphics_.back()->SetStroke(true);
graphics_.back()->SetColour(graphics_state_.back().colour);
graphics_.back()->SetLineWidth(graphics_state_.back().line_width *
graphics_state_.back().CTM[0]);
graphics_.push_back(std::make_shared<Path>());
}
/*---------------------------------------------------------------------------*/
// s operator closes and strokes the path
void Parser::s_() {
h_();
S_();
}
/*---------------------------------------------------------------------------*/
// q operator - pushes a copy of the current graphics state to the stack
void Parser::q_()
{
graphics_state_.emplace_back(graphics_state_.back());
}
/*---------------------------------------------------------------------------*/
// Q operator - pop the graphics state stack
void Parser::Q_()
{
// Empty graphics state is undefined but graphics_state_[0] is identity
if (graphics_state_.size() > 1) graphics_state_.pop_back();
}
/*---------------------------------------------------------------------------*/
// Td operator - applies tranlational changes only to text matrix (Tm)
void Parser::Td_()
{
Matrix Tds = Matrix(); //---------------------------------
Tds[6] = ParseFloats(operands_[0])[0]; // create 3 x 3 translation matrix
Tds[7] = ParseFloats(operands_[1])[0]; //---------------------------------
// Multiply translation and text matrices
graphics_state_.back().td_state *= Tds;
// Td resets kerning
kerning_ = 0;
}
/*---------------------------------------------------------------------------*/
// TD operator - same as Td except it also sets the 'leading' (Tl) operator
void Parser::TD_()
{
Td_();
// Set text leading to new value
graphics_state_.back().text_state.tl = -ParseFloats(operands_[1])[0];
}
/*---------------------------------------------------------------------------*/
// BT operator - signifies start of text
void Parser::BT_()
{
// Reset text matrix to identity matrix
graphics_state_.back().tm_state = Matrix();
graphics_state_.back().td_state = Matrix();
// Reset word spacing and character spacing
graphics_state_.back().text_state.tw = graphics_state_.back().text_state.tc = 0;
graphics_state_.back().text_state.th = 100; // reset horizontal spacing
}
/*---------------------------------------------------------------------------*/
// ET operator - signifies end of text
void Parser::ET_()
{
BT_();
graphics_.push_back(std::make_shared<Path>());
}
/*---------------------------------------------------------------------------*/
// Tf operator - specifies font and pointsize
void Parser::Tf_()
{
// Should be 2 operators: 1 is not defined
if (operands_.size() > 1)
{
graphics_state_.back().text_state.tf = operands_[0];
graphics_state_.back().text_state.current_font =
page_->GetFont(graphics_state_.back().text_state.tf);
graphics_state_.back().text_state.tfs = ParseFloats(operands_[1])[0];
}
}
/*---------------------------------------------------------------------------*/
// TH - sets horizontal spacing
void Parser::TH_()
{
// Reads operand as new horizontal spacing value
graphics_state_.back().text_state.th = stof(operands_.at(0));
}
/*---------------------------------------------------------------------------*/
// Tc operator - sets character spacing
void Parser::TC_()
{
// Reads operand as new character spacing value
graphics_state_.back().text_state.tc = stof(operands_.at(0));
}
/*---------------------------------------------------------------------------*/
// TW operator - sets word spacing
void Parser::TW_()
{
// Reads operand as new word spacing value
graphics_state_.back().text_state.tw = stof(operands_.at(0));
}
/*---------------------------------------------------------------------------*/
// TL operator - sets leading (size of vertical jump to new line)
void Parser::TL_()
{
// Reads operand as new text leading value
graphics_state_.back().text_state.tl = stof(operands_.at(0));
}
/*---------------------------------------------------------------------------*/
// T* operator - moves to new line
void Parser::T__()
{
// Decrease y value of text matrix by amount specified by text leading param
graphics_state_.back().td_state[7] = graphics_state_.back().td_state[7] -
graphics_state_.back().text_state.tl;
// This also resets the kerning
kerning_ = 0;
}
/*---------------------------------------------------------------------------*/
// Tm operator - sets the text matrix (convolve text relative to graphics state)
void Parser::Tm_()
{
// Reads operands as a 3x3 matrix
graphics_state_.back().tm_state = Matrix(operands_);
// Reset the Td modifier matrix to identity matrix
graphics_state_.back().td_state = Matrix();
// Reset the kerning
kerning_ = 0;
}
/*---------------------------------------------------------------------------*/
// cm operator - applies transformation matrix to graphics state
void Parser::cm_()
{
// Read the operands as a matrix, multiply by top of graphics state stack
// and replace the top of the stack with the result
graphics_state_.back().CTM *= Matrix(operands_);
}
/*---------------------------------------------------------------------------*/
// The "'" operator is a minor variation of the TJ function. Ap is short for
// apostrophe
void Parser::Ap_()
{
// The "'" operator is the same as Tj except it moves to the next line first
graphics_state_.back().td_state[7] -= graphics_state_.back().text_state.tl;
kerning_ = 0;
TJ_();
}
/*---------------------------------------------------------------------------*/
// TJ operator - prints glyphs to the output. This is the crux of the reading
// process, because it is where all the elements come together to get the
// values needed for each character. Since there are actually 3 operators
// that print text in largely overlapping ways, they are all handled here,
// but that requires an extra parameter to be passed in to specify which
// operation we are dealing with.
//
// This function is heavily commented as a little mistake here can screw
// everything up. YOU HAVE BEEN WARNED!
void Parser::TJ_()
{
// Creates text space that is the product of Tm, td and cm matrices
// and sets the starting x value and scale of our string
Matrix text_space = graphics_state_.back().CTM *
graphics_state_.back().tm_state *
graphics_state_.back().td_state;
float initial_x = text_space[6],
scale = graphics_state_.back().text_state.tfs * text_space[0];
// We now iterate through our operands and their associated types
for (size_t index = 0; index < operand_types_.size(); index++)
{
// Adjust the text space according to kerning and scale
text_space[6] = kerning_ * scale / 1000 + initial_x;
// Depending on the operand type, we process the operand as appropriate
switch (operand_types_[index])
{
case NUMBER : kerning_ -= stof(operands_[index]); continue;
case HEXSTRING : raw_ = ConvertHexToRawChar(operands_[index]); break;
case STRING : raw_ = ConvertStringToRawChar(operands_[index]); break;
default : continue;
}
// Now we can process the string given the current user space and font
if (!operands_[index].empty()) ProcessRawChar_(scale, text_space, initial_x);
}
}
/*---------------------------------------------------------------------------*/
// This method is a helper of / extension of Tj which takes the RawChars
// generated, the userspace and initial userspace to calculate the
// glyphs, sizes and positions intended by the string in the page program
void Parser::ProcessRawChar_(float& scale, Matrix& text_space,
float& initial_x)
{
// Look up the RawChars in the font to get their Unicode values and widths
vector<pair<Unicode, float>>&& glyph_pairs =
graphics_state_.back().text_state.current_font->MapRawChar(raw_);
// Now, for each character...
for (auto& glyph_pair : glyph_pairs)
{
float glyph_width, left, right, bottom, width;
// If the first character is not a space, record its position as is and
// adjust for character spacing
if (glyph_pair.first != 0x0020)
{
left = text_space[6];
bottom = text_space[7];
glyph_width = glyph_pair.second + graphics_state_.back().text_state.tc * 1000 /
graphics_state_.back().text_state.tfs;
}
else // if this is a space, just adjust word & char spacing
{
glyph_width = glyph_pair.second +
1000 * (graphics_state_.back().text_state.tc +
graphics_state_.back().text_state.tw) /
graphics_state_.back().text_state.tfs;
}
// Adjust the kerning in text space by character width
kerning_ += glyph_width;
// Move user space right by the (converted to user space) width of the char
text_space[6] = kerning_ * scale / 1000 + initial_x;
if (glyph_pair.first != 0x0020)
{
// record width of char taking Th (horizontal scaling) into account
width = scale * (glyph_width / 1000) *
(graphics_state_.back().text_state.th / 100);
right = left + width;
auto te = make_shared<TextElement>
(left, right, bottom + scale,
bottom, scale,
graphics_state_.back().text_state.current_font,
vector<Unicode>{glyph_pair.first});
graphics_.push_back(std::make_shared<Text>(te));
graphics_.back()->SetColour(graphics_state_.back().colour);
graphics_.back()->SetFillColour(graphics_state_.back().fill);
text_box_->push_back(te);
}
}
raw_.clear();
}
/*---------------------------------------------------------------------------*/
// The reader takes the instructions generated by the tokenizer and enacts them.
// It does this by reading each token and its type. If it comes across an
// IDENTIFIER it calls the operator function for that symbol. Otherwise,
// it assumes it is reading an operand and places it on the operand stack.
// When an operator function is called, it takes the operands on the stack
// as arguments.
void Parser::Reader(const string& token, TokenState state)
{
// if it's an identifier, call the operator
if (state == IDENTIFIER)
{
// Pass any stored operands on the stack
auto finder = function_map_.find(token);
if (finder != function_map_.end()) (this->*function_map_[token])();
// Clear the stack since an operator has been called
operand_types_.clear();
operands_.clear();
}
else
{
// Push operands and their types on stack, awaiting operator
operand_types_.push_back(state);
operands_.push_back(token);
}
}
/*---------------------------------------------------------------------------*/
// Can't inline this without including page.h in header
shared_ptr<string> Parser::GetXObject(const string& inloop) const
{
return page_->GetXObject(inloop);
};
| 33.855742 | 85 | 0.508998 | AllanCameron |
a33cb9f8f99c7cee705acb4f0c0426f7bde75698 | 4,154 | cc | C++ | chrome/browser/chromeos/policy/user_cloud_external_data_manager_browsertest.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 4 | 2017-04-05T01:51:34.000Z | 2018-02-15T03:11:54.000Z | chrome/browser/chromeos/policy/user_cloud_external_data_manager_browsertest.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 1 | 2021-12-13T19:44:12.000Z | 2021-12-13T19:44:12.000Z | chrome/browser/chromeos/policy/user_cloud_external_data_manager_browsertest.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 4 | 2017-04-05T01:52:03.000Z | 2022-02-13T17:58:45.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include "base/bind.h"
#include "base/callback.h"
#include "base/file_util.h"
#include "base/files/file_path.h"
#include "base/memory/scoped_ptr.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/values.h"
#include "chrome/browser/chromeos/policy/cloud_external_data_manager_base.h"
#include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h"
#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
#include "chrome/browser/policy/cloud/cloud_policy_core.h"
#include "chrome/browser/policy/external_data_fetcher.h"
#include "chrome/browser/policy/policy_map.h"
#include "chrome/browser/policy/policy_service.h"
#include "chrome/browser/policy/profile_policy_connector.h"
#include "chrome/browser/policy/profile_policy_connector_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "content/public/test/test_utils.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "policy/policy_constants.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
namespace policy {
namespace {
const char kExternalDataPath[] = "policy/blank.html";
} // namespace
typedef InProcessBrowserTest UserCloudExternalDataManagerTest;
IN_PROC_BROWSER_TEST_F(UserCloudExternalDataManagerTest, FetchExternalData) {
CloudExternalDataManagerBase::SetMaxExternalDataSizeForTesting(1000);
ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
const GURL url =
embedded_test_server()->GetURL(std::string("/") + kExternalDataPath);
base::FilePath test_dir;
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
std::string external_data;
ASSERT_TRUE(base::ReadFileToString(test_dir.AppendASCII(kExternalDataPath),
&external_data));
ASSERT_FALSE(external_data.empty());
scoped_ptr<base::DictionaryValue> metadata =
test::ConstructExternalDataReference(url.spec(), external_data);
#if defined(OS_CHROMEOS)
UserCloudPolicyManagerChromeOS* policy_manager =
UserCloudPolicyManagerFactoryChromeOS::GetForProfile(
browser()->profile());
#else
UserCloudPolicyManager* policy_manager =
UserCloudPolicyManagerFactory::GetForBrowserContext(browser()->profile());
#endif
ASSERT_TRUE(policy_manager);
// TODO(bartfab): The test injects an ExternalDataFetcher for an arbitrary
// policy. This is only done because there are no policies that reference
// external data yet. Once the first such policy is added, switch the test to
// that policy and stop injecting a manually instantiated ExternalDataFetcher.
test::SetExternalDataReference(policy_manager->core(),
key::kHomepageLocation,
make_scoped_ptr(metadata->DeepCopy()));
content::RunAllPendingInMessageLoop();
ProfilePolicyConnector* policy_connector =
ProfilePolicyConnectorFactory::GetForProfile(browser()->profile());
ASSERT_TRUE(policy_connector);
const PolicyMap& policies = policy_connector->policy_service()->GetPolicies(
PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
const PolicyMap::Entry* policy_entry = policies.Get(key::kHomepageLocation);
ASSERT_TRUE(policy_entry);
EXPECT_TRUE(base::Value::Equals(metadata.get(), policy_entry->value));
ASSERT_TRUE(policy_entry->external_data_fetcher);
base::RunLoop run_loop;
scoped_ptr<std::string> fetched_external_data;
policy_entry->external_data_fetcher->Fetch(base::Bind(
&test::ExternalDataFetchCallback,
&fetched_external_data,
run_loop.QuitClosure()));
run_loop.Run();
ASSERT_TRUE(fetched_external_data);
EXPECT_EQ(external_data, *fetched_external_data);
}
} // namespace policy
| 40.72549 | 86 | 0.771786 | cvsuser-chromium |
a33db1ad4288d72bf365a93f17287ff06cb8bc4c | 837 | cpp | C++ | ProjectEuler/030.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | 2 | 2021-06-09T12:27:07.000Z | 2021-06-11T12:02:03.000Z | ProjectEuler/030.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | 1 | 2021-09-08T12:00:05.000Z | 2021-09-08T14:52:30.000Z | ProjectEuler/030.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | null | null | null | /*
* @Author: tusikalanse
* @Date: 2021-07-08 12:40:28
* @LastEditTime: 2021-07-08 12:43:12
* @LastEditors: Please set LastEditors
* @Description: In User Settings Edit
* @FilePath: /undefined/root/acm-icpc/ProjectEuler/30.cpp
*/
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL gcd(LL a, LL b) {
return b == 0 ? a : gcd(b, a % b);
}
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
//-------------------end head--------------
int fifthpower(int x) {
return x * x * x * x * x;
}
int main() {
int ans = 0;
for (int i = 2; i <= 354294; ++i) {
int x = i, sum = 0;
while (x) {
sum += fifthpower(x % 10);
x /= 10;
}
if (sum == i)
ans += i;
}
cout << ans << endl;
return 0;
}
| 22.026316 | 58 | 0.516129 | tusikalanse |
a33eb7ffc42d6bdd8f1c6caae9f1e5f519252a3f | 9,786 | cpp | C++ | Code/GraphMol/Wrap/ResonanceMolSupplier.cpp | docking-org/rdk | 6eb710254f027b348a8e3089e6a92c3d40de0949 | [
"PostgreSQL"
] | null | null | null | Code/GraphMol/Wrap/ResonanceMolSupplier.cpp | docking-org/rdk | 6eb710254f027b348a8e3089e6a92c3d40de0949 | [
"PostgreSQL"
] | null | null | null | Code/GraphMol/Wrap/ResonanceMolSupplier.cpp | docking-org/rdk | 6eb710254f027b348a8e3089e6a92c3d40de0949 | [
"PostgreSQL"
] | null | null | null | // $Id$
//
// Copyright (C) 2015 Paolo Tosco
//
// Copyright (C) 2003-2010 Greg Landrum and Rational Discovery LLC
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#define NO_IMPORT_ARRAY
#include <boost/python.hpp>
#include <string>
// ours
#include <GraphMol/RDKitBase.h>
#include <GraphMol/Resonance.h>
#include <GraphMol/Substruct/SubstructMatch.h>
#include <RDBoost/PySequenceHolder.h>
#include <RDBoost/iterator_next.h>
#include "MolSupplier.h"
#include "substructmethods.h"
namespace python = boost::python;
namespace RDKit {
PyObject *GetResonanceSubstructMatches(
ResonanceMolSupplier &suppl, const ROMol &query, bool uniquify = false,
bool useChirality = false, bool useQueryQueryMatches = false,
unsigned int maxMatches = 1000, int numThreads = 1) {
std::vector<MatchVectType> matches;
int matched =
SubstructMatch(suppl, query, matches, uniquify, true, useChirality,
useQueryQueryMatches, maxMatches, numThreads);
PyObject *res = PyTuple_New(matched);
for (int idx = 0; idx < matched; idx++) {
PyTuple_SetItem(res, idx, convertMatches(matches[idx]));
}
return res;
}
std::string resonanceMolSupplierClassDoc =
"A class which supplies resonance structures (as mols) from a mol.\n \
\n \
Usage examples:\n \
\n \
1) Lazy evaluation: the resonance structures are not constructed\n \
until we ask for them:\n \
>>> suppl = ResonanceMolSupplier(mol)\n \
>>> for resMol in suppl:\n \
... resMol.GetNumAtoms()\n \
\n \
2) Lazy evaluation 2:\n \
>>> suppl = ResonanceMolSupplier(mol)\n \
>>> resMol1 = suppl.next()\n \
>>> resMol2 = suppl.next()\n \
>>> suppl.reset()\n \
>>> resMol3 = suppl.next()\n \
# resMol3 and resMol1 are the same: \n \
>>> MolToSmiles(resMol3)==MolToSmiles(resMol1)\n \
\n \
3) Random Access:\n \
>>> suppl = ResonanceMolSupplier(mol)\n \
>>> resMol1 = suppl[0] \n \
>>> resMol2 = suppl[1] \n \
NOTE: this will generate an IndexError if the supplier doesn't have that many\n \
molecules.\n \
\n \
4) Random Access 2: looping over all resonance structures\n \
>>> suppl = ResonanceMolSupplier(mol)\n \
>>> nResMols = len(suppl)\n \
>>> for i in range(nResMols):\n \
... suppl[i].GetNumAtoms()\n \
\n";
struct resmolsup_wrap {
static void wrap() {
python::enum_<ResonanceMolSupplier::ResonanceFlags>("ResonanceFlags")
.value("ALLOW_INCOMPLETE_OCTETS",
ResonanceMolSupplier::ALLOW_INCOMPLETE_OCTETS)
.value("ALLOW_CHARGE_SEPARATION",
ResonanceMolSupplier::ALLOW_CHARGE_SEPARATION)
.value("KEKULE_ALL", ResonanceMolSupplier::KEKULE_ALL)
.value("UNCONSTRAINED_CATIONS",
ResonanceMolSupplier::UNCONSTRAINED_CATIONS)
.value("UNCONSTRAINED_ANIONS",
ResonanceMolSupplier::UNCONSTRAINED_ANIONS)
.export_values();
python::class_<ResonanceMolSupplier, boost::noncopyable>(
"ResonanceMolSupplier", resonanceMolSupplierClassDoc.c_str(),
python::init<ROMol &, unsigned int, unsigned int>(
(python::arg("mol"), python::arg("flags") = 0,
python::arg("maxStructs") = 1000)))
.def(
"__iter__",
(ResonanceMolSupplier * (*)(ResonanceMolSupplier *)) & MolSupplIter,
python::return_internal_reference<1>())
.def(NEXT_METHOD,
(ROMol * (*)(ResonanceMolSupplier *)) &
MolSupplNextAcceptNullLastMolecule,
"Returns the next resonance structure in the supplier. Raises "
"_StopIteration_ on end.\n",
python::return_value_policy<python::manage_new_object>())
.def("__getitem__",
(ROMol * (*)(ResonanceMolSupplier *, int)) & MolSupplGetItem,
python::return_value_policy<python::manage_new_object>())
.def("reset", &ResonanceMolSupplier::reset,
"Resets our position in the resonance structure supplier to the "
"beginning.\n")
.def("__len__", &ResonanceMolSupplier::length)
.def("atEnd", &ResonanceMolSupplier::atEnd,
"Returns whether or not we have hit the end of the resonance "
"structure supplier.\n")
.def("GetNumConjGrps", &ResonanceMolSupplier::getNumConjGrps,
"Returns the number of individual conjugated groups in the "
"molecule\n")
.def("GetBondConjGrpIdx",
(unsigned int (ResonanceMolSupplier::*)(unsigned int)) &
ResonanceMolSupplier::getBondConjGrpIdx,
"Given a bond index, it returns the index of the conjugated group"
"the bond belongs to, or -1 if it is not conjugated\n")
.def("GetAtomConjGrpIdx",
(unsigned int (ResonanceMolSupplier::*)(unsigned int)) &
ResonanceMolSupplier::getAtomConjGrpIdx,
"Given an atom index, it returns the index of the conjugated group"
"the atom belongs to, or -1 if it is not conjugated\n")
.def("SetNumThreads",
(void (ResonanceMolSupplier::*)(unsigned int)) &
ResonanceMolSupplier::setNumThreads,
"Sets the number of threads to be used to enumerate resonance\n"
"structures (defaults to 1; 0 selects the number of concurrent\n"
"threads supported by the hardware; negative values are added\n"
"to the number of concurrent threads supported by the hardware)\n")
.def("Enumerate", &ResonanceMolSupplier::enumerate,
"Ask ResonanceMolSupplier to enumerate resonance structures"
"(automatically done as soon as any attempt to access them is "
"made)\n")
.def("GetIsEnumerated", &ResonanceMolSupplier::getIsEnumerated,
"Returns true if resonance structure enumeration has already "
"happened\n")
.def("GetSubstructMatch",
(PyObject * (*)(ResonanceMolSupplier & m, const ROMol &query, bool,
bool)) GetSubstructMatch,
(python::arg("self"), python::arg("query"),
python::arg("useChirality") = false,
python::arg("useQueryQueryMatches") = false),
"Returns the indices of the molecule's atoms that match a "
"substructure query,\n"
"taking into account all resonance structures in "
"ResonanceMolSupplier.\n\n"
" ARGUMENTS:\n"
" - query: a Molecule\n\n"
" - useChirality: enables the use of stereochemistry in the "
"matching\n\n"
" - useQueryQueryMatches: use query-query matching logic\n\n"
" RETURNS: a tuple of integers\n\n"
" NOTES:\n"
" - only a single match is returned\n"
" - the ordering of the indices corresponds to the atom "
"ordering\n"
" in the query. For example, the first index is for the "
"atom in\n"
" this molecule that matches the first atom in the "
"query.\n")
.def("GetSubstructMatches", GetResonanceSubstructMatches,
(python::arg("self"), python::arg("query"),
python::arg("uniquify") = false,
python::arg("useChirality") = false,
python::arg("useQueryQueryMatches") = false,
python::arg("maxMatches") = 1000, python::arg("numThreads") = 1),
"Returns tuples of the indices of the molecule's atoms that match "
"a substructure query,\n"
"taking into account all resonance structures in "
"ResonanceMolSupplier.\n\n"
" ARGUMENTS:\n"
" - query: a Molecule.\n"
" - uniquify: (optional) determines whether or not the matches "
"are uniquified.\n"
" Defaults to 1.\n\n"
" - useChirality: enables the use of stereochemistry in the "
"matching\n\n"
" - useQueryQueryMatches: use query-query matching logic\n\n"
" - maxMatches: The maximum number of matches that will be "
"returned.\n"
" In high-symmetry cases with medium-sized "
"molecules, it is\n"
" very easy to end up with a combinatorial "
"explosion in the\n"
" number of possible matches. This argument "
"prevents that from\n"
" having unintended consequences\n\n"
" - numThreads: The number of threads to be used (defaults to "
"1; 0 selects the\n"
" number of concurrent threads supported by the "
"hardware; negative\n"
" values are added to the number of concurrent "
"threads supported\n"
" by the hardware).\n\n"
" RETURNS: a tuple of tuples of integers\n\n"
" NOTE:\n"
" - the ordering of the indices corresponds to the atom "
"ordering\n"
" in the query. For example, the first index is for the "
"atom in\n"
" this molecule that matches the first atom in the "
"query.\n");
};
};
}
void wrap_resmolsupplier() { RDKit::resmolsup_wrap::wrap(); }
| 45.305556 | 88 | 0.58737 | docking-org |
a33ef0c3de014f99c9a4dd6af4781002a66527fb | 3,786 | cpp | C++ | ShaderBank.cpp | m3rt32/OpenGL-Playground | 5dbf38dce53ee90a2e59953bedb83de59c270f0a | [
"Apache-2.0"
] | null | null | null | ShaderBank.cpp | m3rt32/OpenGL-Playground | 5dbf38dce53ee90a2e59953bedb83de59c270f0a | [
"Apache-2.0"
] | null | null | null | ShaderBank.cpp | m3rt32/OpenGL-Playground | 5dbf38dce53ee90a2e59953bedb83de59c270f0a | [
"Apache-2.0"
] | 1 | 2020-04-22T22:30:22.000Z | 2020-04-22T22:30:22.000Z | #include <iostream>
#include <fstream>
#include <sstream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <vector>
#include <glm.hpp>
#include <gtc/matrix_transform.hpp>
#include <gtc/matrix_access.hpp>
class ShaderBank
{
public:
ShaderBank(std::string vertexFile, std::string fragmentFile)
{
vertexShaderId = LoadShader(vertexFile, GL_VERTEX_SHADER);
fragmentShaderId = LoadShader(fragmentFile, GL_FRAGMENT_SHADER);
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
}
void BindAttribute(int attributeIndex, std::string attributeName)
{
const GLchar* attrName = attributeName.c_str();
glBindAttribLocation(programId, attributeIndex, attrName);
}
void Prepare()
{
glLinkProgram(programId);
glValidateProgram(programId);
prepared = true;
CheckLinking();
GetAllUniformLocations();
}
void Activate()
{
if (!this->prepared)
std::cout << "Prepare method not called!!!" << std::endl;
glUseProgram(programId);
}
void Deactivate()
{
glUseProgram(0);
}
void Dispose()
{
Deactivate();
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
glDeleteProgram(programId);
}
void GetAllUniformLocations()
{
location_transformMatrix = GetUniformLocation("transformationMatrix");
location_MVPMatrix = GetUniformLocation("MVP");
}
void LoadTRSToBuffer(glm::mat4 matrix)
{
LoadToUniformBuffer(location_transformMatrix, matrix);
}
void LoadMVPToBuffer(glm::mat4 model,glm::mat4 view,glm::mat4 projection)
{
glm::mat4 mvp = projection * view * model;
LoadToUniformBuffer(location_MVPMatrix, mvp);
}
private:
bool prepared = false;
int programId;
int vertexShaderId;
int fragmentShaderId;
int location_transformMatrix;
int location_MVPMatrix;
static int LoadShader(std::string shaderFileName, int shaderType)
{
auto sourceString = ReadShader(shaderFileName);
const GLchar* source = sourceString.c_str();
const int source_length = sourceString.size();
int shader_id = glCreateShader(shaderType);
glShaderSource(shader_id, 1, &source, &source_length);
glCompileShader(shader_id);
int result;
glGetShaderiv(shader_id, GL_COMPILE_STATUS, &result);
if (result != GL_TRUE)
{
int log_length = 0;
char message[2048];
glGetShaderInfoLog(shader_id, 2048, &log_length, message);
std::cout << message << std::endl;
}
return shader_id;
}
static std::string ReadShader(std::string shaderFileName)
{
std::ifstream inFile;
inFile.open("Engine/Shaders/" + shaderFileName);
if (!inFile)
std::cout << "ERROR READING" + shaderFileName << std::endl;
std::stringstream strStream;
strStream << inFile.rdbuf();
return strStream.str();
}
void CheckLinking()
{
GLint program_linked;
glGetProgramiv(programId, GL_LINK_STATUS, &program_linked);
if (program_linked != GL_TRUE)
{
GLsizei log_length = 0;
GLchar message[1024];
glGetProgramInfoLog(programId, 1024, &log_length, message);
std::cout << message << std::endl;
}
}
int GetUniformLocation(std::string uniformName)
{
return glGetUniformLocation(programId, uniformName.c_str());
}
void LoadToUniformBuffer(int location, float value)
{
glUniform1f(location, value);
}
void LoadToUniformBuffer(int location, glm::vec3 value)
{
glUniform3f(location, value.x, value.y, value.z);
}
void LoadToUniformBuffer(int location, bool value)
{
glUniform1i(location, value);
}
void LoadToUniformBuffer(int location, glm::mat4& value) //& passing value by reference
{
//count:how many matrices that you provide
glUniformMatrix4fv(location, 1, false, &value[0][0]); //get pointer of the referenced value
}
}; | 24.584416 | 93 | 0.735605 | m3rt32 |
a33fc6a07574671dc5d7e1bf8b4164e079d066c8 | 15,169 | cc | C++ | src/yb/tablet/transaction_loader.cc | tverona1/yugabyte-db | 5099526ca75c25acf893e9bacda7aad33fabf6c8 | [
"Apache-2.0",
"CC0-1.0"
] | 2,759 | 2017-10-05T22:15:20.000Z | 2019-09-16T13:16:21.000Z | src/yb/tablet/transaction_loader.cc | tverona1/yugabyte-db | 5099526ca75c25acf893e9bacda7aad33fabf6c8 | [
"Apache-2.0",
"CC0-1.0"
] | 2,195 | 2017-11-06T23:38:44.000Z | 2019-09-16T20:24:31.000Z | src/yb/tablet/transaction_loader.cc | tverona1/yugabyte-db | 5099526ca75c25acf893e9bacda7aad33fabf6c8 | [
"Apache-2.0",
"CC0-1.0"
] | 257 | 2017-10-06T02:23:19.000Z | 2019-09-13T18:01:15.000Z | // Copyright (c) YugaByte, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations
// under the License.
//
#include "yb/tablet/transaction_loader.h"
#include "yb/docdb/bounded_rocksdb_iterator.h"
#include "yb/docdb/doc_key.h"
#include "yb/docdb/docdb_rocksdb_util.h"
#include "yb/docdb/intent.h"
#include "yb/tablet/transaction_status_resolver.h"
#include "yb/util/bitmap.h"
#include "yb/util/flag_tags.h"
#include "yb/util/logging.h"
#include "yb/util/metrics.h"
#include "yb/util/operation_counter.h"
#include "yb/util/pb_util.h"
#include "yb/util/scope_exit.h"
#include "yb/util/thread.h"
using namespace std::literals;
DEFINE_test_flag(int32, inject_load_transaction_delay_ms, 0,
"Inject delay before loading each transaction at startup.");
DECLARE_bool(TEST_fail_on_replicated_batch_idx_set_in_txn_record);
METRIC_DEFINE_simple_counter(
tablet, transaction_load_attempts,
"Total number of attempts to load transaction metadata from the intents RocksDB",
yb::MetricUnit::kTransactions);
namespace yb {
namespace tablet {
namespace {
docdb::BoundedRocksDbIterator CreateFullScanIterator(rocksdb::DB* db) {
return docdb::BoundedRocksDbIterator(docdb::CreateRocksDBIterator(
db, &docdb::KeyBounds::kNoBounds,
docdb::BloomFilterMode::DONT_USE_BLOOM_FILTER,
/* user_key_for_filter= */ boost::none, rocksdb::kDefaultQueryId));
}
} // namespace
class TransactionLoader::Executor {
public:
explicit Executor(
TransactionLoader* loader,
RWOperationCounter* pending_op_counter)
: loader_(*loader), scoped_pending_operation_(pending_op_counter) {
metric_transaction_load_attempts_ = METRIC_transaction_load_attempts.Instantiate(
loader_.entity_);
}
bool Start(const docdb::DocDB& db) {
if (!scoped_pending_operation_.ok()) {
return false;
}
regular_iterator_ = CreateFullScanIterator(db.regular);
intents_iterator_ = CreateFullScanIterator(db.intents);
auto& load_thread = loader_.load_thread_;
load_thread = std::thread(&Executor::Execute, this);
return true;
}
private:
void Execute() {
CDSAttacher attacher;
SetThreadName("TransactionLoader");
auto se = ScopeExit([this] {
auto pending_applies = std::move(pending_applies_);
TransactionLoaderContext& context = loader_.context_;
loader_.executor_.reset();
context.LoadFinished(pending_applies);
});
LOG_WITH_PREFIX(INFO) << "Load transactions start";
LoadPendingApplies();
LoadTransactions();
}
void LoadTransactions() {
size_t loaded_transactions = 0;
TransactionId id = TransactionId::Nil();
AppendTransactionKeyPrefix(id, ¤t_key_);
intents_iterator_.Seek(current_key_.AsSlice());
while (intents_iterator_.Valid()) {
auto key = intents_iterator_.key();
if (!key.TryConsumeByte(docdb::KeyEntryTypeAsChar::kTransactionId)) {
break;
}
auto decode_id_result = DecodeTransactionId(&key);
if (!decode_id_result.ok()) {
LOG_WITH_PREFIX(DFATAL)
<< "Failed to decode transaction id from: " << key.ToDebugHexString();
intents_iterator_.Next();
continue;
}
id = *decode_id_result;
current_key_.Clear();
AppendTransactionKeyPrefix(id, ¤t_key_);
if (key.empty()) { // The key only contains a transaction id - it is metadata record.
if (FLAGS_TEST_inject_load_transaction_delay_ms > 0) {
std::this_thread::sleep_for(FLAGS_TEST_inject_load_transaction_delay_ms * 1ms);
}
LoadTransaction(id);
++loaded_transactions;
}
current_key_.AppendKeyEntryType(docdb::KeyEntryType::kMaxByte);
intents_iterator_.Seek(current_key_.AsSlice());
}
intents_iterator_.Reset();
context().CompleteLoad([this] {
loader_.all_loaded_.store(true, std::memory_order_release);
});
{
// We need to lock and unlock the mutex here to avoid missing a notification in WaitLoaded
// and WaitAllLoaded. The waiting loop in those functions is equivalent to the following,
// after locking the mutex (and of course wait(...) releases the mutex while waiting):
//
// 1 while (!all_loaded_.load(std::memory_order_acquire)) {
// 2 load_cond_.wait(lock);
// 3 }
//
// If we did not have the lock/unlock here, it would be possible that all_loaded_ would be set
// to true and notify_all() would be called between lines 1 and 2, and we would miss the
// notification and wait indefinitely at line 2. With lock/unlock this is no longer possible
// because if we set all_loaded_ to true between lines 1 and 2, the only time we would be able
// to send a notification at line 2 as wait(...) releases the mutex, but then we would check
// all_loaded_ and exit the loop at line 1.
std::lock_guard<std::mutex> lock(loader_.mutex_);
}
loader_.load_cond_.notify_all();
LOG_WITH_PREFIX(INFO) << __func__ << " done: loaded " << loaded_transactions << " transactions";
}
void LoadPendingApplies() {
std::array<char, 1 + sizeof(TransactionId) + 1> seek_buffer;
seek_buffer[0] = docdb::KeyEntryTypeAsChar::kTransactionApplyState;
seek_buffer[seek_buffer.size() - 1] = docdb::KeyEntryTypeAsChar::kMaxByte;
regular_iterator_.Seek(Slice(seek_buffer.data(), 1));
while (regular_iterator_.Valid()) {
auto key = regular_iterator_.key();
if (!key.TryConsumeByte(docdb::KeyEntryTypeAsChar::kTransactionApplyState)) {
break;
}
auto txn_id = DecodeTransactionId(&key);
if (!txn_id.ok() || !key.TryConsumeByte(docdb::KeyEntryTypeAsChar::kGroupEnd)) {
LOG_WITH_PREFIX(DFATAL) << "Wrong txn id: " << regular_iterator_.key().ToDebugString();
regular_iterator_.Next();
continue;
}
Slice value = regular_iterator_.value();
if (value.TryConsumeByte(docdb::ValueEntryTypeAsChar::kString)) {
auto pb = pb_util::ParseFromSlice<docdb::ApplyTransactionStatePB>(value);
if (!pb.ok()) {
LOG_WITH_PREFIX(DFATAL) << "Failed to decode apply state pb from RocksDB"
<< key.ToDebugString() << ": " << pb.status();
regular_iterator_.Next();
continue;
}
auto state = docdb::ApplyTransactionState::FromPB(*pb);
if (!state.ok()) {
LOG_WITH_PREFIX(DFATAL) << "Failed to decode apply state from stored pb "
<< state.status();
regular_iterator_.Next();
continue;
}
auto it = pending_applies_.emplace(*txn_id, ApplyStateWithCommitHt {
.state = state.get(),
.commit_ht = HybridTime(pb->commit_ht())
}).first;
VLOG_WITH_PREFIX(4) << "Loaded pending apply for " << *txn_id << ": "
<< it->second.ToString();
} else if (value.TryConsumeByte(docdb::ValueEntryTypeAsChar::kTombstone)) {
VLOG_WITH_PREFIX(4) << "Found deleted large apply for " << *txn_id;
} else {
LOG_WITH_PREFIX(DFATAL)
<< "Unexpected value type in apply state: " << value.ToDebugString();
}
memcpy(seek_buffer.data() + 1, txn_id->data(), txn_id->size());
ROCKSDB_SEEK(®ular_iterator_, Slice(seek_buffer));
}
}
// id - transaction id to load.
void LoadTransaction(const TransactionId& id) {
metric_transaction_load_attempts_->Increment();
VLOG_WITH_PREFIX(1) << "Loading transaction: " << id;
TransactionMetadataPB metadata_pb;
const Slice& value = intents_iterator_.value();
if (!metadata_pb.ParseFromArray(value.cdata(), narrow_cast<int>(value.size()))) {
LOG_WITH_PREFIX(DFATAL) << "Unable to parse stored metadata: "
<< value.ToDebugHexString();
return;
}
auto metadata = TransactionMetadata::FromPB(metadata_pb);
if (!metadata.ok()) {
LOG_WITH_PREFIX(DFATAL) << "Loaded bad metadata: " << metadata.status();
return;
}
if (!metadata->start_time.is_valid()) {
metadata->start_time = HybridTime::kMin;
LOG_WITH_PREFIX(INFO) << "Patched start time " << metadata->transaction_id << ": "
<< metadata->start_time;
}
TransactionalBatchData last_batch_data;
OneWayBitmap replicated_batches;
FetchLastBatchData(id, &last_batch_data, &replicated_batches);
if (!status_resolver_) {
status_resolver_ = &context().AddStatusResolver();
}
status_resolver_->Add(metadata->status_tablet, id);
auto pending_apply_it = pending_applies_.find(id);
context().LoadTransaction(
std::move(*metadata), std::move(last_batch_data), std::move(replicated_batches),
pending_apply_it != pending_applies_.end() ? &pending_apply_it->second : nullptr);
{
std::lock_guard<std::mutex> lock(loader_.mutex_);
loader_.last_loaded_ = id;
}
loader_.load_cond_.notify_all();
}
void FetchLastBatchData(
const TransactionId& id,
TransactionalBatchData* last_batch_data,
OneWayBitmap* replicated_batches) {
current_key_.AppendKeyEntryType(docdb::KeyEntryType::kMaxByte);
intents_iterator_.Seek(current_key_.AsSlice());
if (intents_iterator_.Valid()) {
intents_iterator_.Prev();
} else {
intents_iterator_.SeekToLast();
}
current_key_.RemoveLastByte();
while (intents_iterator_.Valid() && intents_iterator_.key().starts_with(current_key_)) {
auto decoded_key = docdb::DecodeIntentKey(intents_iterator_.value());
LOG_IF_WITH_PREFIX(DFATAL, !decoded_key.ok())
<< "Failed to decode intent while loading transaction " << id << ", "
<< intents_iterator_.key().ToDebugHexString() << " => "
<< intents_iterator_.value().ToDebugHexString() << ": " << decoded_key.status();
if (decoded_key.ok() && docdb::HasStrong(decoded_key->intent_types)) {
last_batch_data->hybrid_time = decoded_key->doc_ht.hybrid_time();
Slice rev_key_slice(intents_iterator_.value());
// Required by the transaction sealing protocol.
if (!rev_key_slice.empty() && rev_key_slice[0] == docdb::KeyEntryTypeAsChar::kBitSet) {
CHECK(!FLAGS_TEST_fail_on_replicated_batch_idx_set_in_txn_record);
rev_key_slice.remove_prefix(1);
auto result = OneWayBitmap::Decode(&rev_key_slice);
if (result.ok()) {
*replicated_batches = std::move(*result);
VLOG_WITH_PREFIX(1) << "Decoded replicated batches for " << id << ": "
<< replicated_batches->ToString();
} else {
LOG_WITH_PREFIX(DFATAL)
<< "Failed to decode replicated batches from "
<< intents_iterator_.value().ToDebugHexString() << ": " << result.status();
}
}
std::string rev_key = rev_key_slice.ToBuffer();
intents_iterator_.Seek(rev_key);
// Delete could run in parallel to this load, and since our deletes break snapshot read
// we could get into a situation when metadata and reverse record were successfully read,
// but intent record could not be found.
if (intents_iterator_.Valid() && intents_iterator_.key().starts_with(rev_key)) {
VLOG_WITH_PREFIX(1)
<< "Found latest record for " << id
<< ": " << docdb::SubDocKey::DebugSliceToString(intents_iterator_.key())
<< " => " << intents_iterator_.value().ToDebugHexString();
auto txn_id_slice = id.AsSlice();
auto decoded_value_or_status = docdb::DecodeIntentValue(
intents_iterator_.value(), &txn_id_slice);
LOG_IF_WITH_PREFIX(DFATAL, !decoded_value_or_status.ok())
<< "Failed to decode intent value: " << decoded_value_or_status.status() << ", "
<< docdb::SubDocKey::DebugSliceToString(intents_iterator_.key()) << " => "
<< intents_iterator_.value().ToDebugHexString();
if (decoded_value_or_status.ok()) {
last_batch_data->next_write_id = decoded_value_or_status->write_id;
}
++last_batch_data->next_write_id;
}
break;
}
intents_iterator_.Prev();
}
}
TransactionLoaderContext& context() const {
return loader_.context_;
}
const std::string& LogPrefix() const {
return context().LogPrefix();
}
TransactionLoader& loader_;
ScopedRWOperation scoped_pending_operation_;
docdb::BoundedRocksDbIterator regular_iterator_;
docdb::BoundedRocksDbIterator intents_iterator_;
// Buffer that contains key of current record, i.e. value type + transaction id.
docdb::KeyBytes current_key_;
TransactionStatusResolver* status_resolver_ = nullptr;
ApplyStatesMap pending_applies_;
scoped_refptr<Counter> metric_transaction_load_attempts_;
};
TransactionLoader::TransactionLoader(
TransactionLoaderContext* context, const scoped_refptr<MetricEntity>& entity)
: context_(*context), entity_(entity) {}
TransactionLoader::~TransactionLoader() {
}
void TransactionLoader::Start(RWOperationCounter* pending_op_counter, const docdb::DocDB& db) {
executor_ = std::make_unique<Executor>(this, pending_op_counter);
if (!executor_->Start(db)) {
executor_ = nullptr;
}
}
namespace {
// Waiting threads will only wake up on a timeout if there is still an uncaught race condition that
// causes us to miss a notification on the condition variable.
constexpr auto kWaitLoadedWakeUpInterval = 10s;
} // namespace
void TransactionLoader::WaitLoaded(const TransactionId& id) NO_THREAD_SAFETY_ANALYSIS {
if (all_loaded_.load(std::memory_order_acquire)) {
return;
}
std::unique_lock<std::mutex> lock(mutex_);
// Defensively wake up at least once a second to avoid deadlock due to any issue similar to #8696.
while (!all_loaded_.load(std::memory_order_acquire)) {
if (last_loaded_ >= id) {
break;
}
load_cond_.wait_for(lock, kWaitLoadedWakeUpInterval);
}
}
// Disable thread safety analysis because std::unique_lock is used.
void TransactionLoader::WaitAllLoaded() NO_THREAD_SAFETY_ANALYSIS {
if (all_loaded_.load(std::memory_order_acquire)) {
return;
}
// Defensively wake up at least once a second to avoid deadlock due to any issue similar to #8696.
std::unique_lock<std::mutex> lock(mutex_);
while (!all_loaded_.load(std::memory_order_acquire)) {
load_cond_.wait_for(lock, kWaitLoadedWakeUpInterval);
}
}
void TransactionLoader::Shutdown() {
if (load_thread_.joinable()) {
load_thread_.join();
}
}
} // namespace tablet
} // namespace yb
| 37.9225 | 100 | 0.676379 | tverona1 |
a341655f44fe224bb63c919716e616a64299603b | 1,604 | cpp | C++ | contents/forward_euler_method/code/c++/euler.cpp | atocil/algorithm-archive | 2eb30cb103508c9efb91621564bd3114eb49d3af | [
"MIT"
] | 1,975 | 2018-04-28T13:46:56.000Z | 2022-03-29T13:14:47.000Z | contents/forward_euler_method/code/c++/euler.cpp | atocil/algorithm-archive | 2eb30cb103508c9efb91621564bd3114eb49d3af | [
"MIT"
] | 632 | 2018-04-28T10:27:13.000Z | 2022-03-28T20:38:53.000Z | contents/forward_euler_method/code/c++/euler.cpp | atocil/algorithm-archive | 2eb30cb103508c9efb91621564bd3114eb49d3af | [
"MIT"
] | 433 | 2018-04-27T22:50:22.000Z | 2022-03-22T06:16:03.000Z | #include <algorithm>
#include <cmath>
#include <cstddef>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using std::begin;
using std::end;
using std::size_t;
std::vector<double> solve_euler(double timestep, size_t size) {
std::vector<double> result;
double current = 1.0;
for (size_t i = 0; i < size; ++i) {
result.push_back(current);
current -= 3.0 * current * timestep;
}
return result;
}
// check_result takes an iterator over doubles,
// and returns whether any value is outside the passed threshold.
template <typename Iter>
bool check_result(Iter first, Iter last, double threshold, double timestep) {
auto it = first;
for (size_t idx = 0; it != last; ++idx, ++it) {
double solution = std::exp(-3.0 * idx * timestep);
if (std::abs(*it - solution) > threshold) {
std::cout << "We found a value outside the threshold; the " << idx
<< "-th value was " << *it << ", but the expected solution was "
<< solution << '\n';
std::cout << "(the threshold was " << threshold
<< " and the difference was " << std::abs(*it - solution)
<< ")\n";
return true;
}
}
return false;
}
int main() {
double threshold = 0.01;
double timestep = 0.01;
auto result = solve_euler(timestep, 100);
auto outside_threshold =
check_result(begin(result), end(result), threshold, timestep);
auto msg = outside_threshold ? "yes :(" : "no :D";
std::cout << "Were any of the values outside of the threshold (" << threshold
<< ")? " << msg << '\n';
}
| 28.642857 | 80 | 0.609102 | atocil |
a3423b5d7f97f8e1c2bef283aa025cb897bf25e9 | 1,014 | cpp | C++ | tests/decisionMaker/XML_test_load_parameters_decision_maker_v2/main.cpp | SimulationEverywhere/NEP_DAM | bc8cdf661c4a4e050abae12fb756f41ec6240e6b | [
"BSD-2-Clause"
] | null | null | null | tests/decisionMaker/XML_test_load_parameters_decision_maker_v2/main.cpp | SimulationEverywhere/NEP_DAM | bc8cdf661c4a4e050abae12fb756f41ec6240e6b | [
"BSD-2-Clause"
] | null | null | null | tests/decisionMaker/XML_test_load_parameters_decision_maker_v2/main.cpp | SimulationEverywhere/NEP_DAM | bc8cdf661c4a4e050abae12fb756f41ec6240e6b | [
"BSD-2-Clause"
] | null | null | null | #include <math.h>
#include <assert.h>
#include <memory>
#include <iomanip>
#include <iostream>
#include <fstream>
#include <string>
#include <chrono>
#include <algorithm>
#include <limits>
#include "../../../data_structures/nep_model_enum_types.hpp"
#include "../../../data_structures/decision_maker_behaviour_struct_types_V2.hpp"
#include "../../../data_structures/decision_maker_behaviour_enum_types.hpp"
using namespace std;
using namespace nep_model_enum_types;
using namespace decision_maker_behaviour_structures;
using namespace decision_maker_behaviour_enum_types;
int main(){
string file_name_in = string("XML_DecisionMakerBehaviour_Eg1_v2.xml");
DecisionMakerBehaviour decison_maker_behaviour;
const char * in = file_name_in.c_str();
decison_maker_behaviour.load(in);
#ifdef DEBUG_PARAMETERS
string debugname = string("test_load_XML_DecisionMakerBehaviour_Eg1_v2.xml");
const char * out = debugname.c_str();
decison_maker_behaviour.save(out);
#endif
return 1;
} | 29.823529 | 87 | 0.770217 | SimulationEverywhere |
a34257fafa1f6103acf98bad3926e1a6d75fc991 | 2,687 | cpp | C++ | snowman.cpp | ItayMeiri/CCPEx_1B | a020e314416371bd891e46507ec1ad3cd836cd8d | [
"MIT"
] | null | null | null | snowman.cpp | ItayMeiri/CCPEx_1B | a020e314416371bd891e46507ec1ad3cd836cd8d | [
"MIT"
] | null | null | null | snowman.cpp | ItayMeiri/CCPEx_1B | a020e314416371bd891e46507ec1ad3cd836cd8d | [
"MIT"
] | null | null | null | #include "snowman.hpp"
#include <iostream>
namespace ariel
{
const int options = 4;
const int required_seed_length = 8;
std::array<std::string, options> hats = {
" _===_",
" ___\n .....",
" _\n /_\\",
" ___ \n (_*_)"
};
std::array<std::string, options> noses = {",", ".", "_", " "};
std::array<std::string, options> eyes = {".", "o", "O", "-"};
std::array<std::string, options> base = {" : ", "\" \"", "___", " "};
std::array<std::string, options> torso = {" : ", "] [", "> <", " "};
std::array<std::string, options> leftHand = {" <", "\\ ", " /", " "};
std::array<std::string, options> rightHand = {" >", "/ ", " \\", " "};
const int Hat=0 , Nose=1, LeftEye=2 , RightEye=3, RightHand=4, LeftHand=5, Torso=6, Base=7;
std::string snowman(int seed)
{
// validate snowman seed, throws exception when invalid
std::array<std::string, required_seed_length> strSeed = seedValidator(seed); // stored as the seed HNLRXYTB
std::string sman =
strSeed.at(Hat) + "\n" // hat
+strSeed.at(RightHand).at(0) + "(" // right arm, char 0
+strSeed.at(LeftEye) + strSeed.at(1) + strSeed.at(3) + ")" // face and eyes
+strSeed.at(LeftHand).at(0) + "\n" // left arm, char 0
+strSeed.at(RightHand).at(1) + "(" // right arm, char 1
+strSeed.at(Torso) + ")" // torso
+strSeed.at(LeftHand).at(1) + "\n (" // left arm, char 1
+strSeed.at(Base) + ")"; // base
return sman;
}
constexpr int TEN{10};
std::array<std::string, required_seed_length> seedValidator(int seed)
{
if(seed < 0) { throw std::out_of_range("Invalid code '5'");}
int count = 0;
std::array<std::string, required_seed_length> str;
int size = required_seed_length - 1;
while(seed > 0)
{
if ((seed % TEN) > 4){ // get last digit
throw std::out_of_range("Invalid code '5'");
}
//HNLRXYTB
int index = (seed % TEN) - 1;
int strCount = size - count;
if(count == Base){str.at(strCount) = hats.at(index);}
else if(count == Torso){str.at(strCount) = noses.at(index);}
else if( (count == LeftHand) || (count == RightHand) ){str.at(strCount) = eyes.at(index);} // left
else if(count == RightEye){str.at(strCount) = leftHand.at(index);}
else if(count == LeftEye){str.at(strCount) = rightHand.at(index);}
else if(count == Nose){str.at(strCount) = torso.at(index);}
else if(count == Hat){str.at(strCount) = base.at(index);}
seed = (seed/TEN); // removes last digit
count++; // counts the digits
}
if(count != required_seed_length ){
throw std::out_of_range("Invalid code '5'");
}
return str;
}
} | 34.896104 | 112 | 0.563082 | ItayMeiri |
a342786af783cc2e6302597f8dc7060180c5e8c2 | 14,049 | cc | C++ | third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator_test.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 76 | 2020-09-02T03:05:41.000Z | 2022-03-30T04:40:55.000Z | third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator_test.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 45 | 2020-09-02T03:21:37.000Z | 2022-03-31T22:19:45.000Z | third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator_test.cc | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 8 | 2020-07-22T18:49:18.000Z | 2022-02-08T10:27:16.000Z | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/core/html/canvas/canvas_async_blob_creator.h"
#include "components/ukm/test_ukm_recorder.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/html/canvas/image_data.h"
#include "third_party/blink/renderer/core/testing/page_test_base.h"
#include "third_party/blink/renderer/platform/graphics/color_correction_test_utils.h"
#include "third_party/blink/renderer/platform/graphics/static_bitmap_image.h"
#include "third_party/blink/renderer/platform/graphics/unaccelerated_static_bitmap_image.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include "third_party/skia/include/core/SkSurface.h"
namespace blink {
typedef CanvasAsyncBlobCreator::IdleTaskStatus IdleTaskStatus;
class MockCanvasAsyncBlobCreator : public CanvasAsyncBlobCreator {
public:
MockCanvasAsyncBlobCreator(scoped_refptr<StaticBitmapImage> image,
ImageEncodingMimeType mime_type,
Document* document,
bool fail_encoder_initialization = false)
: CanvasAsyncBlobCreator(
image,
CanvasAsyncBlobCreator::GetImageEncodeOptionsForMimeType(mime_type),
kHTMLCanvasToBlobCallback,
nullptr,
base::TimeTicks(),
document->GetExecutionContext(),
0,
nullptr) {
if (fail_encoder_initialization)
fail_encoder_initialization_for_test_ = true;
enforce_idle_encoding_for_test_ = true;
}
CanvasAsyncBlobCreator::IdleTaskStatus GetIdleTaskStatus() {
return idle_task_status_;
}
MOCK_METHOD0(SignalTaskSwitchInStartTimeoutEventForTesting, void());
MOCK_METHOD0(SignalTaskSwitchInCompleteTimeoutEventForTesting, void());
protected:
void CreateBlobAndReturnResult() override {}
void CreateNullAndReturnResult() override {}
void SignalAlternativeCodePathFinishedForTesting() override;
void PostDelayedTaskToCurrentThread(const base::Location&,
base::OnceClosure,
double delay_ms) override;
};
void MockCanvasAsyncBlobCreator::SignalAlternativeCodePathFinishedForTesting() {
test::ExitRunLoop();
}
void MockCanvasAsyncBlobCreator::PostDelayedTaskToCurrentThread(
const base::Location& location,
base::OnceClosure task,
double delay_ms) {
DCHECK(IsMainThread());
Thread::Current()->GetTaskRunner()->PostTask(location, std::move(task));
}
//==============================================================================
class MockCanvasAsyncBlobCreatorWithoutStart
: public MockCanvasAsyncBlobCreator {
public:
MockCanvasAsyncBlobCreatorWithoutStart(scoped_refptr<StaticBitmapImage> image,
Document* document)
: MockCanvasAsyncBlobCreator(image, kMimeTypePng, document) {}
protected:
void ScheduleInitiateEncoding(double) override {
// Deliberately make scheduleInitiateEncoding do nothing so that idle
// task never starts
}
};
//==============================================================================
class MockCanvasAsyncBlobCreatorWithoutComplete
: public MockCanvasAsyncBlobCreator {
public:
MockCanvasAsyncBlobCreatorWithoutComplete(
scoped_refptr<StaticBitmapImage> image,
Document* document,
bool fail_encoder_initialization = false)
: MockCanvasAsyncBlobCreator(image,
kMimeTypePng,
document,
fail_encoder_initialization) {}
protected:
void ScheduleInitiateEncoding(double quality) override {
Thread::Current()->GetTaskRunner()->PostTask(
FROM_HERE,
WTF::Bind(&MockCanvasAsyncBlobCreatorWithoutComplete::InitiateEncoding,
WrapPersistent(this), quality, base::TimeTicks::Max()));
}
void IdleEncodeRows(base::TimeTicks deadline) override {
// Deliberately make idleEncodeRows do nothing so that idle task never
// completes
}
};
//==============================================================================
class CanvasAsyncBlobCreatorTest : public PageTestBase {
public:
void PrepareMockCanvasAsyncBlobCreatorWithoutStart();
void PrepareMockCanvasAsyncBlobCreatorWithoutComplete();
void PrepareMockCanvasAsyncBlobCreatorFail();
protected:
CanvasAsyncBlobCreatorTest();
MockCanvasAsyncBlobCreator* AsyncBlobCreator() {
return async_blob_creator_.Get();
}
ukm::UkmRecorder* UkmRecorder() { return &ukm_recorder_; }
void TearDown() override;
private:
Persistent<MockCanvasAsyncBlobCreator> async_blob_creator_;
ukm::TestUkmRecorder ukm_recorder_;
};
CanvasAsyncBlobCreatorTest::CanvasAsyncBlobCreatorTest() = default;
scoped_refptr<StaticBitmapImage> CreateTransparentImage(int width, int height) {
sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(width, height);
if (!surface)
return nullptr;
return UnacceleratedStaticBitmapImage::Create(surface->makeImageSnapshot());
}
void CanvasAsyncBlobCreatorTest::
PrepareMockCanvasAsyncBlobCreatorWithoutStart() {
async_blob_creator_ =
MakeGarbageCollected<MockCanvasAsyncBlobCreatorWithoutStart>(
CreateTransparentImage(20, 20), &GetDocument());
}
void CanvasAsyncBlobCreatorTest::
PrepareMockCanvasAsyncBlobCreatorWithoutComplete() {
async_blob_creator_ =
MakeGarbageCollected<MockCanvasAsyncBlobCreatorWithoutComplete>(
CreateTransparentImage(20, 20), &GetDocument());
}
void CanvasAsyncBlobCreatorTest::PrepareMockCanvasAsyncBlobCreatorFail() {
// We reuse the class MockCanvasAsyncBlobCreatorWithoutComplete because
// this test case is expected to fail at initialization step before
// completion.
async_blob_creator_ =
MakeGarbageCollected<MockCanvasAsyncBlobCreatorWithoutComplete>(
CreateTransparentImage(20, 20), &GetDocument(), true);
}
void CanvasAsyncBlobCreatorTest::TearDown() {
async_blob_creator_ = nullptr;
}
//==============================================================================
TEST_F(CanvasAsyncBlobCreatorTest,
IdleTaskNotStartedWhenStartTimeoutEventHappens) {
// This test mocks the scenario when idle task is not started when the
// StartTimeoutEvent is inspecting the idle task status.
// The whole image encoding process (including initialization) will then
// become carried out in the alternative code path instead.
PrepareMockCanvasAsyncBlobCreatorWithoutStart();
EXPECT_CALL(*(AsyncBlobCreator()),
SignalTaskSwitchInStartTimeoutEventForTesting());
AsyncBlobCreator()->ScheduleAsyncBlobCreation(1.0);
test::EnterRunLoop();
testing::Mock::VerifyAndClearExpectations(AsyncBlobCreator());
EXPECT_EQ(IdleTaskStatus::kIdleTaskSwitchedToImmediateTask,
AsyncBlobCreator()->GetIdleTaskStatus());
}
TEST_F(CanvasAsyncBlobCreatorTest,
IdleTaskNotCompletedWhenCompleteTimeoutEventHappens) {
// This test mocks the scenario when idle task is not completed when the
// CompleteTimeoutEvent is inspecting the idle task status.
// The remaining image encoding process (excluding initialization) will
// then become carried out in the alternative code path instead.
PrepareMockCanvasAsyncBlobCreatorWithoutComplete();
EXPECT_CALL(*(AsyncBlobCreator()),
SignalTaskSwitchInCompleteTimeoutEventForTesting());
AsyncBlobCreator()->ScheduleAsyncBlobCreation(1.0);
test::EnterRunLoop();
testing::Mock::VerifyAndClearExpectations(AsyncBlobCreator());
EXPECT_EQ(IdleTaskStatus::kIdleTaskSwitchedToImmediateTask,
AsyncBlobCreator()->GetIdleTaskStatus());
}
TEST_F(CanvasAsyncBlobCreatorTest, IdleTaskFailedWhenStartTimeoutEventHappens) {
// This test mocks the scenario when idle task is not failed during when
// either the StartTimeoutEvent or the CompleteTimeoutEvent is inspecting
// the idle task status.
PrepareMockCanvasAsyncBlobCreatorFail();
AsyncBlobCreator()->ScheduleAsyncBlobCreation(1.0);
test::EnterRunLoop();
EXPECT_EQ(IdleTaskStatus::kIdleTaskFailed,
AsyncBlobCreator()->GetIdleTaskStatus());
}
static sk_sp<SkImage> DrawAndReturnImage(
const std::pair<sk_sp<SkColorSpace>, SkColorType>& color_space_param) {
SkPaint transparentRed, transparentGreen, transparentBlue, transparentBlack;
transparentRed.setARGB(128, 155, 27, 27);
transparentGreen.setARGB(128, 27, 155, 27);
transparentBlue.setARGB(128, 27, 27, 155);
transparentBlack.setARGB(128, 27, 27, 27);
SkImageInfo info = SkImageInfo::Make(2, 2, color_space_param.second,
SkAlphaType::kPremul_SkAlphaType,
color_space_param.first);
sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
surface->getCanvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), transparentRed);
surface->getCanvas()->drawRect(SkRect::MakeXYWH(1, 0, 1, 1),
transparentGreen);
surface->getCanvas()->drawRect(SkRect::MakeXYWH(0, 1, 1, 1), transparentBlue);
surface->getCanvas()->drawRect(SkRect::MakeXYWH(1, 1, 1, 1),
transparentBlack);
return surface->makeImageSnapshot();
}
TEST_F(CanvasAsyncBlobCreatorTest, ColorManagedConvertToBlob) {
std::list<std::pair<sk_sp<SkColorSpace>, SkColorType>> color_space_params;
color_space_params.push_back(std::pair<sk_sp<SkColorSpace>, SkColorType>(
SkColorSpace::MakeSRGB(), kN32_SkColorType));
color_space_params.push_back(std::pair<sk_sp<SkColorSpace>, SkColorType>(
SkColorSpace::MakeSRGBLinear(), kRGBA_F16_SkColorType));
color_space_params.push_back(std::pair<sk_sp<SkColorSpace>, SkColorType>(
SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear,
SkNamedGamut::kDisplayP3),
kRGBA_F16_SkColorType));
color_space_params.push_back(std::pair<sk_sp<SkColorSpace>, SkColorType>(
SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear, SkNamedGamut::kRec2020),
kRGBA_F16_SkColorType));
color_space_params.push_back(std::pair<sk_sp<SkColorSpace>, SkColorType>(
nullptr, kRGBA_F16_SkColorType));
color_space_params.push_back(
std::pair<sk_sp<SkColorSpace>, SkColorType>(nullptr, kN32_SkColorType));
std::list<String> blob_mime_types = {"image/png", "image/webp", "image/jpeg"};
std::list<String> blob_color_spaces = {kSRGBImageColorSpaceName,
kDisplayP3ImageColorSpaceName,
kRec2020ImageColorSpaceName};
std::list<String> blob_pixel_formats = {
kRGBA8ImagePixelFormatName,
kRGBA16ImagePixelFormatName,
};
// Maximum differences are both observed locally with
// kRGBA16ImagePixelFormatName, kSRGBImageColorSpaceName and nil input color
// space
const unsigned uint8_color_tolerance = 3;
const float f16_color_tolerance = 0.015;
for (auto color_space_param : color_space_params) {
for (auto blob_mime_type : blob_mime_types) {
for (auto blob_color_space : blob_color_spaces) {
for (auto blob_pixel_format : blob_pixel_formats) {
// Create the StaticBitmapImage in canvas_color_space
sk_sp<SkImage> source_image = DrawAndReturnImage(color_space_param);
scoped_refptr<StaticBitmapImage> source_bitmap_image =
UnacceleratedStaticBitmapImage::Create(source_image);
// Prepare encoding options
ImageEncodeOptions* options = ImageEncodeOptions::Create();
options->setQuality(1);
options->setType(blob_mime_type);
options->setColorSpace(blob_color_space);
options->setPixelFormat(blob_pixel_format);
// Encode the image using CanvasAsyncBlobCreator
auto* async_blob_creator =
MakeGarbageCollected<CanvasAsyncBlobCreator>(
source_bitmap_image, options,
CanvasAsyncBlobCreator::ToBlobFunctionType::
kHTMLCanvasConvertToBlobPromise,
base::TimeTicks(), GetFrame().DomWindow(), 0, nullptr);
ASSERT_TRUE(async_blob_creator->EncodeImageForConvertToBlobTest());
sk_sp<SkData> sk_data = SkData::MakeWithCopy(
async_blob_creator->GetEncodedImageForConvertToBlobTest().data(),
async_blob_creator->GetEncodedImageForConvertToBlobTest().size());
sk_sp<SkImage> decoded_img = SkImage::MakeFromEncoded(sk_data);
sk_sp<SkColorSpace> expected_color_space =
CanvasAsyncBlobCreator::BlobColorSpaceToSkColorSpace(
blob_color_space);
SkColorType expected_color_type =
(blob_pixel_format == kRGBA8ImagePixelFormatName)
? kN32_SkColorType
: kRGBA_F16_SkColorType;
scoped_refptr<StaticBitmapImage> ref_bitmap =
source_bitmap_image->ConvertToColorSpace(expected_color_space,
expected_color_type);
sk_sp<SkImage> ref_image =
ref_bitmap->PaintImageForCurrentFrame().GetSwSkImage();
// Jpeg does not support transparent images.
bool compare_alpha = (blob_mime_type != "image/jpeg");
ASSERT_TRUE(ColorCorrectionTestUtils::MatchSkImages(
ref_image, decoded_img, uint8_color_tolerance,
f16_color_tolerance, compare_alpha));
}
}
}
}
}
} // namespace blink
| 41.937313 | 91 | 0.705246 | zealoussnow |
a34280ac3c7c8c2366bb0a8a2bafa26677fb2624 | 5,349 | cpp | C++ | GPRO-Graphics1/project/VisualStudio/GPRO-Graphics1/rawdata.cpp | rmMinusR/GPR-200 | 344d983a1a9cc9c1d2468cc2502a403e793eddf9 | [
"Apache-2.0"
] | null | null | null | GPRO-Graphics1/project/VisualStudio/GPRO-Graphics1/rawdata.cpp | rmMinusR/GPR-200 | 344d983a1a9cc9c1d2468cc2502a403e793eddf9 | [
"Apache-2.0"
] | null | null | null | GPRO-Graphics1/project/VisualStudio/GPRO-Graphics1/rawdata.cpp | rmMinusR/GPR-200 | 344d983a1a9cc9c1d2468cc2502a403e793eddf9 | [
"Apache-2.0"
] | null | null | null | #include "rawdata.hpp"
/*
Copyright 2020 Robert S. Christensen
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
rawdata.cpp
Contains basic boilerplate data types such as float4 and int3. All member
variables are given deliberately vague names, which are accessed by
reference as RGB or XYZ in children.
These are loosely based on:
- `vec3` by Dan Buckstein in his starter framework
- `vec3` by Peter Shirley in `Ray Tracing in One Weekend`
- `Vector3` by myself, in `rm's Bukkit Common API` (private codebase available upon request)
- `Vector` and `Quaternion` by Unity Technologies
*/
#pragma region int3
//Data IO
int3::int3(int _x, int _y, int _z) : val0(_x), val1(_y), val2(_z)
{ }
int3::int3(float _x, float _y, float _z) : int3((int)_x, (int)_y, (int)_z)
{ }
int3::int3(const int3& cpy) : val0(cpy.val0), val1(cpy.val1), val2(cpy.val2)
{ }
int3& int3::operator=(const int3& rhs)
{
this->val0 = rhs.val0;
this->val1 = rhs.val1;
this->val2 = rhs.val2;
return *this;
}
int3& int3::operator+=(const int3& rhs) { return *this = *this + rhs; }
int3& int3::operator-=(const int3& rhs) { return *this = *this - rhs; }
int3& int3::operator*=(const float& rhs) { return *this = *this * rhs; }
int3& int3::operator/=(const float& rhs) { return *this = *this / rhs; }
//Math operators
inline int3 int3::operator+(const int3& rhs) const
{
return int3(this->val0 + rhs.val0, this->val1 + rhs.val1, this->val2 + rhs.val2);
}
inline int3 int3::operator-(const int3& rhs) const
{
return int3(this->val0 - rhs.val0, this->val1 - rhs.val1, this->val2 - rhs.val2);
}
inline int3 int3::operator*(const float& rhs) const
{
return int3(this->val0 * rhs, this->val1 * rhs, this->val2 * rhs);
}
//Allows float*int3 as well
int3 operator*(const float& lhs, const int3& rhs) { return rhs * lhs; }
inline int3 int3::operator/(const float& rhs) const
{
return int3(this->val0 / rhs, this->val1 / rhs, this->val2 / rhs);
}
#pragma endregion int3
#pragma region float3
//Data IO
float3::float3(float _x, float _y, float _z) : val0(_x), val1(_y), val2(_z)
{ }
float3::float3(const float3& cpy) : val0(cpy.val0), val1(cpy.val1), val2(cpy.val2)
{ }
float3& float3::operator=(const float3& rhs)
{
this->val0 = rhs.val0;
this->val1 = rhs.val1;
this->val2 = rhs.val2;
return *this;
}
float3& float3::operator+=(const float3& rhs) { return *this = *this + rhs; }
float3& float3::operator-=(const float3& rhs) { return *this = *this - rhs; }
float3& float3::operator*=(const float& rhs) { return *this = *this * rhs; }
float3& float3::operator/=(const float& rhs) { return *this = *this / rhs; }
//Math operators
inline float3 float3::operator-() const
{
return float3(-val0, -val1, -val2);
}
inline float3 float3::operator+(const float3& rhs) const
{
return float3(this->val0 + rhs.val0, this->val1 + rhs.val1, this->val2 + rhs.val2);
}
inline float3 float3::operator-(const float3& rhs) const
{
return float3(this->val0 - rhs.val0, this->val1 - rhs.val1, this->val2 - rhs.val2);
}
inline float3 float3::operator*(const float& rhs) const
{
return float3(this->val0 * rhs, this->val1 * rhs, this->val2 * rhs);
}
//Allows float*float3 as well
float3 operator*(const float& lhs, const float3& rhs) { return rhs * lhs; }
inline float3 float3::operator/(const float& rhs) const
{
return float3(this->val0 / rhs, this->val1 / rhs, this->val2 / rhs);
}
#pragma endregion float3
#pragma region float4
//Data IO
float4::float4(float _w, float _x, float _y, float _z) : val0(_w), val1(_x), val2(_y), val3(_z)
{ }
float4::float4(const float4& cpy) : val0(cpy.val0), val1(cpy.val1), val2(cpy.val2), val3(cpy.val3)
{ }
float4& float4::operator=(const float4& rhs)
{
this->val1 = rhs.val1;
this->val2 = rhs.val2;
this->val3 = rhs.val3;
return *this;
}
float4& float4::operator+=(const float4& rhs) { return *this = *this + rhs; }
float4& float4::operator-=(const float4& rhs) { return *this = *this - rhs; }
float4& float4::operator*=(const float& rhs) { return *this = *this * rhs; }
float4& float4::operator/=(const float& rhs) { return *this = *this / rhs; }
//Math operators
inline float4 float4::operator+(const float4& rhs) const
{
return float4(this->val0+rhs.val0, this->val1+rhs.val1, this->val2+rhs.val2, this->val3+rhs.val3);
}
inline float4 float4::operator-(const float4& rhs) const
{
return float4(this->val0-rhs.val0, this->val1-rhs.val1, this->val2-rhs.val2, this->val3-rhs.val3);
}
inline float4 float4::operator*(const float& rhs) const
{
return float4(this->val0 * rhs, this->val1 * rhs, this->val2 * rhs, this->val3 * rhs);
}
//Allows float*float4 as well
float4 operator*(const float& lhs, const float4& rhs) { return rhs * lhs; }
inline float4 float4::operator/(const float& rhs) const
{
return float4(this->val0 / rhs, this->val1 / rhs, this->val2 / rhs, this->val3 / rhs);
}
#pragma endregion float4 | 28.301587 | 99 | 0.688353 | rmMinusR |
a3436cb729345b7c760389e6c291409493bda0d6 | 5,570 | cc | C++ | paddle/fluid/operators/sequence_ops/sequence_mask_op_npu.cc | Li-fAngyU/Paddle | e548f65f96697830035a28f9070b40829408ccdb | [
"Apache-2.0"
] | 11 | 2016-08-29T07:43:26.000Z | 2016-08-29T07:51:24.000Z | paddle/fluid/operators/sequence_ops/sequence_mask_op_npu.cc | Li-fAngyU/Paddle | e548f65f96697830035a28f9070b40829408ccdb | [
"Apache-2.0"
] | 1 | 2022-01-28T07:23:22.000Z | 2022-01-28T07:23:22.000Z | paddle/fluid/operators/sequence_ops/sequence_mask_op_npu.cc | Li-fAngyU/Paddle | e548f65f96697830035a28f9070b40829408ccdb | [
"Apache-2.0"
] | 1 | 2022-03-02T11:36:03.000Z | 2022-03-02T11:36:03.000Z | /* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
#include "paddle/fluid/operators/sequence_ops/sequence_mask_op.h"
#include "paddle/fluid/platform/device/npu/npu_op_runner.h"
namespace paddle {
namespace operators {
using Tensor = framework::Tensor;
template <typename DeviceContext, typename T>
class SequenceMaskNPUKernel : public framework::OpKernel<T> {
public:
void Compute(const framework::ExecutionContext& ctx) const override {
auto& dev_ctx = ctx.template device_context<DeviceContext>();
auto* x = ctx.Input<Tensor>("X");
auto* y = ctx.Output<Tensor>("Y");
int maxlen = ctx.Attr<int>("maxlen");
if (ctx.HasInput("MaxLenTensor")) {
auto max_len_tensor = ctx.Input<Tensor>("MaxLenTensor");
PADDLE_ENFORCE_NOT_NULL(max_len_tensor,
platform::errors::InvalidArgument(
"Input(MaxLenTensor) should not be NULL."
"But received Input(MaxLenTensor) is NULL"));
framework::Tensor temp;
paddle::framework::TensorCopySync(*max_len_tensor, platform::CPUPlace(),
&temp);
maxlen = *temp.data<int32_t>();
PADDLE_ENFORCE_GT(
maxlen, 0,
platform::errors::InvalidArgument(
"Input(MaxLenTensor) value should be greater than 0. But "
"received Input(MaxLenTensor) value = %d.",
maxlen));
}
if (maxlen < 0) {
auto x_numel = x->numel();
std::vector<T> x_vec;
framework::TensorToVector(*x, dev_ctx, &x_vec);
auto x_data = x_vec.data();
maxlen = static_cast<int>(*std::max_element(x_data, x_data + x_numel));
}
auto y_dim = phi::vectorize<int>(x->dims());
y_dim.push_back(maxlen);
Tensor cast_x;
cast_x.mutable_data<int32_t>(x->dims(), ctx.GetPlace());
const auto& cast1_runner = NpuOpRunner(
"Cast", {*x}, {cast_x},
{{"dst_type",
ConvertToNpuDtype(framework::TransToProtoVarType(cast_x.dtype()))}});
cast1_runner.Run(dev_ctx.stream());
Tensor tmp;
tmp.mutable_data<int32_t>(phi::make_ddim({maxlen}), ctx.GetPlace());
NpuOpRunner range_runner;
range_runner.SetType("Range");
range_runner.AddInput(std::vector<int32_t>({0}));
range_runner.AddInput(std::vector<int32_t>({maxlen}));
range_runner.AddInput(std::vector<int32_t>({1}));
range_runner.AddOutput(tmp);
range_runner.Run(dev_ctx.stream());
Tensor expand_tmp;
expand_tmp.mutable_data<int32_t>(phi::make_ddim(y_dim), ctx.GetPlace());
const auto& expand_runner =
NpuOpRunner("ExpandD", {tmp}, {expand_tmp}, {{"shape", y_dim}});
expand_runner.Run(dev_ctx.stream());
auto x_dims = phi::vectorize<int>(x->dims());
x_dims.push_back(1);
cast_x.Resize(phi::make_ddim({x_dims}));
Tensor x_tmp;
x_tmp.mutable_data<int32_t>(phi::make_ddim(y_dim), ctx.GetPlace());
const auto& tile_runner =
NpuOpRunner("TileWithAxis", {cast_x}, {x_tmp},
{{"axis", x->dims().size()}, {"tiles", maxlen}});
tile_runner.Run(dev_ctx.stream());
Tensor y_tmp;
y_tmp.mutable_data<uint8_t>(phi::make_ddim(y_dim), ctx.GetPlace());
const auto& less_runner =
NpuOpRunner("Less", {expand_tmp, x_tmp}, {y_tmp}, {});
less_runner.Run(dev_ctx.stream());
y->Resize(phi::make_ddim(y_dim));
auto out_dtype = static_cast<framework::proto::VarType::Type>(
ctx.Attr<int>("out_dtype"));
if (out_dtype == framework::proto::VarType::INT32) {
y->mutable_data<int32_t>(ctx.GetPlace());
} else if (out_dtype == framework::proto::VarType::INT64) {
y->mutable_data<int64_t>(ctx.GetPlace());
} else if (out_dtype == framework::proto::VarType::FP32) {
y->mutable_data<float>(ctx.GetPlace());
} else if (out_dtype == framework::proto::VarType::FP64) {
y->mutable_data<double>(ctx.GetPlace());
} else if (out_dtype == framework::proto::VarType::BOOL) {
y->mutable_data<bool>(ctx.GetPlace());
} else if (out_dtype == framework::proto::VarType::UINT8) {
y->mutable_data<uint8_t>(ctx.GetPlace());
} else {
PADDLE_ENFORCE(false,
platform::errors::InvalidArgument(
"out_dtype only supporing int32, int64, fp32, fp64, "
"bool, uint8, but receive out_dtype is %d",
out_dtype));
}
const auto& cast2_runner = NpuOpRunner(
"Cast", {y_tmp}, {*y}, {{"dst_type", ConvertToNpuDtype(out_dtype)}});
cast2_runner.Run(dev_ctx.stream());
}
};
} // namespace operators
} // namespace paddle
namespace ops = paddle::operators;
namespace plat = paddle::platform;
REGISTER_OP_NPU_KERNEL(
sequence_mask, ops::SequenceMaskNPUKernel<plat::NPUDeviceContext, int32_t>,
ops::SequenceMaskNPUKernel<plat::NPUDeviceContext, int64_t>,
ops::SequenceMaskNPUKernel<plat::NPUDeviceContext, float>,
ops::SequenceMaskNPUKernel<plat::NPUDeviceContext, double>);
| 39.785714 | 79 | 0.64991 | Li-fAngyU |
a34487532423d0ad62efb8a88d7810da5956de9b | 8,948 | cpp | C++ | cpp/src/meshmatchcommand.cpp | luckylyk/cfxnodes | e787eb1974566ffc5f92976685cc3e1f2389839a | [
"BSD-3-Clause-Clear"
] | 1 | 2020-06-27T07:11:35.000Z | 2020-06-27T07:11:35.000Z | cpp/src/meshmatchcommand.cpp | luckylyk/cfxnodes | e787eb1974566ffc5f92976685cc3e1f2389839a | [
"BSD-3-Clause-Clear"
] | null | null | null | cpp/src/meshmatchcommand.cpp | luckylyk/cfxnodes | e787eb1974566ffc5f92976685cc3e1f2389839a | [
"BSD-3-Clause-Clear"
] | null | null | null |
#include "commands.h"
#include <maya/MGlobal.h>
#include <maya/MObject.h>
#include <maya/MPlugArray.h>
#include <maya/MDGModifier.h>
#include <maya/MSyntax.h>
#include <maya/MPlug.h>
#include <maya/MSelectionList.h>
#include <maya/MDagPath.h>
#include <maya/MArgList.h>
#include <maya/MArgParser.h>
MeshMatchCommand::MeshMatchCommand() {}
MeshMatchCommand::~MeshMatchCommand() {}
void* MeshMatchCommand::creator() {return new MeshMatchCommand();}
MString MeshMatchCommand::name("meshMatch");
void checkArgsSanity(
const MArgList & argList,
MArgParser & argParser,
MString & meshMatchNodeName,
MStatus & status) {
if (argParser.numberOfFlagsUsed() > 1) {
status = MS::kInvalidParameter;
MString msg("meshMatch doesn't support multi-flag usage.");
MGlobal::displayError(msg);
return;}
if (argParser.numberOfFlagsUsed() == 0) {
MStringArray objects;
argParser.getObjects(objects);
if (objects.length() < 2) {
status = MS::kInvalidParameter;
MString msg(
"No enough objects providen.\n At least 2 geometries "
"must be selected or passed as argument when the command is "
"used without any flag or");
MGlobal::displayError(msg);
return;}}
if (argParser.isFlagSet("updateBinding") == true) {
meshMatchNodeName = argParser.flagArgumentString("updateBinding", 0);
if (argList.length() != 0){
status = MS::kInvalidParameter;
MString msg(
"meshMatch command doesn't support argument with flag "
"-updateBinding");
MGlobal::displayError(msg);
return;}}
if (argParser.isFlagSet("addGeometryDriver") == true) {
meshMatchNodeName = argParser.flagArgumentString("addGeometryDriver", 0);
if (argList.length() == 0){
status = MS::kInvalidParameter;
MString msg(
"meshMatch need at least one geometry argument with "
"flag addGeometryDriver");
MGlobal::displayError(msg);
return;}}
if (argParser.isFlagSet("removeGeometryDriver") == true) {
meshMatchNodeName = argParser.flagArgumentString("removeGeometryDriver", 0);
if (argList.length() == 0){
status = MS::kInvalidParameter;
MString msg(
"meshMatch need at least one geometry argument with flag "
"removeGeometryDriver");
MGlobal::displayError(msg);
return;}}
return;
}
MStatus toDependecyNode(
const MString & nodeName,
MObject & mobject,
MStatus status){
MSelectionList nodelist;
status = nodelist.add(nodeName);
if (status != MS::kSuccess) {
MGlobal::displayError(nodeName + " doesn't exists");}
CHECK_MSTATUS_AND_RETURN_IT(status);
MDagPath dagPath;
nodelist.getDagPath(0, dagPath);
dagPath.extendToShape();
MObject oDependNode(dagPath.node());
mobject = oDependNode;
return status;
}
MStatus isNodeType(
const MString & nodeName,
const MString & nodeType,
MStatus & status){
MObject oDependNode;
toDependecyNode(nodeName, oDependNode, status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MFnDependencyNode fnDagNode(oDependNode);
if (fnDagNode.typeName() != nodeType) {
MString msg(
nodeName + " must be a " + nodeType +
" node but is " + fnDagNode.typeName());
MGlobal::displayInfo(msg);
status = MS::kInvalidParameter;}
return status;
}
void getSelectedMeshes(MStringArray & geometries, MStatus & status) {
MSelectionList sel;
MGlobal::getActiveSelectionList(sel);
MStringArray selections;
sel.getSelectionStrings(selections);
bool isMesh;
for (unsigned int i(0); i < selections.length(); ++i) {
isMesh = isNodeType(selections[i], "mesh", status);
if (isMesh == true) {
geometries.append(selections[i]);}}
return;
}
unsigned int findNextFreeLogicalIndex(
MPlug const & plugArray,
unsigned int index) {
MPlug child;
while (true) {
child = plugArray.elementByLogicalIndex(index);
if (child.isConnected() == false) {
return index;}
index += 1;}
return index;
}
void addGeometriesToMeshMatch(
const MStringArray & geometries,
const MString & meshMatchName,
MStatus & status) {
MDGModifier modifier;
MPlug dstPlug;
MPlug srcPlug;
MPlug pMeshes;
MSelectionList sel;
sel.add(meshMatchName + ".meshes");
sel.getPlug(0, pMeshes);
unsigned int plugChildIndex(0);
for (unsigned int i(0); i < geometries.length(); ++i) {
MString geometry(geometries[i]);
MObject oGeometry;
toDependecyNode(geometry, oGeometry, status);
plugChildIndex = findNextFreeLogicalIndex(pMeshes, plugChildIndex);
MFnDependencyNode fnDepNodeGeometry(oGeometry);
srcPlug = fnDepNodeGeometry.findPlug("outMesh", status);
dstPlug = pMeshes.elementByLogicalIndex(plugChildIndex);
status = modifier.connect(srcPlug, dstPlug);
plugChildIndex += 1;}
status = modifier.doIt();
return;
}
void removeGeometriesToMeshMatch(
const MStringArray & geometries,
const MString meshMatchName,
MStatus & status) {
MDGModifier modifier;
MPlug pMeshes;
MPlug dstPlug;
MPlug srcPlug;
MSelectionList sel;
sel.add(meshMatchName + ".meshes");
sel.getPlug(0, pMeshes);
for (unsigned int i(0); i < geometries.length(); ++i) {
MString geometry(geometries[i]);
MObject oGeometry;
toDependecyNode(geometry, oGeometry, status);
MFnDependencyNode fnDepNodeGeometry(oGeometry);
srcPlug = fnDepNodeGeometry.findPlug("outMesh");
for (unsigned int j(0); j < pMeshes.numElements(); ++j) {
dstPlug = pMeshes.elementByLogicalIndex(j);
MPlugArray connections;
connections.append(dstPlug);
srcPlug.connectedTo(connections, false, true);
for (unsigned int k(0); k < connections.length(); ++k) {
if (dstPlug.name() == connections[k].name()) {
modifier.disconnect(srcPlug, dstPlug);
modifier.doIt();}}}}
}
MString createMeshMatchs(const MString & target, MStatus & status) {
MString command;
command += "deformer -type meshMatch " + target;
MStringArray result;
MGlobal::executeCommand(command, result);
return result[0];
}
MStatus checksNodesTypesSanity(
const MStringArray & geometries,
MStatus & status){
for (unsigned int i(0); i < geometries.length(); ++i){
MString geometry(geometries[i]);
isNodeType(geometry, "mesh", status);
CHECK_MSTATUS_AND_RETURN_IT(status);}
return status;
}
MStatus MeshMatchCommand::doIt(const MArgList & args) {
MStatus status;
MArgParser argParser(syntax(), args, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MString meshMatchNodeName;
checkArgsSanity(args, argParser, meshMatchNodeName, status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MStringArray geometries;
argParser.getObjects(geometries);
if (geometries.length() == 0) {
getSelectedMeshes(geometries, status);
CHECK_MSTATUS_AND_RETURN_IT(status);}
checksNodesTypesSanity(geometries, status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MString target(geometries[geometries.length() - 1]);
if (argParser.isFlagSet("addGeometryDriver")){
addGeometriesToMeshMatch(geometries, meshMatchNodeName, status);
CHECK_MSTATUS_AND_RETURN_IT(status);}
if (argParser.isFlagSet("removeGeometryDriver")){
removeGeometriesToMeshMatch(geometries, meshMatchNodeName, status);
CHECK_MSTATUS_AND_RETURN_IT(status);}
if (argParser.numberOfFlagsUsed() == 0) {
geometries.remove(geometries.length() - 1);
MString deformer(createMeshMatchs(target, status));
CHECK_MSTATUS_AND_RETURN_IT(status);
addGeometriesToMeshMatch(geometries, deformer, status);
CHECK_MSTATUS_AND_RETURN_IT(status);
setResult(deformer);}
// set node in update mode
MSelectionList sel;
MPlug plug;
sel.add(meshMatchNodeName + ".hasToRebuiltMatches");
sel.getPlug(0, plug);
plug.setValue(true);
return MS::kSuccess;
}
MSyntax MeshMatchCommand::createSyntax(){
MSyntax syntax;
syntax.enableQuery(false);
syntax.enableEdit(false);
syntax.setObjectType(MSyntax::kStringObjects, 0, 1024);
syntax.addFlag("-ub", "-updateBinding", MSyntax::kString);
syntax.addFlag("-add", "-addGeometryDriver", MSyntax::kString);
syntax.addFlag("-rmv", "-removeGeometryDriver", MSyntax::kString);
return syntax;
} | 31.730496 | 84 | 0.646737 | luckylyk |
a3457b0442fff335a3c8296eaef3b44c7f09efd3 | 5,615 | cpp | C++ | Common/util/string_utils.cpp | ericoporto/ags-old | da4f28d7cf700f5256f9b1295ee346e7a3cb39a4 | [
"Artistic-2.0"
] | null | null | null | Common/util/string_utils.cpp | ericoporto/ags-old | da4f28d7cf700f5256f9b1295ee346e7a3cb39a4 | [
"Artistic-2.0"
] | null | null | null | Common/util/string_utils.cpp | ericoporto/ags-old | da4f28d7cf700f5256f9b1295ee346e7a3cb39a4 | [
"Artistic-2.0"
] | null | null | null | //=============================================================================
//
// Adventure Game Studio (AGS)
//
// Copyright (C) 1999-2011 Chris Jones and 2011-20xx others
// The full list of copyright holders can be found in the Copyright.txt
// file, which is part of this source code distribution.
//
// The AGS source code is provided under the Artistic License 2.0.
// A copy of this license can be found in the file License.txt and at
// http://www.opensource.org/licenses/artistic-license-2.0.php
//
//=============================================================================
#include "util/string_utils.h"
#include <errno.h>
#include <string.h>
#include <regex>
#include "core/platform.h"
#include "util/math.h"
#include "util/stream.h"
using namespace AGS::Common;
String cbuf_to_string_and_free(char *char_buf)
{
String s = char_buf;
free(char_buf);
return s;
}
namespace AGS
{
namespace Common
{
String StrUtil::IntToString(int d)
{
return String::FromFormat("%d", d);
}
int StrUtil::StringToInt(const String &s, int def_val)
{
if (!s.GetCStr())
return def_val;
char *stop_ptr;
int val = strtol(s.GetCStr(), &stop_ptr, 0);
return (stop_ptr == s.GetCStr() + s.GetLength()) ? val : def_val;
}
StrUtil::ConversionError StrUtil::StringToInt(const String &s, int &val, int def_val)
{
val = def_val;
if (!s.GetCStr())
return StrUtil::kFailed;
char *stop_ptr;
errno = 0;
long lval = strtol(s.GetCStr(), &stop_ptr, 0);
if (stop_ptr != s.GetCStr() + s.GetLength())
return StrUtil::kFailed;
if (lval > INT_MAX || lval < INT_MIN || errno == ERANGE)
return StrUtil::kOutOfRange;
val = (int)lval;
return StrUtil::kNoError;
}
String StrUtil::WildcardToRegex(const String &wildcard)
{
// https://stackoverflow.com/questions/40195412/c11-regex-search-for-exact-string-escape
// matches any characters that need to be escaped in RegEx
std::regex esc{ R"([-[\]{}()*+?.,\^$|#\s])" };
std::string sanitized = std::regex_replace(wildcard.GetCStr(), esc, R"(\$&)");
// convert (now escaped) wildcard "\\*" and "\\?" into ".*" and "." respectively
String pattern(sanitized.c_str());
pattern.Replace("\\*", ".*");
pattern.Replace("\\?", ".");
return pattern;
}
String StrUtil::Unescape(const String &s)
{
size_t at = s.FindChar('\\');
if (at == -1)
return s; // no unescaping necessary, return original string
char *buf = new char[s.GetLength()];
strncpy(buf, s.GetCStr(), at);
char *pb = buf + at;
for (const char *ptr = s.GetCStr() + at; *ptr; ++ptr)
{
if (*ptr != '\\')
{
*(pb++) = *ptr;
continue;
}
char next = *(++ptr);
switch (next)
{
case 'a': *(pb++) = '\a'; break;
case 'b': *(pb++) = '\b'; break;
case 'f': *(pb++) = '\f'; break;
case 'n': *(pb++) = '\n'; break;
case 'r': *(pb++) = '\r'; break;
case 't': *(pb++) = '\t'; break;
case 'v': *(pb++) = '\v'; break;
case '\\': *(pb++) = '\\'; break;
case '\'': *(pb++) = '\''; break;
case '\"': *(pb++) = '\"'; break;
case '\?': *(pb++) = '\?'; break;
default: *(pb++) = next; break;
}
}
*pb = 0;
String dst(buf);
delete buf;
return dst;
}
String StrUtil::ReadString(Stream *in)
{
size_t len = in->ReadInt32();
if (len > 0)
return String::FromStreamCount(in, len);
return String();
}
void StrUtil::ReadString(char *cstr, Stream *in, size_t buf_limit)
{
size_t len = in->ReadInt32();
if (buf_limit == 0)
{
in->Seek(len);
return;
}
len = Math::Min(len, buf_limit - 1);
if (len > 0)
in->Read(cstr, len);
cstr[len] = 0;
}
void StrUtil::ReadString(String &s, Stream *in)
{
size_t len = in->ReadInt32();
s.ReadCount(in, len);
}
void StrUtil::ReadString(char **cstr, Stream *in)
{
size_t len = in->ReadInt32();
*cstr = new char[len + 1];
if (len > 0)
in->Read(*cstr, len);
(*cstr)[len] = 0;
}
void StrUtil::SkipString(Stream *in)
{
size_t len = in->ReadInt32();
in->Seek(len);
}
void StrUtil::WriteString(const String &s, Stream *out)
{
size_t len = s.GetLength();
out->WriteInt32(len);
if (len > 0)
out->Write(s.GetCStr(), len);
}
void StrUtil::WriteString(const char *cstr, Stream *out)
{
size_t len = strlen(cstr);
out->WriteInt32(len);
if (len > 0)
out->Write(cstr, len);
}
void StrUtil::WriteString(const char *cstr, size_t len, Stream *out)
{
out->WriteInt32(len);
if (len > 0)
out->Write(cstr, len);
}
void StrUtil::ReadCStr(char *buf, Stream *in, size_t buf_limit)
{
if (buf_limit == 0)
{
while (in->ReadByte() > 0);
return;
}
auto ptr = buf;
auto last = buf + buf_limit - 1;
for (;;)
{
if (ptr >= last) {
*ptr = 0;
while (in->ReadByte() > 0); // must still read until 0
break;
}
auto ichar = in->ReadByte();
if (ichar <= 0) {
*ptr = 0;
break;
}
*ptr = static_cast<char>(ichar);
ptr++;
}
}
void StrUtil::SkipCStr(Stream *in)
{
while (in->ReadByte() > 0);
}
void StrUtil::WriteCStr(const char *cstr, Stream *out)
{
size_t len = strlen(cstr);
out->Write(cstr, len + 1);
}
void StrUtil::WriteCStr(const String &s, Stream *out)
{
out->Write(s.GetCStr(), s.GetLength() + 1);
}
} // namespace Common
} // namespace AGS
| 24.202586 | 92 | 0.54016 | ericoporto |
a345e9f06bedd8b5e98b883424725f3ca320c0cc | 4,695 | cpp | C++ | third-party/llvm/llvm-src/tools/sanstats/sanstats.cpp | ram-nad/chapel | 1d4aae17e58699c1481d2b2209c9d1fcd2658fc8 | [
"ECL-2.0",
"Apache-2.0"
] | 15 | 2019-08-05T01:24:20.000Z | 2022-01-12T08:19:55.000Z | third-party/llvm/llvm-src/tools/sanstats/sanstats.cpp | ram-nad/chapel | 1d4aae17e58699c1481d2b2209c9d1fcd2658fc8 | [
"ECL-2.0",
"Apache-2.0"
] | 4 | 2017-12-13T18:19:11.000Z | 2018-11-17T04:37:14.000Z | third-party/llvm/llvm-src/tools/sanstats/sanstats.cpp | ram-nad/chapel | 1d4aae17e58699c1481d2b2209c9d1fcd2658fc8 | [
"ECL-2.0",
"Apache-2.0"
] | 9 | 2019-09-24T06:26:58.000Z | 2021-11-22T08:54:00.000Z | //===- sanstats.cpp - Sanitizer statistics dumper -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This tool dumps statistics information from files in the format produced
// by clang's -fsanitize-stats feature.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/Symbolize/Symbolize.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Transforms/Utils/SanitizerStats.h"
#include <stdint.h>
using namespace llvm;
static cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
cl::desc("<filename>"));
static cl::opt<bool> ClDemangle("demangle", cl::init(false),
cl::desc("Print demangled function name."));
inline uint64_t KindFromData(uint64_t Data, char SizeofPtr) {
return Data >> (SizeofPtr * 8 - kSanitizerStatKindBits);
}
inline uint64_t CountFromData(uint64_t Data, char SizeofPtr) {
return Data & ((1ull << (SizeofPtr * 8 - kSanitizerStatKindBits)) - 1);
}
uint64_t ReadLE(char Size, const char *Begin, const char *End) {
uint64_t Result = 0;
char Pos = 0;
while (Begin < End && Pos != Size) {
Result |= uint64_t(uint8_t(*Begin)) << (Pos * 8);
++Begin;
++Pos;
}
return Result;
}
const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
const char *FilenameBegin = Begin;
while (Begin != End && *Begin)
++Begin;
if (Begin == End)
return nullptr;
std::string Filename(FilenameBegin, Begin - FilenameBegin);
if (!llvm::sys::fs::exists(Filename))
Filename = std::string(llvm::sys::path::parent_path(ClInputFile)) +
std::string(llvm::sys::path::filename(Filename));
++Begin;
if (Begin == End)
return nullptr;
symbolize::LLVMSymbolizer::Options SymbolizerOptions;
SymbolizerOptions.Demangle = ClDemangle;
SymbolizerOptions.UseSymbolTable = true;
symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
while (1) {
uint64_t Addr = ReadLE(SizeofPtr, Begin, End);
Begin += SizeofPtr;
uint64_t Data = ReadLE(SizeofPtr, Begin, End);
Begin += SizeofPtr;
if (Begin > End)
return nullptr;
if (Addr == 0 && Data == 0)
return Begin;
if (Begin == End)
return nullptr;
// As the instrumentation tracks the return address and not
// the address of the call to `__sanitizer_stat_report` we
// remove one from the address to get the correct DI.
if (Expected<DILineInfo> LineInfo =
Symbolizer.symbolizeCode(Filename, Addr - 1)) {
llvm::outs() << format_hex(Addr - 1, 18) << ' ' << LineInfo->FileName
<< ':' << LineInfo->Line << ' ' << LineInfo->FunctionName
<< ' ';
} else {
logAllUnhandledErrors(LineInfo.takeError(), llvm::outs(), "<error> ");
}
switch (KindFromData(Data, SizeofPtr)) {
case SanStat_CFI_VCall:
llvm::outs() << "cfi-vcall";
break;
case SanStat_CFI_NVCall:
llvm::outs() << "cfi-nvcall";
break;
case SanStat_CFI_DerivedCast:
llvm::outs() << "cfi-derived-cast";
break;
case SanStat_CFI_UnrelatedCast:
llvm::outs() << "cfi-unrelated-cast";
break;
case SanStat_CFI_ICall:
llvm::outs() << "cfi-icall";
break;
default:
llvm::outs() << "<unknown>";
break;
}
llvm::outs() << " " << CountFromData(Data, SizeofPtr) << '\n';
}
}
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv,
"Sanitizer Statistics Processing Tool");
ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
MemoryBuffer::getFile(ClInputFile, -1, false);
if (!MBOrErr) {
errs() << argv[0] << ": " << ClInputFile << ": "
<< MBOrErr.getError().message() << '\n';
return 1;
}
std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
const char *Begin = MB->getBufferStart(), *End = MB->getBufferEnd();
if (Begin == End) {
errs() << argv[0] << ": " << ClInputFile << ": short read\n";
return 1;
}
char SizeofPtr = *Begin++;
while (Begin != End) {
Begin = ReadModule(SizeofPtr, Begin, End);
if (Begin == nullptr) {
errs() << argv[0] << ": " << ClInputFile << ": short read\n";
return 1;
}
assert(Begin <= End);
}
}
| 31.510067 | 80 | 0.59148 | ram-nad |
a34603ae7bfd450bdd2c3c02fa6db976542ef4aa | 11,943 | cpp | C++ | src/InterSpecializer.cpp | lahiri-phdworks/OCCAM | 21919b0819606b8f76a391965151fba6df86cee7 | [
"BSD-3-Clause"
] | null | null | null | src/InterSpecializer.cpp | lahiri-phdworks/OCCAM | 21919b0819606b8f76a391965151fba6df86cee7 | [
"BSD-3-Clause"
] | null | null | null | src/InterSpecializer.cpp | lahiri-phdworks/OCCAM | 21919b0819606b8f76a391965151fba6df86cee7 | [
"BSD-3-Clause"
] | null | null | null | //
// OCCAM
//
// Copyright (c) 2011-2020, SRI International
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * Neither the name of SRI International nor the names of its contributors may
// be used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
/**
* Inter-module specialization.
* Interfaces are modified but callsites are not. The callsites will
* be modified by InterRewriter
**/
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/IR/CallSite.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/IPO.h"
#include "Interfaces.h"
#include "SpecializationPolicy.h"
#include "Specializer.h"
/* here specialization policies */
#include "AggressiveSpecPolicy.h"
#include "BoundedSpecPolicy.h"
#include "OnlyOnceSpecPolicy.h"
#include "RecursiveGuardSpecPolicy.h"
#include "llvm/Support/raw_ostream.h"
#include <fstream>
#include <string>
#include <vector>
using namespace llvm;
static cl::opt<previrt::SpecializationPolicyType> SpecPolicy(
"Pspecialize-policy", cl::desc("Inter-module specialization policy"),
cl::values(clEnumValN(previrt::SpecializationPolicyType::NOSPECIALIZE,
"nospecialize", "Skip inter-module specialization"),
clEnumValN(previrt::SpecializationPolicyType::AGGRESSIVE,
"aggressive",
"Specialize always if some constant argument"),
clEnumValN(previrt::SpecializationPolicyType::ONLY_ONCE,
"onlyonce",
"Specialize a function if it is called once"),
clEnumValN(previrt::SpecializationPolicyType::BOUNDED, "bounded",
"Always specialize if number of copies so far <= "
"Ppeval-max-spec-copies"),
clEnumValN(previrt::SpecializationPolicyType::NONREC,
"nonrec-aggressive",
"Specialize always if some constant "
"arg and function is non-recursive")),
cl::init(previrt::SpecializationPolicyType::NONREC));
static cl::opt<unsigned>
MaxSpecCopies("Pspecialize-max-bounded", cl::init(5),
cl::desc("Maximum number of copies for a function if "
"-Pspecialize-policy=bounded"));
static cl::list<std::string>
SpecCompIn("Pspecialize-input", cl::NotHidden,
cl::desc("Specify the interface to specialize with respect to"));
static cl::opt<std::string>
SpecCompOut("Pspecialize-output", cl::init(""), cl::NotHidden,
cl::desc("Specify the output file for the specialized module"));
namespace previrt {
static Function *resolveFunction(Module &M, StringRef name) {
if (Function *f = M.getFunction(name)) {
return f;
}
if (GlobalAlias *ga = M.getNamedAlias(name)) {
const GlobalValue *v = ga->getBaseObject();
if (Function *f = dyn_cast<Function>(const_cast<GlobalValue *>(v))) {
return f;
}
}
return nullptr;
}
/*
* Reduce this module with respect to the given interface.
* - The interface suggests some of the uses of the functions,
* so here we can generate special versions of those functions.
* Generate a ComponentInterfaceTransform for clients to rewrite their
* code to use the new API
*/
static bool SpecializeComponent(Module &M, ComponentInterfaceTransform &T,
SpecializationPolicy &policy,
std::vector<Function *> &to_add) {
errs() << "SpecializeComponent()\n";
if (!T.hasInterface()) {
return false;
}
int rewrite_count = 0;
const ComponentInterface &I = T.getInterface();
// TODO: What needs to be done?
// - Should try to handle strings & arrays
// Iterate through all functions in the interface of T
for (auto fName : llvm::make_range(I.begin(), I.end())) {
Function *func = resolveFunction(M, fName);
if (!func || func->isDeclaration()) {
continue;
}
// Now iterate through all calls to func in the interface of T
for (const CallInfo *call :
llvm::make_range(I.call_begin(fName), I.call_end(fName))) {
const unsigned arg_count = call->num_args();
if (func->isVarArg()) {
continue;
}
if (arg_count != func->arg_size()) {
// Not referring to this function?
// NOTE: I can't assert this equality because of the way that
// approximations occur
continue;
}
/*
should we specialize? if yes then each bit in marks will
indicate whether the argument is a specializable constant
*/
SmallBitVector marks(arg_count);
bool shouldSpecialize =
policy.interSpecializeOn(*func, call->get_args(), I, marks);
if (!shouldSpecialize)
continue;
std::vector<Value *> args;
std::vector<unsigned> argPerm;
args.reserve(arg_count);
argPerm.reserve(marks.count());
for (unsigned i = 0; i < arg_count; i++) {
if (marks.test(i)) {
Type *paramType = func->getFunctionType()->getParamType(i);
Value *concreteArg = call->get_args()[i].concretize(M, paramType);
args.push_back(concreteArg);
assert(concreteArg->getType() == paramType &&
"Specializing function with concrete argument of wrong type!");
} else {
args.push_back(nullptr);
argPerm.push_back(i);
}
}
/*
args is a list of pointers to values
-- if the pointer is nullptr then that argument is not
specialized.
-- if the pointer is not nullptr then the argument will be/has
been specialized to that value.
argsPerm is a list on integers; the indices of the non-special arguments
args[i] = nullptr iff i is in argsPerm for i < arg_count.
*/
Function *specialized_func = specializeFunction(func, args);
if (!specialized_func) {
continue;
}
specialized_func->setLinkage(GlobalValue::ExternalLinkage);
FunctionHandle rewriteTo = specialized_func->getName();
T.rewrite(fName, call, rewriteTo, argPerm);
to_add.push_back(specialized_func);
errs() << "Specialized " << fName << " to " << rewriteTo << "\n";
#if 0
for (unsigned i = 0; i < arg_count; i++) {
errs() << "i = " << i << ": marks[i] = " << marks[i]
<< " args[i] = " << args.at(i) << "\n";
}
errs() << " argPerm = [";
for (unsigned i = 0; i < argPerm.size(); i++) {
errs() << argPerm.at(i) << " ";
}
errs() << "]\n";
#endif
rewrite_count++;
}
}
if (rewrite_count > 0) {
errs() << rewrite_count << " pending rewrites\n";
}
return rewrite_count > 0;
}
} // namespace previrt
namespace previrt {
class InterSpecializerPass : public ModulePass {
public:
ComponentInterfaceTransform transform;
static char ID;
public:
InterSpecializerPass() : ModulePass(ID) {
for (auto fileName : SpecCompIn) {
errs() << "Reading file '" << fileName << "'...";
if (transform.readInterfaceFromFile(fileName)) {
errs() << "success\n";
} else {
errs() << "failed\n";
}
}
}
virtual ~InterSpecializerPass() {}
virtual bool runOnModule(Module &M) {
if (!transform.hasInterface()) {
errs() << "No interfaces read.\n";
return false;
}
errs() << " === Begin inter-module specialization ===\n";
const ComponentInterface &interface = transform.getInterface();
errs() << "Read " << std::distance(interface.begin(), interface.end())
<< "interface entries.\n";
// -- Create the specialization policy. Bail out if no policy.
std::unique_ptr<SpecializationPolicy> policy;
switch (SpecPolicy) {
case SpecializationPolicyType::NOSPECIALIZE:
return false;
case SpecializationPolicyType::AGGRESSIVE:
policy.reset(new AggressiveSpecPolicy());
break;
case SpecializationPolicyType::BOUNDED: {
std::unique_ptr<SpecializationPolicy> subpolicy =
std::make_unique<AggressiveSpecPolicy>();
policy.reset(
new BoundedSpecPolicy(M, std::move(subpolicy), MaxSpecCopies));
break;
}
case SpecializationPolicyType::ONLY_ONCE:
policy.reset(new OnlyOnceSpecPolicy());
break;
case SpecializationPolicyType::NONREC: {
std::unique_ptr<SpecializationPolicy> subpolicy =
std::make_unique<AggressiveSpecPolicy>();
CallGraph &cg = getAnalysis<CallGraphWrapperPass>().getCallGraph();
policy.reset(new RecursiveGuardSpecPolicy(std::move(subpolicy), cg));
break;
}
default:;
;
}
if (!policy) {
return false;
}
std::vector<Function *> to_add;
bool modified = SpecializeComponent(M, transform, *policy, to_add);
/*
adding the "new" specialized definitions (in to_add) to M;
opt will write out M to the -o argument to the "python call"
*/
unsigned specialized_functions = 0;
Module::FunctionListType &functionList = M.getFunctionList();
while (!to_add.empty()) {
Function *add = to_add.back();
to_add.pop_back();
if (add->getParent() == &M) {
// Already in module
continue;
} else {
errs() << "Adding \"" << add->getName() << "\" to the module.\n";
functionList.push_back(add);
specialized_functions++;
}
}
/* writing the output ("rw" rewrite file) to the -Pspecialize-output
* argument */
if (SpecCompOut != "") {
proto::ComponentInterfaceTransform buf;
codeInto(this->transform, buf);
std::ofstream output(SpecCompOut.c_str(),
std::ios::binary | std::ios::trunc);
bool success = buf.SerializeToOstream(&output);
if (!success) {
assert(false && "failed to write out interface");
}
output.close();
}
if (modified) {
errs() << "Specialized " << specialized_functions << "\n";
} else {
errs() << "No specialization took place\n";
}
errs() << " === End inter-module specialization ===\n";
return modified;
}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<CallGraphWrapperPass>();
}
};
char InterSpecializerPass::ID;
} // end namespace previrt
static RegisterPass<previrt::InterSpecializerPass>
X("Pspecialize", "Specialize the inter-module interface", false, false);
| 34.22063 | 80 | 0.640375 | lahiri-phdworks |
a3463162d276cd6939765756213471db6d2a1cb8 | 2,873 | cc | C++ | paddle/fluid/distributed/test/graph_table_sample_test.cc | L-Net-1992/Paddle | 4d0ca02ba56760b456f3d4b42a538555b9b6c307 | [
"Apache-2.0"
] | 11 | 2016-08-29T07:43:26.000Z | 2016-08-29T07:51:24.000Z | paddle/fluid/distributed/test/graph_table_sample_test.cc | L-Net-1992/Paddle | 4d0ca02ba56760b456f3d4b42a538555b9b6c307 | [
"Apache-2.0"
] | null | null | null | paddle/fluid/distributed/test/graph_table_sample_test.cc | L-Net-1992/Paddle | 4d0ca02ba56760b456f3d4b42a538555b9b6c307 | [
"Apache-2.0"
] | 1 | 2021-09-24T11:23:36.000Z | 2021-09-24T11:23:36.000Z | // Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <unistd.h>
#include <chrono>
#include <condition_variable> // NOLINT
#include <fstream>
#include <iomanip>
#include <string>
#include <thread> // NOLINT
#include <unordered_set>
#include <vector>
#include "google/protobuf/text_format.h"
#include "gtest/gtest.h"
#include "paddle/fluid/distributed/ps.pb.h"
#include "paddle/fluid/distributed/ps/table/common_graph_table.h"
namespace framework = paddle::framework;
namespace platform = paddle::platform;
namespace operators = paddle::operators;
namespace memory = paddle::memory;
namespace distributed = paddle::distributed;
std::vector<std::string> edges = {
std::string("37\t45\t0.34"), std::string("37\t145\t0.31"),
std::string("37\t112\t0.21"), std::string("96\t48\t1.4"),
std::string("96\t247\t0.31"), std::string("96\t111\t1.21"),
std::string("59\t45\t0.34"), std::string("59\t145\t0.31"),
std::string("59\t122\t0.21"), std::string("97\t48\t0.34"),
std::string("97\t247\t0.31"), std::string("97\t111\t0.21")};
// odd id:96 48 122 112
char edge_file_name[] = "edges.txt";
std::vector<std::string> nodes = {
std::string("user\t37\ta 0.34\tb 13 14\tc hello\td abc"),
std::string("user\t96\ta 0.31\tb 15 10\tc 96hello\td abcd"),
std::string("user\t59\ta 0.11\tb 11 14"),
std::string("user\t97\ta 0.11\tb 12 11"),
std::string("item\t45\ta 0.21"),
std::string("item\t145\ta 0.21"),
std::string("item\t112\ta 0.21"),
std::string("item\t48\ta 0.21"),
std::string("item\t247\ta 0.21"),
std::string("item\t111\ta 0.21"),
std::string("item\t46\ta 0.21"),
std::string("item\t146\ta 0.21"),
std::string("item\t122\ta 0.21"),
std::string("item\t49\ta 0.21"),
std::string("item\t248\ta 0.21"),
std::string("item\t113\ta 0.21")};
char node_file_name[] = "nodes.txt";
void prepare_file(char file_name[], std::vector<std::string> data) {
std::ofstream ofile;
ofile.open(file_name);
for (auto x : data) {
ofile << x << std::endl;
}
ofile.close();
}
void testGraphSample() {
::paddle::distributed::GraphParameter table_proto;
// table_proto.set_gpu_num(2);
distributed::GraphTable graph_table;
graph_table.Initialize(table_proto);
}
TEST(testGraphSample, Run) { testGraphSample(); }
| 34.202381 | 75 | 0.680125 | L-Net-1992 |
a3473bbf7894fff710247f02a76abb18b89428f5 | 1,458 | cc | C++ | vendor/chromium/base/metrics/bucket_ranges.cc | thorium-cfx/fivem | 587eb7c12066a2ebf8631bde7bb39ee2df1b5a0c | [
"MIT"
] | 5,411 | 2017-04-14T08:57:56.000Z | 2022-03-30T19:35:15.000Z | vendor/chromium/base/metrics/bucket_ranges.cc | thorium-cfx/fivem | 587eb7c12066a2ebf8631bde7bb39ee2df1b5a0c | [
"MIT"
] | 802 | 2017-04-21T14:18:36.000Z | 2022-03-31T21:20:48.000Z | vendor/chromium/base/metrics/bucket_ranges.cc | thorium-cfx/fivem | 587eb7c12066a2ebf8631bde7bb39ee2df1b5a0c | [
"MIT"
] | 2,011 | 2017-04-14T09:44:15.000Z | 2022-03-31T15:40:39.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/metrics/bucket_ranges.h"
#include <cmath>
#include "base/logging.h"
#include "base/metrics/crc32.h"
namespace base {
BucketRanges::BucketRanges(size_t num_ranges)
: ranges_(num_ranges, 0),
checksum_(0) {}
BucketRanges::~BucketRanges() = default;
uint32_t BucketRanges::CalculateChecksum() const {
// Crc of empty ranges_ happens to be 0. This early exit prevents trying to
// take the address of ranges_[0] which will fail for an empty vector even
// if that address is never used.
const size_t ranges_size = ranges_.size();
if (ranges_size == 0)
return 0;
// Checksum is seeded with the ranges "size".
return Crc32(static_cast<uint32_t>(ranges_size), &ranges_[0],
sizeof(ranges_[0]) * ranges_size);
}
bool BucketRanges::HasValidChecksum() const {
return CalculateChecksum() == checksum_;
}
void BucketRanges::ResetChecksum() {
checksum_ = CalculateChecksum();
}
bool BucketRanges::Equals(const BucketRanges* other) const {
if (checksum_ != other->checksum_)
return false;
if (ranges_.size() != other->ranges_.size())
return false;
for (size_t index = 0; index < ranges_.size(); ++index) {
if (ranges_[index] != other->ranges_[index])
return false;
}
return true;
}
} // namespace base
| 27 | 77 | 0.697531 | thorium-cfx |
a348a44569e0006e2e267cf88baebecdb96cc484 | 1,610 | cpp | C++ | src/unittests/escaped_string_test.cpp | puremourning/netcoredbg | c34eaef68abe06197d03bc8c19282707cfc1adda | [
"MIT"
] | null | null | null | src/unittests/escaped_string_test.cpp | puremourning/netcoredbg | c34eaef68abe06197d03bc8c19282707cfc1adda | [
"MIT"
] | null | null | null | src/unittests/escaped_string_test.cpp | puremourning/netcoredbg | c34eaef68abe06197d03bc8c19282707cfc1adda | [
"MIT"
] | null | null | null | // Copyright (C) 2021 Samsung Electronics Co., Ltd.
// See the LICENSE file in the project root for more information.
#include <catch2/catch.hpp>
#include <string>
#include "string_view.h"
#include "utils/escaped_string.h"
#include "compile_test.h"
using namespace netcoredbg;
using string_view = Utility::string_view;
struct EscapeRules
{
static const char forbidden_chars[];
static const char subst_chars[];
static const char constexpr escape_char = '\\';
};
const char EscapeRules::forbidden_chars[] = "\"\\\0\a\b\f\n\r\t\v";
const char EscapeRules::subst_chars[] = "\"\\0abfnrtv";
using ES = EscapedString<EscapeRules>;
TEST_CASE("EscapedString")
{
string_view s1 { "test12345" };
string_view s2 { "test\n" };
// assuming no copying
CHECK(static_cast<string_view>(ES(s1)) == s1);
const void *v1, *v2;
v1 = static_cast<string_view>(ES(s1)).data(), v2 = s1.data();
CHECK(v1 == v2);
ES es1(s1); // expecting copying
CHECK(static_cast<string_view>(es1) == s1);
v1 = static_cast<string_view>(es1).data(), v2 = s1.data();
CHECK(v1 != v2);
CHECK(static_cast<string_view>(ES("\n")) == "\\n");
CHECK(static_cast<string_view>(ES("aaa\n")) == "aaa\\n");
CHECK(static_cast<string_view>(ES("\naaa")) == "\\naaa");
CHECK(static_cast<string_view>(ES("aaa\nbbb")) == string_view("aaa\\nbbb", 8));
CHECK(static_cast<string_view>(ES(string_view("aaa\0bbb", 7))) == string_view("aaa\\0bbb", 8));
std::string result;
ES("aaa\nbbb")([&](string_view s) { result.append(s.begin(), s.end()); });
CHECK(result == "aaa\\nbbb");
}
| 30.961538 | 99 | 0.650311 | puremourning |
a34a803e86d6245e370b649a1d72d80213527f4c | 8,973 | cpp | C++ | MMOCoreORB/src/server/zone/managers/skill/SkillModManager.cpp | V-Fib/FlurryClone | 40e0ca7245ec31b3815eb6459329fd9e70f88936 | [
"Zlib",
"OpenSSL"
] | 18 | 2017-02-09T15:36:05.000Z | 2021-12-21T04:22:15.000Z | MMOCoreORB/src/server/zone/managers/skill/SkillModManager.cpp | V-Fib/FlurryClone | 40e0ca7245ec31b3815eb6459329fd9e70f88936 | [
"Zlib",
"OpenSSL"
] | 61 | 2016-12-30T21:51:10.000Z | 2021-12-10T20:25:56.000Z | MMOCoreORB/src/server/zone/managers/skill/SkillModManager.cpp | V-Fib/FlurryClone | 40e0ca7245ec31b3815eb6459329fd9e70f88936 | [
"Zlib",
"OpenSSL"
] | 71 | 2017-01-01T05:34:38.000Z | 2022-03-29T01:04:00.000Z | /*
Copyright <SWGEmu>
See file COPYING for copying conditions.
*/
#include "SkillModManager.h"
#include "server/zone/objects/creature/CreatureObject.h"
#include "server/zone/objects/player/PlayerObject.h"
#include "server/zone/objects/tangible/TangibleObject.h"
#include "server/zone/objects/tangible/weapon/WeaponObject.h"
#include "server/zone/objects/tangible/wearables/WearableObject.h"
#include "server/zone/objects/tangible/wearables/WearableContainerObject.h"
#include "server/zone/objects/structure/StructureObject.h"
#include "server/zone/objects/area/CampSiteActiveArea.h"
SkillModManager::SkillModManager()
: Logger("SkillModManager") {
skillModMin.setNullValue(0);
skillModMax.setNullValue(0);
disabledWearableSkillMods.setNoDuplicateInsertPlan();
init();
}
SkillModManager::~SkillModManager() {
}
void SkillModManager::init() {
Lua* lua = new Lua();
lua->init();
if (!lua->runFile("scripts/managers/skill_mod_manager.lua")) {
error("Cannot read configuration, using default");
setDefaults();
delete lua;
lua = nullptr;
return;
}
LuaObject skillLimits = lua->getGlobalObject("skillModLimits");
if (!skillLimits.isValidTable()) {
error("Invalid configuration");
setDefaults();
} else {
for(int i = 1; i <= skillLimits.getTableSize(); ++i) {
LuaObject entry = skillLimits.getObjectAt(i);
uint32 type = entry.getIntAt(1);
int min = entry.getIntAt(2);
int max = entry.getIntAt(3);
skillModMin.put(type, min);
skillModMax.put(type, max);
entry.pop();
}
skillLimits.pop();
}
LuaObject disabledMods = lua->getGlobalObject("disabledWearableSkillMods");
if (disabledMods.isValidTable()) {
for(int i = 1; i <= disabledMods.getTableSize(); ++i) {
String mod = disabledMods.getStringAt(i);
disabledWearableSkillMods.put(mod);
}
disabledMods.pop();
}
delete lua;
lua = nullptr;
return;
}
void SkillModManager::setDefaults() {
skillModMin.put(WEARABLE, -25);
skillModMax.put(WEARABLE, 25);
skillModMin.put(ABILITYBONUS, -125);
skillModMax.put(ABILITYBONUS, 125);
skillModMin.put(STRUCTURE, -125);
skillModMax.put(STRUCTURE, 125);
skillModMin.put(BUFF, -125);
skillModMax.put(BUFF, 125);
skillModMin.put(DROID, -110);
skillModMax.put(DROID, 110);
}
void SkillModManager::verifyWearableSkillMods(CreatureObject* creature) {
Locker locker(creature);
VectorMap<String, int> mods;
mods.setAllowOverwriteInsertPlan();
mods.setNullValue(0);
SortedVector<ManagedReference<SceneObject*> > usedObjects;
usedObjects.setNoDuplicateInsertPlan();
for(int i = 0; i < creature->getSlottedObjectsSize(); ++i) {
ManagedReference<TangibleObject*> object = creature->getSlottedObject(i).castTo<TangibleObject*>();
if(object == nullptr || usedObjects.contains(object.get()))
continue;
if(object->isWearableObject()) {
WearableObject* wearable = cast<WearableObject*>(object.get());
if(wearable != nullptr) {
const VectorMap<String, int>* wearableSkillMods = wearable->getWearableSkillMods();
for (int j = 0; j < wearableSkillMods->size(); ++j) {
String name = wearableSkillMods->elementAt(j).getKey();
if (isWearableModDisabled(name))
continue;
int value = wearableSkillMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
} else if (object->isWearableContainerObject()) {
WearableContainerObject* wearable = cast<WearableContainerObject*>(object.get());
if(wearable != nullptr) {
const VectorMap<String, int>* wearableSkillMods = wearable->getWearableSkillMods();
for (int j = 0; j < wearableSkillMods->size(); ++j) {
String name = wearableSkillMods->elementAt(j).getKey();
if (isWearableModDisabled(name))
continue;
int value = wearableSkillMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
} else if (object->isWeaponObject()) {
WeaponObject* weapon = cast<WeaponObject*>(object.get());
if(weapon != nullptr) {
const VectorMap<String, int>* wearableSkillMods = weapon->getWearableSkillMods();
for (int j = 0; j < wearableSkillMods->size(); ++j) {
String name = wearableSkillMods->elementAt(j).getKey();
if (isWearableModDisabled(name))
continue;
int value = wearableSkillMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
}
usedObjects.put(object.get());
}
if(!compareMods(mods, creature, WEARABLE)) {
warning("Wearable mods don't match for " + creature->getFirstName());
}
}
void SkillModManager::verifyStructureSkillMods(TangibleObject* tano) {
if (!tano->isCreatureObject())
return;
CreatureObject* creature = cast<CreatureObject*>(tano);
if (creature == nullptr)
return;
//Locker locker(creature);
VectorMap<String, int> mods;
mods.setAllowOverwriteInsertPlan();
mods.setNullValue(0);
ManagedReference<SceneObject*> parent = creature->getRootParent();
if (parent == nullptr) {
if (creature->getCurrentCamp() != nullptr) {
ManagedReference<CampSiteActiveArea*> campArea = creature->getCurrentCamp();
parent = campArea->getCamp();
}
}
if (parent != nullptr && parent->isStructureObject()) {
StructureObject* structure = parent.castTo<StructureObject*>();
const auto templateMods = structure->getTemplateSkillMods();
for (int i = 0; i < templateMods->size(); ++i) {
String name = templateMods->elementAt(i).getKey();
int value = templateMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
if (!compareMods(mods, creature, STRUCTURE)) {
warning("Structure mods don't match for " + creature->getFirstName());
}
}
void SkillModManager::verifySkillBoxSkillMods(CreatureObject* creature) {
Locker locker(creature);
VectorMap<String, int> mods;
mods.setAllowOverwriteInsertPlan();
mods.setNullValue(0);
const SkillList* skillList = creature->getSkillList();
for(int i = 0; i < skillList->size(); ++i) {
Reference<Skill*> skill = skillList->get(i);
auto skillMods = skill->getSkillModifiers();
for(int j = 0; j < skillMods->size(); ++j) {
const String& name = skillMods->elementAt(j).getKey();
int value = skillMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
if(!compareMods(mods, creature, SKILLBOX)) {
warning("SkillBox mods don't match for " + creature->getFirstName());
}
}
void SkillModManager::verifyBuffSkillMods(CreatureObject* creature) {
Locker locker(creature);
VectorMap<String, int> mods;
mods.setAllowOverwriteInsertPlan();
mods.setNullValue(0);
const BuffList* buffList = creature->getBuffList();
for(int i = 0; i < buffList->getBuffListSize(); ++i) {
ManagedReference<Buff*> buff = buffList->getBuffByIndex(i);
VectorMap<String, int>* skillMods = buff->getSkillModifiers();
for(int j = 0; j < skillMods->size(); ++j) {
String name = skillMods->elementAt(j).getKey();
int value = skillMods->get(name);
if(mods.contains(name)) {
value += mods.get(name);
}
mods.put(name, value);
}
}
if(!compareMods(mods, creature, BUFF)) {
warning("Buff mods don't match for " + creature->getFirstName());
}
}
bool SkillModManager::compareMods(VectorMap<String, int>& mods, CreatureObject* creature, uint32 type) {
mods.setAllowOverwriteInsertPlan();
mods.setNullValue(0);
auto skillModMutex = creature->getSkillModMutex();
Locker skillModLocker(skillModMutex);
SkillModList* skillModList = creature->getSkillModList();
if (skillModList == nullptr) {
error("nullptr SkillmodList for " + creature->getFirstName());
return false;
}
const SkillModGroup* group = skillModList->getSkillModGroup(type);
if(group == nullptr){
error("nullptr SkillModGroup for " + creature->getFirstName());
return false;
}
bool match = true;
StringBuffer compare;
compare << endl << " " << "SkillMod" << " " << "Player" << " " << "Computed" << endl;
for(int i = 0; i < group->size(); ++i) {
String key = group->elementAt(i).getKey();
int value = group->get(key);
int currentValue = mods.get(key);
mods.drop(key);
compare << " " << key << " " << value << " " << currentValue << endl;
if (value != currentValue) {
creature->removeSkillMod(type, key, value, true);
creature->addSkillMod(type, key, currentValue, true);
match = false;
}
}
if (!mods.isEmpty()) {
match = false;
for (int i = 0; i < mods.size(); i++) {
String key = mods.elementAt(i).getKey();
int currentValue = mods.get(key);
compare << " " << key << " " << "none" << " " << currentValue << endl;
}
}
if (match == false) {
warning(compare.toString());
if(creature->getPlayerObject() != nullptr) {
if(creature->getPlayerObject()->getDebug()) {
creature->sendSystemMessage(compare.toString());
}
}
}
return match;
}
| 25.205056 | 104 | 0.680597 | V-Fib |
a34ad4f998d847b5be3c0fdda2930bf8d4540af6 | 134 | hxx | C++ | src/Providers/UNIXProviders/AGPVideoController/UNIX_AGPVideoController_FREEBSD.hxx | brunolauze/openpegasus-providers-old | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | [
"MIT"
] | 1 | 2020-10-12T09:00:09.000Z | 2020-10-12T09:00:09.000Z | src/Providers/UNIXProviders/AGPVideoController/UNIX_AGPVideoController_FREEBSD.hxx | brunolauze/openpegasus-providers-old | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | [
"MIT"
] | null | null | null | src/Providers/UNIXProviders/AGPVideoController/UNIX_AGPVideoController_FREEBSD.hxx | brunolauze/openpegasus-providers-old | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | [
"MIT"
] | null | null | null | #ifdef PEGASUS_OS_FREEBSD
#ifndef __UNIX_AGPVIDEOCONTROLLER_PRIVATE_H
#define __UNIX_AGPVIDEOCONTROLLER_PRIVATE_H
#endif
#endif
| 11.166667 | 43 | 0.858209 | brunolauze |
a34af2f1abb7ca39ebc7fb496cfc11f7d64d6422 | 17,043 | cpp | C++ | src/twins.cpp | sequencing/gvcftools | 7e854392c94c63410a846d29a97b95a6f1435576 | [
"BSL-1.0"
] | 26 | 2015-11-30T18:53:11.000Z | 2021-11-12T07:48:37.000Z | src/twins.cpp | sequencing/gvcftools | 7e854392c94c63410a846d29a97b95a6f1435576 | [
"BSL-1.0"
] | 5 | 2015-08-06T18:32:55.000Z | 2020-03-08T18:13:22.000Z | src/twins.cpp | ctsa/gvcftools | 7e854392c94c63410a846d29a97b95a6f1435576 | [
"BSL-1.0"
] | 8 | 2015-07-20T09:53:07.000Z | 2018-06-10T09:55:31.000Z | // -*- mode: c++; indent-tabs-mode: nil; -*-
//
// Copyright (c) 2009-2012 Illumina, Inc.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use, copy,
// modify, merge, publish, distribute, sublicense, and/or sell copies
// of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// 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
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
// 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.
//
//
/// \file
///
/// \author Chris Saunders
///
#include "gvcftools.hh"
#include "related_sample_util.hh"
#include "ref_util.hh"
#include "tabix_util.hh"
#include "trio_option_util.hh"
#include "boost/program_options.hpp"
#include <ctime>
#include <iostream>
#include <string>
#include <vector>
std::ostream& log_os(std::cerr);
std::ostream& report_os(std::cout);
std::string cmdline;
enum sample_t {
TWIN1,
TWIN2,
SAMPLE_SIZE
};
const char* sample_label[] = { "twin1","twin2" };
enum state_t {
SAMEHOM,
DIFFHOM,
SAMEHET,
DIFFHET,
HOMHET,
STATE_SIZE
};
const char* state_label[] = { "samehom" , "diffhom" , "samehet" , "diffhet" , "homhet" };
static
state_t
get_st_cat(const bool ist1hom,
const bool ist2hom,
const char t1_1,
const char t2_1,
const char t1_2,
const char t2_2) {
if (ist1hom!=ist2hom) return HOMHET;
if (ist1hom) {
return (t1_1==t2_1 ? SAMEHOM : DIFFHOM);
} else {
return ((t1_1==t2_1) && (t1_2==t2_2) ? SAMEHET : DIFFHET);
}
}
struct site_stats : public site_stats_core<SAMPLE_SIZE> {
site_stats() {
for (unsigned i(0); i<STATE_SIZE; ++i) {
snp_correct_type[i]=0;
incorrect_type[i]=0;
}
}
unsigned snp_correct_type[STATE_SIZE];
unsigned incorrect_type[STATE_SIZE];
};
static
void
processSite(const site_crawler* sa,
const pos_t low_pos,
const reference_contig_segment& ref_seg,
pos_reporter& pr,
site_stats& ss) {
bool is_all_mapped(true);
bool is_any_mapped(false);
bool is_all_called(true);
bool is_any_called(false);
const char ref_base(ref_seg.get_base(low_pos-1));
if (ref_base=='N') return;
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
if (sa[st].is_pos_valid() && (sa[st].pos()==low_pos) && (sa[st].n_total() != 0)) {
ss.sample_mapped[st]++;
is_any_mapped=true;
} else {
is_all_mapped=false;
}
if (sa[st].is_pos_valid() && (sa[st].pos()==low_pos) && sa[st].is_site_call()) {
ss.sample_called[st]++;
if (! ((ref_base==sa[st].get_allele(0)) && (ref_base==sa[st].get_allele(1)))) {
ss.sample_snp[st]++;
if (sa[st].get_allele(0) != sa[st].get_allele(1)) {
ss.sample_snp_het[st]++;
}
}
is_any_called=true;
} else {
is_all_called=false;
}
}
if (! is_all_mapped) {
if (is_any_mapped) ss.some_mapped++;
} else {
ss.all_mapped++;
}
if (! is_all_called) {
if (is_any_called) ss.some_called++;
return;
} else {
ss.all_called++;
}
const char t1_1(sa[TWIN1].get_allele(0));
const char t1_2(sa[TWIN1].get_allele(1));
const char t2_1(sa[TWIN2].get_allele(0));
const char t2_2(sa[TWIN2].get_allele(1));
const bool is_correct(((t1_1==t2_1) && (t1_2==t2_2)) ||
((t1_2==t2_1) && (t1_1==t2_2)));
const bool ist1hom(t1_1==t1_2);
const bool ist2hom(t2_1==t2_2);
if (is_correct) {
const bool is_ref_call(ist1hom && ist2hom && (t1_1==ref_base));
if (! is_ref_call) {
const state_t st(get_st_cat(ist1hom,ist2hom,t1_1,t2_1,t1_2,t2_2));
ss.snp_correct++;
ss.snp_correct_type[st]++;
if (! ist1hom) ss.sample_snp_correct_het[TWIN1]++;
else if (t1_1!=ref_base) ss.sample_snp_correct_hom[TWIN1]++;
if (! ist2hom) ss.sample_snp_correct_het[TWIN2]++;
else if (t2_1!=ref_base) ss.sample_snp_correct_hom[TWIN2]++;
}
} else {
pr.print_pos(sa);
const state_t st(get_st_cat(ist1hom,ist2hom,t1_1,t2_1,t1_2,t2_2));
ss.incorrect++;
ss.incorrect_type[st]++;
}
}
static
void
report(const site_stats& ss,
const time_t& start_time,
const bool is_variable_metadata) {
std::ostream& os(report_os);
os << "CMDLINE " << cmdline << "\n";
if (is_variable_metadata) {
os << "START_TIME " << asctime(localtime(&start_time));
os << "VERSION " << gvcftools_version() << "\n";
}
os << "\n";
os << "sites: " << ss.ref_size << "\n";
os << "known_sites: " << ss.known_size << "\n";
os << "\n";
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
os << "sites_mapped_" << sample_label[st] << ": " << ss.sample_mapped[st] << "\n";
}
assert(ss.known_size >= (ss.some_mapped+ss.all_mapped));
const unsigned none_mapped(ss.known_size-(ss.some_mapped+ss.all_mapped));
os << "sites_mapped_in_no_samples: " << none_mapped << "\n";
os << "sites_mapped_in_some_samples: " << ss.some_mapped << "\n";
os << "sites_mapped_in_all_samples: " << ss.all_mapped << "\n";
os << "\n";
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
os << "sites_called_" << sample_label[st] << ": " << ss.sample_called[st] << "\n";
}
assert(ss.known_size >= (ss.some_called+ss.all_called));
const unsigned none_called(ss.known_size-(ss.some_called+ss.all_called));
os << "sites_called_in_no_samples: " << none_called << "\n";
os << "sites_called_in_some_samples: " << ss.some_called << "\n";
os << "sites_called_in_all_samples: " << ss.all_called << "\n";
os << "sites_called_in_all_samples_conflict: " << ss.incorrect << "\n";
os << "fraction_of_known_sites_called_in_all_samples: " << ratio(ss.all_called,ss.known_size) << "\n";
os << "fraction_of_sites_called_in_all_samples_in_conflict: " << ratio(ss.incorrect,ss.all_called) << "\n";
os << "\n";
const unsigned snps(ss.snp_correct+ss.incorrect);
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
const unsigned het(ss.sample_snp_het[st]);
const unsigned hom(ss.sample_snp[st]-ss.sample_snp_het[st]);
const double sample_het_hom(ratio(het,hom));
const double sample_phet(ratio(het,(hom+het)));
os << "sites_with_snps_called_total_het_hom_het/hom_P(het)_" << sample_label[st] << ": " << ss.sample_snp[st] << " " << het << " " << hom << " " << sample_het_hom << " " << sample_phet << "\n";
}
os << "sites_called_in_all_samples_with_snps_called_any_sample: " << snps << "\n";
os << "fraction_of_snp_sites_in_conflict: " << ratio(ss.incorrect,snps) << "\n";
os << "\n";
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
const unsigned het(ss.sample_snp_correct_het[st]);
const unsigned hom(ss.sample_snp_correct_hom[st]);
const double sample_het_hom(ratio(het,hom));
const double sample_phet(ratio(het,(hom+het)));
os << "snp_non_conflict_total_het_hom_het/hom_P(het)_" << sample_label[st] << ": " << (het+hom) << " " << het << " " << hom << " " << sample_het_hom << " " << sample_phet << "\n";
}
os << "\n";
for (unsigned i(0); i<STATE_SIZE; ++i) {
os << "snp_conflict_type_" << state_label[i] << ": "
<< ss.incorrect_type[i] << "\n";
}
os << "\n";
for (unsigned i(0); i<STATE_SIZE; ++i) {
os << "snp_non_conflict_type_" << state_label[i] << ": "
<< ss.snp_correct_type[i] << "\n";
}
os << "\n";
}
static
void
accumulate_region_statistics(const sample_info* const si,
const shared_crawler_options& opt,
const std::string& ref_seq_file,
const char* region,
pos_reporter& pr,
site_stats& ss) {
// setup reference sequence:
reference_contig_segment ref_seg;
unsigned segment_known_size;
get_samtools_std_ref_segment(ref_seq_file.c_str(),region,ref_seg,segment_known_size);
if (opt.is_region()) {
ref_seg.set_offset(opt.region_begin-1);
}
ss.ref_size += ref_seg.seq().size();
ss.known_size += segment_known_size;
// setup allele crawlers:
site_crawler sa[SAMPLE_SIZE] = { site_crawler(si[TWIN1],TWIN1,opt,region,ref_seg),
site_crawler(si[TWIN2],TWIN2,opt,region,ref_seg)
};
while (true) {
// get lowest position:
bool is_low_pos_set(false);
pos_t low_pos(0);
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
if (! sa[st].is_pos_valid()) continue;
if ((! is_low_pos_set) || (sa[st].pos() < low_pos)) {
low_pos = sa[st].pos();
is_low_pos_set=true;
}
}
if (! is_low_pos_set) break;
processSite(sa,low_pos,ref_seg,pr,ss);
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
if (sa[st].is_pos_valid() && (low_pos == sa[st].pos())) {
sa[st].update();
}
}
}
}
static
void
try_main(int argc,char* argv[]) {
const time_t start_time(time(0));
const char* progname(compat_basename(argv[0]));
for (int i(0); i<argc; ++i) {
if (i) cmdline += ' ';
cmdline += argv[i];
}
std::string conflict_pos_file;
std::string ref_seq_file;
shared_crawler_options opt;
std::vector<std::string> exclude_list;
sample_info si[SAMPLE_SIZE];
snp_param& sp(opt.sp());
std::vector<info_filter> max_info_filters;
namespace po = boost::program_options;
po::options_description req("configuration");
req.add_options()
("ref", po::value(&ref_seq_file),"samtools reference sequence (required)")
("region", po::value(&opt.region), "samtools reference region (optional)")
("exclude", po::value<std::vector<std::string> >(&exclude_list), "name of chromosome to skip over (argument may be specified multiple times). Exclusions will be ignored if a region argument is provided")
("twin1", po::value(&si[TWIN1].file),
"twin/replicate 1 gvcf file")
("twin2", po::value(&si[TWIN2].file),
"twin/replicate 2 gvcf file")
("conflict-file", po::value(&conflict_pos_file), "Write all conflict positions to the specified file")
("no-variable-metadata",
"Remove timestamp and any other metadata from output during validation testing")
("murdock", po::value(&opt.is_murdock_mode)->zero_tokens(),
"If true, don't stop because of any out-of-order position conflicts. Any out of order positions are ignored. In case of an overlap the first observation is used and subsequent repeats are ignored.");
po::options_description filter("filtration");
filter.add_options()
("min-gqx", po::value(&sp.min_gqx), "If GQX value for a record is below this value, then don't use the locus. Note that if the filter field already contains a GQX filter, this will not 'rescue' filtered variants when min-gqx is set very low -- this filter can only lower callability on a file. Any records missing the GQX field will not be filtered out. (default: 0)")
("min-pos-rank-sum", po::value(&sp.min_pos_rank_sum), "Filter site if the INFO field contains the key BaseQRankSum and the value is less than the minimum. (default: no-filter)")
("min-qd", po::value(&sp.min_qd), "Filter site if the INFO field contains the key QD and the value is less than the minimum. (default: no-filter)")
("min-info-field",po::value<std::vector<info_filter> >(&sp.infof)->multitoken(),
"Filter records which contain an INFO key equal to argument1, and a corresponding value less than argument2 ")
("max-info-field",po::value<std::vector<info_filter> >(&max_info_filters)->multitoken(),
"Filter records which contain an INFO key equal to argument1, and a corresponding value greater than argument2 ");
po::options_description help("help");
help.add_options()
("help,h","print this message");
po::options_description visible("options");
visible.add(req).add(filter).add(help);
bool po_parse_fail(false);
po::variables_map vm;
try {
po::store(po::parse_command_line(argc, argv, visible,
po::command_line_style::unix_style ^ po::command_line_style::allow_short), vm);
po::notify(vm);
} catch (const boost::program_options::error& e) { // todo:: find out what is the more specific exception class thrown by program options
log_os << "ERROR: Exception thrown by option parser: " << e.what() << "\n";
po_parse_fail=true;
}
if ((argc<=1) || (vm.count("help")) || ref_seq_file.empty() || po_parse_fail) {
log_os << "\n" << progname << " finds conflicts in the variant calls made from twins or technical replicates.\n\n";
log_os << "version: " << gvcftools_version() << "\n\n";
log_os << "usage: " << progname << " [options] > twins_report\n\n";
log_os << visible << "\n";
log_os << "Note that calls inside of deletions will not be used\n";
exit(EXIT_FAILURE);
}
// clean up filters:
{
for (unsigned i(0); i<max_info_filters.size(); ++i) {
max_info_filters[i].is_min=false;
sp.infof.push_back(max_info_filters[i]);
}
}
const bool is_variable_metadata(! vm.count("no-variable-metadata"));
sp.is_min_qd=(vm.count("min-qd"));
sp.is_min_pos_rank_sum=(vm.count("min-pos-rank-sum"));
#if 0
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
log_os << sample_label[st] << "_files:\n";
const unsigned st_size(si[st].allele_files.size());
for (unsigned i(0); i<st_size; ++i) {
log_os << si[st].allele_files[i] << "\n";
}
}
#endif
for (unsigned st(0); st<SAMPLE_SIZE; ++st) {
if (si[st].file.empty()) {
log_os << "ERROR: no gvcf file specified for sample: '" << sample_label[st] << "'\n";
exit(EXIT_FAILURE);
}
}
if (opt.is_region()) {
parse_tabix_region(si[TWIN1].file.c_str(),opt.region.c_str(),opt.region_begin,opt.region_end);
opt.region_begin+=1;
}
std::vector<std::string> slabel(sample_label,sample_label+SAMPLE_SIZE);
pos_reporter pr(conflict_pos_file,slabel);
site_stats ss;
if (opt.is_region()) {
accumulate_region_statistics(si,opt,ref_seq_file,opt.region.c_str(),pr,ss);
} else {
fasta_chrom_list fcl(ref_seq_file.c_str());
while (true) {
const char* chrom = fcl.next();
if (NULL == chrom) break;
// don't even bother making this efficient:
bool is_skip(false);
for (unsigned i(0); i<exclude_list.size(); ++i) {
if (strcmp(chrom,exclude_list[i].c_str())==0) {
is_skip=true;
break;
}
}
if (is_skip) {
log_os << "skipping chromosome: '" << chrom << "'\n";
} else {
log_os << "processing chromosome: '" << chrom << "'\n";
accumulate_region_statistics(si,opt,ref_seq_file,chrom,pr,ss);
}
}
}
report(ss,start_time,is_variable_metadata);
}
static
void
dump_cl(int argc,
char* argv[],
std::ostream& os) {
os << "cmdline:";
for (int i(0); i<argc; ++i) {
os << ' ' << argv[i];
}
os << std::endl;
}
int
main(int argc,char* argv[]) {
std::ios_base::sync_with_stdio(false);
// last chance to catch exceptions...
//
try {
try_main(argc,argv);
} catch (const std::exception& e) {
log_os << "FATAL:: EXCEPTION: " << e.what() << "\n"
<< "...caught in main()\n";
dump_cl(argc,argv,log_os);
exit(EXIT_FAILURE);
} catch (...) {
log_os << "FATAL:: UNKNOWN EXCEPTION\n"
<< "...caught in main()\n";
dump_cl(argc,argv,log_os);
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
| 33.748515 | 372 | 0.598251 | sequencing |
a34b336796739c2c2a18df02c41408ba002124ce | 5,486 | cpp | C++ | FastCAE_Linux/Code/GeometryCommand/GeoCommandMakeFillHole.cpp | alleindrach/calculix-desktop | 2cb2c434b536eb668ff88bdf82538d22f4f0f711 | [
"MIT"
] | 23 | 2020-03-16T03:01:43.000Z | 2022-03-21T16:36:22.000Z | FastCAE_Linux/Code/GeometryCommand/GeoCommandMakeFillHole.cpp | alleindrach/calculix-desktop | 2cb2c434b536eb668ff88bdf82538d22f4f0f711 | [
"MIT"
] | 1 | 2020-03-17T05:50:07.000Z | 2020-03-17T05:50:07.000Z | FastCAE_Linux/Code/GeometryCommand/GeoCommandMakeFillHole.cpp | alleindrach/calculix-desktop | 2cb2c434b536eb668ff88bdf82538d22f4f0f711 | [
"MIT"
] | 17 | 2020-03-16T01:46:36.000Z | 2022-03-21T16:36:37.000Z | #include "GeoCommandMakeFillHole.h"
#include "geometry/geometrySet.h"
#include "geometry/geometryData.h"
#include <TopExp.hxx>
#include <TopoDS.hxx>
#include <TopoDS_TShape.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx>
#include <TopExp_Explorer.hxx>
#include <QDebug>
#include <BRepAlgoAPI_Defeaturing.hxx>
#include "geometry/geometryParaMakeFillHole.h"
namespace Command
{
CommandMakeFillHole::CommandMakeFillHole(GUI::MainWindow* m, MainWidget::PreWindow* p)
:GeoCommandBase(m, p)
{
}
bool CommandMakeFillHole::execute()
{
QList<Geometry::GeometrySet*> setList = _shapeHash.uniqueKeys();
bool success = false;
for (int i = 0; i < setList.size(); ++i)
{
Geometry::GeometrySet* set = setList.at(i);
TopoDS_Shape* parent = set->getShape();
QList<int> shapes = _shapeHash.values(set);
const int count = shapes.size();
if (count < 1) continue;
TopTools_ListOfShape aFeatures;// Features to remove from the shape
for (int j = 0; j < count; ++j)
{
const int index = shapes.at(j);
TopExp_Explorer edgeExp(*parent, TopAbs_FACE);
for (int k = 0; k < index; ++k) edgeExp.Next();
const TopoDS_Shape& shape = edgeExp.Current();
aFeatures.Append(shape);
}
if (aFeatures.Size() < 1) return false;
Standard_Boolean bRunParallel = true; // Parallel processing mode
Standard_Boolean isHistoryNeeded = false; // History support
BRepAlgoAPI_Defeaturing aDF; // Defeaturing algorithm
aDF.SetShape(*parent); // Set the shape
aDF.AddFacesToRemove(aFeatures); // Add faces to remove
aDF.SetRunParallel(bRunParallel); // Define the processing mode (parallel or single)
aDF.SetToFillHistory(isHistoryNeeded); // Define whether to track the shapes modifications
aDF.Build(); // Perform the operation
if (!aDF.IsDone()) // Check for the errors
{
// error treatment
Standard_SStream aSStream;
aDF.DumpErrors(aSStream);
return false;
}
if (aDF.HasWarnings()) // Check for the warnings
{
// warnings treatment
Standard_SStream aSStream;
aDF.DumpWarnings(aSStream);
}
success = true;
const TopoDS_Shape &resShape = aDF.Shape();
TopoDS_Shape* successShape = new TopoDS_Shape;
*successShape = resShape;
const int id = Geometry::GeometrySet::getMaxID() + 1;
QString name = _name.arg(id);
Geometry::GeometrySet* newset = new Geometry::GeometrySet(Geometry::STEP);
newset->setName(name);
newset->setShape(successShape);
//_geoData->appendGeometrySet(newset);
if (_isEdit)
{
newset->setName(_editSet->getName());
_geoData->replaceSet(newset, _editSet);
}
else
{
newset->setName(name);
_geoData->appendGeometrySet(newset);
}
_geoData->removeTopGeometrySet(set);
newset->appendSubSet(set);
_inputOutputHash.insert(set, newset);
Geometry::GeometryParaMakeFillHole* para = new Geometry::GeometryParaMakeFillHole;
para->setName(name);
para->setInputSet(set);
para->setFaceList(shapes);
newset->setParameter(para);
GeoCommandBase::execute();
emit removeDisplayActor(set);
emit showSet(newset);
}
emit updateGeoTree();
return success;
}
void CommandMakeFillHole::undo()
{
if (_isEdit)
{
Geometry::GeometrySet* orset = _editSet->getSubSetAt(0);
Geometry::GeometrySet* resplace = _inputOutputHash.value(orset);
_geoData->replaceSet(_editSet, resplace);
emit removeDisplayActor(resplace);
emit showSet(_editSet);
}
else
{
QList<Geometry::GeometrySet*> inputList = _inputOutputHash.keys();
const int n = inputList.size();
for (int i = 0; i < n; ++i)
{
Geometry::GeometrySet* inputSet = inputList.at(i);
Geometry::GeometrySet* outputSet = _inputOutputHash.value(inputSet);
emit removeDisplayActor(outputSet);
outputSet->removeSubSet(inputSet);
_geoData->removeTopGeometrySet(outputSet);
_geoData->appendGeometrySet(inputSet);
emit showSet(inputSet);
}
}
emit updateGeoTree();
}
void CommandMakeFillHole::redo()
{
if (_isEdit)
{
Geometry::GeometrySet* orset = _editSet->getSubSetAt(0);
Geometry::GeometrySet* resplace = _inputOutputHash.value(orset);
_geoData->replaceSet(resplace, _editSet);
emit removeDisplayActor(_editSet);
emit showSet(resplace);
}
else
{
QList<Geometry::GeometrySet*> inputList = _inputOutputHash.keys();
const int n = inputList.size();
for (int i = 0; i < n; ++i)
{
Geometry::GeometrySet* inputSet = inputList.at(i);
Geometry::GeometrySet* outputSet = _inputOutputHash.value(inputSet);
emit removeDisplayActor(inputSet);
outputSet->appendSubSet(inputSet);
_geoData->removeTopGeometrySet(inputSet);
_geoData->appendGeometrySet(outputSet);
emit showSet(outputSet);
}
}
emit updateGeoTree();
}
void CommandMakeFillHole::releaseResult()
{
QList<Geometry::GeometrySet*> outputList = _inputOutputHash.values();
const int n = outputList.size();
for (int i = 0; i < n; ++i)
{
auto set = outputList.at(i);
delete set;
}
_inputOutputHash.clear();
}
void CommandMakeFillHole::setShapeList(QMultiHash<Geometry::GeometrySet*, int> s)
{
_shapeHash = s;
}
} | 28.873684 | 96 | 0.658221 | alleindrach |
a34b3aa8443cd09ba2da708b397080b3aa05e070 | 16,042 | cpp | C++ | components/homme/src/preqx_kokkos/cxx/cxx_f90_interface_preqx.cpp | oksanaguba/E3SM | 3523b2bd017db92dcc84c4df29fa2b2c3473d3a9 | [
"BSD-3-Clause"
] | null | null | null | components/homme/src/preqx_kokkos/cxx/cxx_f90_interface_preqx.cpp | oksanaguba/E3SM | 3523b2bd017db92dcc84c4df29fa2b2c3473d3a9 | [
"BSD-3-Clause"
] | 11 | 2021-06-04T22:56:10.000Z | 2022-03-29T14:23:55.000Z | components/homme/src/preqx_kokkos/cxx/cxx_f90_interface_preqx.cpp | oksanaguba/E3SM | 3523b2bd017db92dcc84c4df29fa2b2c3473d3a9 | [
"BSD-3-Clause"
] | null | null | null | /********************************************************************************
* HOMMEXX 1.0: Copyright of Sandia Corporation
* This software is released under the BSD license
* See the file 'COPYRIGHT' in the HOMMEXX/src/share/cxx directory
*******************************************************************************/
#include "CaarFunctor.hpp"
#include "Context.hpp"
#include "Diagnostics.hpp"
#include "Elements.hpp"
#include "ErrorDefs.hpp"
#include "EulerStepFunctor.hpp"
#include "FunctorsBuffersManager.hpp"
#include "HommexxEnums.hpp"
#include "HybridVCoord.hpp"
#include "HyperviscosityFunctor.hpp"
#include "ReferenceElement.hpp"
#include "SimulationParams.hpp"
#include "SphereOperators.hpp"
#include "TimeLevel.hpp"
#include "Tracers.hpp"
#include "VerticalRemapManager.hpp"
#include "mpi/BoundaryExchange.hpp"
#include "mpi/MpiBuffersManager.hpp"
#include "utilities/SyncUtils.hpp"
#include "profiling.hpp"
namespace Homme
{
extern "C"
{
void init_simulation_params_c (const int& remap_alg, const int& limiter_option, const int& rsplit, const int& qsplit,
const int& time_step_type, const int& qsize, const int& state_frequency,
const Real& nu, const Real& nu_p, const Real& nu_q, const Real& nu_s, const Real& nu_div, const Real& nu_top,
const int& hypervis_order, const int& hypervis_subcycle, const double& hypervis_scaling,
const int& ftype, const bool& prescribed_wind, const bool& moisture, const bool& disable_diagnostics,
const bool& use_cpstar, const int& transport_alg,
const int& dt_remap_factor, const int& dt_tracer_factor,
const double& rearth)
{
// Check that the simulation options are supported. This helps us in the future, since we
// are currently 'assuming' some option have/not have certain values. As we support for more
// options in the C++ build, we will remove some checks
Errors::check_option("init_simulation_params_c","vert_remap_q_alg",remap_alg,{1,3});
Errors::check_option("init_simulation_params_c","prescribed_wind",prescribed_wind,{false});
Errors::check_option("init_simulation_params_c","hypervis_order",hypervis_order,{2});
Errors::check_option("init_simulation_params_c","transport_alg",transport_alg,{0});
Errors::check_option("init_simulation_params_c","time_step_type",time_step_type,{5});
Errors::check_option("init_simulation_params_c","qsize",qsize,0,Errors::ComparisonOp::GE);
Errors::check_option("init_simulation_params_c","qsize",qsize,QSIZE_D,Errors::ComparisonOp::LE);
Errors::check_option("init_simulation_params_c","limiter_option",limiter_option,{8,9});
Errors::check_option("init_simulation_params_c","ftype",ftype, {-1, 0, 2});
Errors::check_option("init_simulation_params_c","nu_p",nu_p,0.0,Errors::ComparisonOp::GT);
Errors::check_option("init_simulation_params_c","nu",nu,0.0,Errors::ComparisonOp::GT);
Errors::check_option("init_simulation_params_c","nu_div",nu_div,0.0,Errors::ComparisonOp::GT);
// Get the simulation params struct
SimulationParams& params = Context::singleton().create<SimulationParams>();
if (remap_alg==1) {
params.remap_alg = RemapAlg::PPM_MIRRORED;
}
if (time_step_type==5) {
params.time_step_type = TimeStepType::ttype5;
}
params.limiter_option = limiter_option;
params.rsplit = rsplit;
params.qsplit = qsplit;
params.dt_remap_factor = dt_remap_factor;
params.dt_tracer_factor = dt_tracer_factor;
params.prescribed_wind = prescribed_wind;
params.state_frequency = state_frequency;
params.qsize = qsize;
params.nu = nu;
params.nu_p = nu_p;
params.nu_q = nu_q;
params.nu_s = nu_s;
params.nu_div = nu_div;
params.nu_top = nu_top;
params.hypervis_order = hypervis_order;
params.hypervis_subcycle = hypervis_subcycle;
params.hypervis_scaling = hypervis_scaling;
params.disable_diagnostics = disable_diagnostics;
params.moisture = (moisture ? MoistDry::MOIST : MoistDry::DRY);
params.use_cpstar = use_cpstar;
params.transport_alg = transport_alg;
params.rearth = rearth;
//set nu_ratios values
if (params.nu != params.nu_div) {
Real ratio = params.nu_div / params.nu;
if (params.hypervis_scaling != 0.0) {
params.nu_ratio1 = ratio * ratio;
params.nu_ratio2 = 1.0;
}else{
params.nu_ratio1 = ratio;
params.nu_ratio2 = ratio;
}
}else{
params.nu_ratio1 = 1.0;
params.nu_ratio2 = 1.0;
}
if (ftype == -1) {
params.ftype = ForcingAlg::FORCING_OFF;
} else if (ftype == 0) {
params.ftype = ForcingAlg::FORCING_DEBUG;
} else if (ftype == 2) {
params.ftype = ForcingAlg::FORCING_2;
}
// TODO Parse a fortran string and set this properly. For now, our code does
// not depend on this except to throw an error in apply_test_forcing.
params.test_case = TestCase::JW_BAROCLINIC;
// Now this structure can be used safely
params.params_set = true;
}
void init_hvcoord_c (const Real& ps0, CRCPtr& hybrid_am_ptr, CRCPtr& hybrid_ai_ptr,
CRCPtr& hybrid_bm_ptr, CRCPtr& hybrid_bi_ptr)
{
HybridVCoord& hvcoord = Context::singleton().create<HybridVCoord>();
hvcoord.init(ps0,hybrid_am_ptr,hybrid_ai_ptr,hybrid_bm_ptr,hybrid_bi_ptr);
}
void cxx_push_results_to_f90(F90Ptr &elem_state_v_ptr, F90Ptr &elem_state_temp_ptr,
F90Ptr &elem_state_dp3d_ptr, F90Ptr &elem_state_Qdp_ptr,
F90Ptr &elem_Q_ptr, F90Ptr &elem_state_ps_v_ptr,
F90Ptr &elem_derived_omega_p_ptr) {
Elements &elements = Context::singleton().get<Elements>();
elements.m_state.push_to_f90_pointers(elem_state_v_ptr, elem_state_temp_ptr, elem_state_dp3d_ptr);
Tracers &tracers = Context::singleton().get<Tracers>();
tracers.push_qdp(elem_state_Qdp_ptr);
// F90 ptrs to arrays (np,np,num_time_levels,nelemd) can be stuffed directly
// in an unmanaged view
// with scalar Real*[NUM_TIME_LEVELS][NP][NP] (with runtime dimension nelemd)
HostViewUnmanaged<Real * [NUM_TIME_LEVELS][NP][NP]> ps_v_f90(
elem_state_ps_v_ptr, elements.num_elems());
auto ps_v_host = Kokkos::create_mirror_view(elements.m_state.m_ps_v);
Kokkos::deep_copy(ps_v_host, elements.m_state.m_ps_v);
Kokkos::deep_copy(ps_v_f90, ps_v_host);
sync_to_host(elements.m_derived.m_omega_p,
HostViewUnmanaged<Real * [NUM_PHYSICAL_LEV][NP][NP]>(
elem_derived_omega_p_ptr, elements.num_elems()));
sync_to_host(tracers.Q,
HostViewUnmanaged<Real * [QSIZE_D][NUM_PHYSICAL_LEV][NP][NP]>(
elem_Q_ptr, elements.num_elems()));
}
// Probably not needed
void cxx_push_forcing_to_f90(F90Ptr elem_derived_FM, F90Ptr elem_derived_FT,
F90Ptr elem_derived_FQ) {
Elements &elements = Context::singleton().get<Elements>();
Tracers &tracers = Context::singleton().get<Tracers>();
HostViewUnmanaged<Real * [NUM_PHYSICAL_LEV][2][NP][NP]> fm_f90(
elem_derived_FM, elements.num_elems());
sync_to_host<2>(elements.m_forcing.m_fm, fm_f90);
HostViewUnmanaged<Real * [NUM_PHYSICAL_LEV][NP][NP]> ft_f90(
elem_derived_FT, elements.num_elems());
sync_to_host(elements.m_forcing.m_ft, ft_f90);
const SimulationParams ¶ms = Context::singleton().get<SimulationParams>();
if (params.ftype == ForcingAlg::FORCING_DEBUG) {
if (tracers.fq.data() == nullptr) {
tracers.fq = decltype(tracers.fq)("fq", elements.num_elems());
}
HostViewUnmanaged<Real * [QSIZE_D][NUM_PHYSICAL_LEV][NP][NP]> fq_f90(
elem_derived_FQ, elements.num_elems());
sync_to_host(tracers.fq, fq_f90);
}
}
void f90_push_forcing_to_cxx(F90Ptr elem_derived_FM, F90Ptr elem_derived_FT,
F90Ptr elem_derived_FQ,
F90Ptr elem_state_Qdp_ptr) {
Elements &elements = Context::singleton().get<Elements>();
HostViewUnmanaged<Real * [NUM_PHYSICAL_LEV][2][NP][NP]> fm_f90(
elem_derived_FM, elements.num_elems());
sync_to_device<2>(fm_f90, elements.m_forcing.m_fm);
HostViewUnmanaged<Real * [NUM_PHYSICAL_LEV][NP][NP]> ft_f90(
elem_derived_FT, elements.num_elems());
sync_to_device(ft_f90, elements.m_forcing.m_ft);
const SimulationParams ¶ms = Context::singleton().get<SimulationParams>();
Tracers &tracers = Context::singleton().get<Tracers>();
if (params.ftype == ForcingAlg::FORCING_DEBUG) {
if (tracers.fq.data() == nullptr) {
tracers.fq = decltype(tracers.fq)("fq", elements.num_elems());
}
HostViewUnmanaged<Real * [QSIZE_D][NUM_PHYSICAL_LEV][NP][NP]> fq_f90(
elem_derived_FQ, elements.num_elems());
sync_to_device(fq_f90, tracers.fq);
}
tracers.push_qdp(elem_state_Qdp_ptr);
}
void init_reference_element_c (CF90Ptr& deriv, CF90Ptr& mass)
{
ReferenceElement& ref_FE = Context::singleton().create<ReferenceElement> ();
ref_FE.init(deriv,mass);
}
void init_time_level_c (const int& nm1, const int& n0, const int& np1,
const int& nstep, const int& nstep0)
{
TimeLevel& tl = Context::singleton().create<TimeLevel>();
tl.nm1 = nm1-1;
tl.n0 = n0-1;
tl.np1 = np1-1;
tl.nstep = nstep;
tl.nstep0 = nstep0;
}
void init_elements_c (const int& num_elems)
{
auto& c = Context::singleton();
Elements& e = c.create<Elements> ();
const SimulationParams& params = c.get<SimulationParams>();
const bool consthv = (params.hypervis_scaling==0.0);
e.init (num_elems, consthv, /* alloc_gradphis = */ false, params.rearth);
// Init also the tracers structure
Tracers& t = c.create<Tracers> ();
t.init(num_elems,params.qsize);
// In the context, we register also Elements[Geometry|State|DerivedState|Forcing],
// making sure they store the same views as in the subobjects of Elements.
// This allows objects that need only a piece of Elements, to grab it from the Context,
// while still knowing that what they grab contains the same views as the object stored in the
// Elements inside the Context
// WARNING: after this point, you should NOT do things like
// e.m_geometry.m_phis = ...
// since they would NOT be reflected into the ElementsGeometry stored in the Context.
// In other words, you cannot reset the views. If you *really* need to do it,
// you must reset the view in both c.get<Elements>().m_geometry AND
// c.get<ElementsGeometry>()
c.create_ref<ElementsGeometry>(e.m_geometry);
c.create_ref<ElementsState>(e.m_state);
c.create_ref<ElementsDerivedState>(e.m_derived);
c.create_ref<ElementsForcing>(e.m_forcing);
}
void init_functors_c ()
{
// We init all the functors in the Context, so that every call to
// Context::singleton().get<[FunctorName]>() is allowed (otherwise
// Context would throw because the requested object is not found).
auto& elems = Context::singleton().get<Elements>();
auto& tracers = Context::singleton().get<Tracers>();
auto& ref_FE = Context::singleton().get<ReferenceElement>();
auto& hvcoord = Context::singleton().get<HybridVCoord>();
auto& params = Context::singleton().get<SimulationParams>();
auto& fbm = Context::singleton().create<FunctorsBuffersManager>();
// Check that the above structures have been inited
Errors::runtime_check(elems.inited(), "Error! You must initialize the Elements structure before initializing the functors.\n", -1);
Errors::runtime_check(tracers.inited(), "Error! You must initialize the Tracers structure before initializing the functors.\n", -1);
Errors::runtime_check(ref_FE.inited(), "Error! You must initialize the ReferenceElement structure before initializing the functors.\n", -1);
Errors::runtime_check(hvcoord.m_inited, "Error! You must initialize the HybridVCoord structure before initializing the functors.\n", -1);
Errors::runtime_check(params.params_set, "Error! You must initialize the SimulationParams structure before initializing the functors.\n", -1);
// First, sphere operators, then all the functors
auto& sph_op = Context::singleton().create<SphereOperators>(elems.m_geometry,ref_FE);
auto& caar = Context::singleton().create<CaarFunctor>(elems,tracers,ref_FE,hvcoord,sph_op,params);
auto& esf = Context::singleton().create<EulerStepFunctor>();
auto& hvf = Context::singleton().create<HyperviscosityFunctor>();
Context::singleton().create<VerticalRemapManager>();
// Ask the functors to request buffers to the buffers manager
fbm.request_size(caar.requested_buffer_size());
fbm.request_size(esf.requested_buffer_size());
fbm.request_size(hvf.requested_buffer_size());
// Allocate the buffers
fbm.allocate();
// Tell the functors to grab their buffers
caar.init_buffers(fbm);
esf.init_buffers(fbm);
hvf.init_buffers(fbm);
}
void init_elements_2d_c (const int& ie, CF90Ptr& D, CF90Ptr& Dinv, CF90Ptr& fcor,
CF90Ptr& spheremp, CF90Ptr& rspheremp,
CF90Ptr& metdet, CF90Ptr& metinv, CF90Ptr& phis,
CF90Ptr &tensorvisc, CF90Ptr &vec_sph2cart)
{
Elements& e = Context::singleton().get<Elements> ();
const SimulationParams& params = Context::singleton().get<SimulationParams>();
const bool consthv = (params.hypervis_scaling==0.0);
e.m_geometry.set_elem_data(ie,D,Dinv,fcor,spheremp,rspheremp,metdet,metinv,tensorvisc,vec_sph2cart,consthv);
e.m_geometry.set_phis(ie,phis);
}
void init_elements_states_c (CF90Ptr& elem_state_v_ptr, CF90Ptr& elem_state_temp_ptr, CF90Ptr& elem_state_dp3d_ptr,
CF90Ptr& elem_state_Qdp_ptr, CF90Ptr& elem_state_ps_v_ptr)
{
Elements& elements = Context::singleton().get<Elements> ();
elements.m_state.pull_from_f90_pointers(elem_state_v_ptr,elem_state_temp_ptr,elem_state_dp3d_ptr,elem_state_ps_v_ptr);
Tracers &tracers = Context::singleton().get<Tracers>();
tracers.pull_qdp(elem_state_Qdp_ptr);
}
void init_diagnostics_c (F90Ptr& elem_state_q_ptr, F90Ptr& elem_accum_qvar_ptr, F90Ptr& elem_accum_qmass_ptr,
F90Ptr& elem_accum_q1mass_ptr, F90Ptr& elem_accum_iener_ptr, F90Ptr& elem_accum_iener_wet_ptr,
F90Ptr& elem_accum_kener_ptr, F90Ptr& elem_accum_pener_ptr)
{
Elements& elements = Context::singleton().get<Elements> ();
Diagnostics& diagnostics = Context::singleton().create<Diagnostics> ();
diagnostics.init(elements.num_elems(), elem_state_q_ptr, elem_accum_qvar_ptr, elem_accum_qmass_ptr, elem_accum_q1mass_ptr,
elem_accum_iener_ptr, elem_accum_iener_wet_ptr, elem_accum_kener_ptr, elem_accum_pener_ptr);
}
void init_boundary_exchanges_c ()
{
auto& params = Context::singleton().get<SimulationParams>();
// Create BEs. Note: connectivity is created in init_connectivity in mpi_cxx_f90_interface
auto connectivity = Context::singleton().get_ptr<Connectivity>();
auto& bmm = Context::singleton().create<MpiBuffersManagerMap>();
bmm[MPI_EXCHANGE]->set_connectivity(connectivity);
bmm[MPI_EXCHANGE_MIN_MAX]->set_connectivity(connectivity);
// Euler BEs
auto& esf = Context::singleton().get<EulerStepFunctor>();
esf.reset(params);
esf.init_boundary_exchanges();
// RK stages BE's
auto& cf = Context::singleton().get<CaarFunctor>();
cf.init_boundary_exchanges(bmm[MPI_EXCHANGE]);
// HyperviscosityFunctor's BE's
auto& hvf = Context::singleton().get<HyperviscosityFunctor>();
hvf.init_boundary_exchanges();
}
} // extern "C"
} // namespace Homme
| 44.437673 | 144 | 0.686136 | oksanaguba |
a34bd9cccfb95831c11f1c118ad0e12ba336cb66 | 94,219 | cpp | C++ | Split/Temp/il2cppOutput/il2cppOutput/UnityEngine.UnityWebRequestWWWModule.cpp | OgiJr/SunBed | ea42007d57affe1421517cff6634e6412943f89f | [
"MIT"
] | null | null | null | Split/Temp/il2cppOutput/il2cppOutput/UnityEngine.UnityWebRequestWWWModule.cpp | OgiJr/SunBed | ea42007d57affe1421517cff6634e6412943f89f | [
"MIT"
] | null | null | null | Split/Temp/il2cppOutput/il2cppOutput/UnityEngine.UnityWebRequestWWWModule.cpp | OgiJr/SunBed | ea42007d57affe1421517cff6634e6412943f89f | [
"MIT"
] | null | null | null | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <limits>
#include <stdint.h>
// UnityEngine.Networking.CertificateHandler
struct CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
// UnityEngine.WWW
struct WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2;
// System.Action`1<UnityEngine.AsyncOperation>
struct Action_1_tC1348BEB2C677FD60E4B65764CA3A1CAFF6DFB31;
// System.Collections.Generic.Dictionary`2<System.Object,System.Object>
struct Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D;
// System.Collections.Generic.Dictionary`2<System.String,System.String>
struct Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5;
// System.Collections.Generic.IEqualityComparer`1<System.String>
struct IEqualityComparer_1_tE6A65C5E45E33FD7D9849FD0914DE3AD32B68050;
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.String>
struct KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D;
// System.Collections.Generic.List`1<System.Byte[]>
struct List_1_t08E192A6E99857FD75EAA081A5D3BEC33729EDBE;
// System.Collections.Generic.List`1<System.String>
struct List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3;
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.String>
struct ValueCollection_t9161A5C97376D261665798FA27DAFD5177305C81;
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// UnityEngine.CustomYieldInstruction
struct CustomYieldInstruction_t4ED1543FBAA3143362854EB1867B42E5D190A5C7;
// UnityEngine.Networking.DownloadHandler
struct DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB;
// UnityEngine.Networking.DownloadHandlerBuffer
struct DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D;
// System.Collections.Generic.Dictionary`2/Entry<System.String,System.String>[]
struct EntryU5BU5D_t52A654EA9927D1B5F56CA05CF209F2E4393C4510;
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
// System.String
struct String_t;
// UnityEngine.Texture2D
struct Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF;
// UnityEngine.Networking.UnityWebRequest
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E;
// UnityEngine.Networking.UnityWebRequestAsyncOperation
struct UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396;
// UnityEngine.Networking.UploadHandler
struct UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA;
// UnityEngine.Networking.UploadHandlerRaw
struct UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669;
// System.Uri
struct Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612;
// UnityEngine.WWWForm
struct WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB;
IL2CPP_EXTERN_C RuntimeClass* Debug_tEB68BCBEB8EFD60F8043C67146DC05E7F50F374B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral14B6DF3349D302FD20ED0B3BD448C2045066E9BE;
IL2CPP_EXTERN_C String_t* _stringLiteral14E338D17C42E552FA7AF42CDAE40CA1F0E8A04D;
IL2CPP_EXTERN_C String_t* _stringLiteral218F5A08519088A96BE3C1074984C53EA49F1CCA;
IL2CPP_EXTERN_C String_t* _stringLiteral3781CFEEF925855A4B7284E1783A7D715A6333F6;
IL2CPP_EXTERN_C String_t* _stringLiteral8E752B76D455A50FE476984D4B09A7CDBF2A753E;
IL2CPP_EXTERN_C String_t* _stringLiteralDA39A3EE5E6B4B0D3255BFEF95601890AFD80709;
IL2CPP_EXTERN_C String_t* _stringLiteralE2429764F10DC7E990250D2AE4138FE5AC928076;
IL2CPP_EXTERN_C const RuntimeMethod* Dictionary_2_GetEnumerator_m8C0A038B5FA7E62DEF4DB9EF1F5FCC4348D785C5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_Dispose_m76E867298698AA2B89F9D57E21CEFCD16B372D22_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_MoveNext_mA57D4325DBD9D10EB3E43C99CC18DB6C3CE85FC8_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_get_Current_m45394A0B01FA26CB32851562F9CBF27DB35FF4DD_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* KeyValuePair_2_get_Key_m42802FFFC275E928911F87B16DFE504319DF58F1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* KeyValuePair_2_get_Value_mB6B24D3920A4744624F8ED9AE493783D0E5F81DD_RuntimeMethod_var;
IL2CPP_EXTERN_C const uint32_t WWW_CreateTextureFromDownloadedData_m978F4A746B24EEA580E7AA8F1F05203196A299F9_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WWW__ctor_m6686CBC878BB9EB28F4C4171C203CA4E3DE3656C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WWW_get_error_mB278F5EC90EF99FEF70D80112940CFB49E79C9BC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WWW_get_text_m0D2EF7BBFB58E37FE30A665389355ACA65804138_MetadataUsageId;
struct CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E_marshaled_com;
struct DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_com;
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_com;
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_pinvoke;
struct UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_com;
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_t1A04780FFD77F371B4AE0F3CA161423BCEF4EDAF
{
public:
public:
};
// System.Object
struct Il2CppArrayBounds;
// System.Array
// System.Collections.Generic.Dictionary`2<System.String,System.String>
struct Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 : public RuntimeObject
{
public:
// System.Int32[] System.Collections.Generic.Dictionary`2::buckets
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___buckets_0;
// System.Collections.Generic.Dictionary`2_Entry<TKey,TValue>[] System.Collections.Generic.Dictionary`2::entries
EntryU5BU5D_t52A654EA9927D1B5F56CA05CF209F2E4393C4510* ___entries_1;
// System.Int32 System.Collections.Generic.Dictionary`2::count
int32_t ___count_2;
// System.Int32 System.Collections.Generic.Dictionary`2::version
int32_t ___version_3;
// System.Int32 System.Collections.Generic.Dictionary`2::freeList
int32_t ___freeList_4;
// System.Int32 System.Collections.Generic.Dictionary`2::freeCount
int32_t ___freeCount_5;
// System.Collections.Generic.IEqualityComparer`1<TKey> System.Collections.Generic.Dictionary`2::comparer
RuntimeObject* ___comparer_6;
// System.Collections.Generic.Dictionary`2_KeyCollection<TKey,TValue> System.Collections.Generic.Dictionary`2::keys
KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D * ___keys_7;
// System.Collections.Generic.Dictionary`2_ValueCollection<TKey,TValue> System.Collections.Generic.Dictionary`2::values
ValueCollection_t9161A5C97376D261665798FA27DAFD5177305C81 * ___values_8;
// System.Object System.Collections.Generic.Dictionary`2::_syncRoot
RuntimeObject * ____syncRoot_9;
public:
inline static int32_t get_offset_of_buckets_0() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___buckets_0)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_buckets_0() const { return ___buckets_0; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_buckets_0() { return &___buckets_0; }
inline void set_buckets_0(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___buckets_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___buckets_0), (void*)value);
}
inline static int32_t get_offset_of_entries_1() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___entries_1)); }
inline EntryU5BU5D_t52A654EA9927D1B5F56CA05CF209F2E4393C4510* get_entries_1() const { return ___entries_1; }
inline EntryU5BU5D_t52A654EA9927D1B5F56CA05CF209F2E4393C4510** get_address_of_entries_1() { return &___entries_1; }
inline void set_entries_1(EntryU5BU5D_t52A654EA9927D1B5F56CA05CF209F2E4393C4510* value)
{
___entries_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___entries_1), (void*)value);
}
inline static int32_t get_offset_of_count_2() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___count_2)); }
inline int32_t get_count_2() const { return ___count_2; }
inline int32_t* get_address_of_count_2() { return &___count_2; }
inline void set_count_2(int32_t value)
{
___count_2 = value;
}
inline static int32_t get_offset_of_version_3() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___version_3)); }
inline int32_t get_version_3() const { return ___version_3; }
inline int32_t* get_address_of_version_3() { return &___version_3; }
inline void set_version_3(int32_t value)
{
___version_3 = value;
}
inline static int32_t get_offset_of_freeList_4() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___freeList_4)); }
inline int32_t get_freeList_4() const { return ___freeList_4; }
inline int32_t* get_address_of_freeList_4() { return &___freeList_4; }
inline void set_freeList_4(int32_t value)
{
___freeList_4 = value;
}
inline static int32_t get_offset_of_freeCount_5() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___freeCount_5)); }
inline int32_t get_freeCount_5() const { return ___freeCount_5; }
inline int32_t* get_address_of_freeCount_5() { return &___freeCount_5; }
inline void set_freeCount_5(int32_t value)
{
___freeCount_5 = value;
}
inline static int32_t get_offset_of_comparer_6() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___comparer_6)); }
inline RuntimeObject* get_comparer_6() const { return ___comparer_6; }
inline RuntimeObject** get_address_of_comparer_6() { return &___comparer_6; }
inline void set_comparer_6(RuntimeObject* value)
{
___comparer_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___comparer_6), (void*)value);
}
inline static int32_t get_offset_of_keys_7() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___keys_7)); }
inline KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D * get_keys_7() const { return ___keys_7; }
inline KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D ** get_address_of_keys_7() { return &___keys_7; }
inline void set_keys_7(KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D * value)
{
___keys_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keys_7), (void*)value);
}
inline static int32_t get_offset_of_values_8() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ___values_8)); }
inline ValueCollection_t9161A5C97376D261665798FA27DAFD5177305C81 * get_values_8() const { return ___values_8; }
inline ValueCollection_t9161A5C97376D261665798FA27DAFD5177305C81 ** get_address_of_values_8() { return &___values_8; }
inline void set_values_8(ValueCollection_t9161A5C97376D261665798FA27DAFD5177305C81 * value)
{
___values_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___values_8), (void*)value);
}
inline static int32_t get_offset_of__syncRoot_9() { return static_cast<int32_t>(offsetof(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5, ____syncRoot_9)); }
inline RuntimeObject * get__syncRoot_9() const { return ____syncRoot_9; }
inline RuntimeObject ** get_address_of__syncRoot_9() { return &____syncRoot_9; }
inline void set__syncRoot_9(RuntimeObject * value)
{
____syncRoot_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_9), (void*)value);
}
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// UnityEngine.CustomYieldInstruction
struct CustomYieldInstruction_t4ED1543FBAA3143362854EB1867B42E5D190A5C7 : public RuntimeObject
{
public:
public:
};
// UnityEngine.WWWForm
struct WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB : public RuntimeObject
{
public:
// System.Collections.Generic.List`1<System.Byte[]> UnityEngine.WWWForm::formData
List_1_t08E192A6E99857FD75EAA081A5D3BEC33729EDBE * ___formData_0;
// System.Collections.Generic.List`1<System.String> UnityEngine.WWWForm::fieldNames
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___fieldNames_1;
// System.Collections.Generic.List`1<System.String> UnityEngine.WWWForm::fileNames
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___fileNames_2;
// System.Collections.Generic.List`1<System.String> UnityEngine.WWWForm::types
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___types_3;
// System.Byte[] UnityEngine.WWWForm::boundary
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___boundary_4;
// System.Boolean UnityEngine.WWWForm::containsFiles
bool ___containsFiles_5;
public:
inline static int32_t get_offset_of_formData_0() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___formData_0)); }
inline List_1_t08E192A6E99857FD75EAA081A5D3BEC33729EDBE * get_formData_0() const { return ___formData_0; }
inline List_1_t08E192A6E99857FD75EAA081A5D3BEC33729EDBE ** get_address_of_formData_0() { return &___formData_0; }
inline void set_formData_0(List_1_t08E192A6E99857FD75EAA081A5D3BEC33729EDBE * value)
{
___formData_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___formData_0), (void*)value);
}
inline static int32_t get_offset_of_fieldNames_1() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___fieldNames_1)); }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * get_fieldNames_1() const { return ___fieldNames_1; }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 ** get_address_of_fieldNames_1() { return &___fieldNames_1; }
inline void set_fieldNames_1(List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * value)
{
___fieldNames_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___fieldNames_1), (void*)value);
}
inline static int32_t get_offset_of_fileNames_2() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___fileNames_2)); }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * get_fileNames_2() const { return ___fileNames_2; }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 ** get_address_of_fileNames_2() { return &___fileNames_2; }
inline void set_fileNames_2(List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * value)
{
___fileNames_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___fileNames_2), (void*)value);
}
inline static int32_t get_offset_of_types_3() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___types_3)); }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * get_types_3() const { return ___types_3; }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 ** get_address_of_types_3() { return &___types_3; }
inline void set_types_3(List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * value)
{
___types_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___types_3), (void*)value);
}
inline static int32_t get_offset_of_boundary_4() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___boundary_4)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_boundary_4() const { return ___boundary_4; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_boundary_4() { return &___boundary_4; }
inline void set_boundary_4(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___boundary_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___boundary_4), (void*)value);
}
inline static int32_t get_offset_of_containsFiles_5() { return static_cast<int32_t>(offsetof(WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB, ___containsFiles_5)); }
inline bool get_containsFiles_5() const { return ___containsFiles_5; }
inline bool* get_address_of_containsFiles_5() { return &___containsFiles_5; }
inline void set_containsFiles_5(bool value)
{
___containsFiles_5 = value;
}
};
// UnityEngine.YieldInstruction
struct YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of UnityEngine.YieldInstruction
struct YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of UnityEngine.YieldInstruction
struct YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF_marshaled_com
{
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Byte
struct Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>
struct KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.String,System.String>
struct KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
String_t* ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
String_t* ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC, ___key_0)); }
inline String_t* get_key_0() const { return ___key_0; }
inline String_t** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(String_t* value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC, ___value_1)); }
inline String_t* get_value_1() const { return ___value_1; }
inline String_t** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(String_t* value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// System.Int32
struct Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.Int64
struct Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5
{
public:
union
{
struct
{
};
uint8_t Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5__padding[1];
};
public:
};
// UnityEngine.WWW
struct WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 : public CustomYieldInstruction_t4ED1543FBAA3143362854EB1867B42E5D190A5C7
{
public:
// UnityEngine.Networking.UnityWebRequest UnityEngine.WWW::_uwr
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * ____uwr_0;
public:
inline static int32_t get_offset_of__uwr_0() { return static_cast<int32_t>(offsetof(WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2, ____uwr_0)); }
inline UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * get__uwr_0() const { return ____uwr_0; }
inline UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E ** get_address_of__uwr_0() { return &____uwr_0; }
inline void set__uwr_0(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * value)
{
____uwr_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____uwr_0), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2_Enumerator<System.Object,System.Object>
struct Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2_Enumerator::dictionary
Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D * ___dictionary_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::version
int32_t ___version_1;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::index
int32_t ___index_2;
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2_Enumerator::current
KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___current_3;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::getEnumeratorRetType
int32_t ___getEnumeratorRetType_4;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0, ___dictionary_0)); }
inline Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
inline static int32_t get_offset_of_version_1() { return static_cast<int32_t>(offsetof(Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0, ___version_1)); }
inline int32_t get_version_1() const { return ___version_1; }
inline int32_t* get_address_of_version_1() { return &___version_1; }
inline void set_version_1(int32_t value)
{
___version_1 = value;
}
inline static int32_t get_offset_of_index_2() { return static_cast<int32_t>(offsetof(Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0, ___index_2)); }
inline int32_t get_index_2() const { return ___index_2; }
inline int32_t* get_address_of_index_2() { return &___index_2; }
inline void set_index_2(int32_t value)
{
___index_2 = value;
}
inline static int32_t get_offset_of_current_3() { return static_cast<int32_t>(offsetof(Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0, ___current_3)); }
inline KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 get_current_3() const { return ___current_3; }
inline KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * get_address_of_current_3() { return &___current_3; }
inline void set_current_3(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 value)
{
___current_3 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___current_3))->___key_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___current_3))->___value_1), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_getEnumeratorRetType_4() { return static_cast<int32_t>(offsetof(Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0, ___getEnumeratorRetType_4)); }
inline int32_t get_getEnumeratorRetType_4() const { return ___getEnumeratorRetType_4; }
inline int32_t* get_address_of_getEnumeratorRetType_4() { return &___getEnumeratorRetType_4; }
inline void set_getEnumeratorRetType_4(int32_t value)
{
___getEnumeratorRetType_4 = value;
}
};
// System.Collections.Generic.Dictionary`2_Enumerator<System.String,System.String>
struct Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2_Enumerator::dictionary
Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * ___dictionary_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::version
int32_t ___version_1;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::index
int32_t ___index_2;
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2_Enumerator::current
KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC ___current_3;
// System.Int32 System.Collections.Generic.Dictionary`2_Enumerator::getEnumeratorRetType
int32_t ___getEnumeratorRetType_4;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB, ___dictionary_0)); }
inline Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
inline static int32_t get_offset_of_version_1() { return static_cast<int32_t>(offsetof(Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB, ___version_1)); }
inline int32_t get_version_1() const { return ___version_1; }
inline int32_t* get_address_of_version_1() { return &___version_1; }
inline void set_version_1(int32_t value)
{
___version_1 = value;
}
inline static int32_t get_offset_of_index_2() { return static_cast<int32_t>(offsetof(Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB, ___index_2)); }
inline int32_t get_index_2() const { return ___index_2; }
inline int32_t* get_address_of_index_2() { return &___index_2; }
inline void set_index_2(int32_t value)
{
___index_2 = value;
}
inline static int32_t get_offset_of_current_3() { return static_cast<int32_t>(offsetof(Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB, ___current_3)); }
inline KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC get_current_3() const { return ___current_3; }
inline KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC * get_address_of_current_3() { return &___current_3; }
inline void set_current_3(KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC value)
{
___current_3 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___current_3))->___key_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___current_3))->___value_1), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_getEnumeratorRetType_4() { return static_cast<int32_t>(offsetof(Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB, ___getEnumeratorRetType_4)); }
inline int32_t get_getEnumeratorRetType_4() const { return ___getEnumeratorRetType_4; }
inline int32_t* get_address_of_getEnumeratorRetType_4() { return &___getEnumeratorRetType_4; }
inline void set_getEnumeratorRetType_4(int32_t value)
{
___getEnumeratorRetType_4 = value;
}
};
// System.StringComparison
struct StringComparison_tCC9F72B9B1E2C3C6D2566DD0D3A61E1621048998
{
public:
// System.Int32 System.StringComparison::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StringComparison_tCC9F72B9B1E2C3C6D2566DD0D3A61E1621048998, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.AsyncOperation
struct AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86 : public YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF
{
public:
// System.IntPtr UnityEngine.AsyncOperation::m_Ptr
intptr_t ___m_Ptr_0;
// System.Action`1<UnityEngine.AsyncOperation> UnityEngine.AsyncOperation::m_completeCallback
Action_1_tC1348BEB2C677FD60E4B65764CA3A1CAFF6DFB31 * ___m_completeCallback_1;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
inline static int32_t get_offset_of_m_completeCallback_1() { return static_cast<int32_t>(offsetof(AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86, ___m_completeCallback_1)); }
inline Action_1_tC1348BEB2C677FD60E4B65764CA3A1CAFF6DFB31 * get_m_completeCallback_1() const { return ___m_completeCallback_1; }
inline Action_1_tC1348BEB2C677FD60E4B65764CA3A1CAFF6DFB31 ** get_address_of_m_completeCallback_1() { return &___m_completeCallback_1; }
inline void set_m_completeCallback_1(Action_1_tC1348BEB2C677FD60E4B65764CA3A1CAFF6DFB31 * value)
{
___m_completeCallback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_completeCallback_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.AsyncOperation
struct AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86_marshaled_pinvoke : public YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
Il2CppMethodPointer ___m_completeCallback_1;
};
// Native definition for COM marshalling of UnityEngine.AsyncOperation
struct AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86_marshaled_com : public YieldInstruction_tB0B4E05316710E51ECCC1E57174C27FE6DEBBEAF_marshaled_com
{
intptr_t ___m_Ptr_0;
Il2CppMethodPointer ___m_completeCallback_1;
};
// UnityEngine.Networking.CertificateHandler
struct CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Networking.CertificateHandler::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.CertificateHandler
struct CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
};
// Native definition for COM marshalling of UnityEngine.Networking.CertificateHandler
struct CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E_marshaled_com
{
intptr_t ___m_Ptr_0;
};
// UnityEngine.Networking.DownloadHandler
struct DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Networking.DownloadHandler::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.DownloadHandler
struct DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
};
// Native definition for COM marshalling of UnityEngine.Networking.DownloadHandler
struct DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_com
{
intptr_t ___m_Ptr_0;
};
// UnityEngine.Networking.UnityWebRequest_Result
struct Result_t3233C0F690EC3844C8E0C4649568659679AFBE75
{
public:
// System.Int32 UnityEngine.Networking.UnityWebRequest_Result::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Result_t3233C0F690EC3844C8E0C4649568659679AFBE75, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Networking.UploadHandler
struct UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Networking.UploadHandler::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.UploadHandler
struct UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
};
// Native definition for COM marshalling of UnityEngine.Networking.UploadHandler
struct UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_com
{
intptr_t ___m_Ptr_0;
};
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.Networking.DownloadHandlerBuffer
struct DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D : public DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB
{
public:
public:
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.DownloadHandlerBuffer
struct DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D_marshaled_pinvoke : public DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_pinvoke
{
};
// Native definition for COM marshalling of UnityEngine.Networking.DownloadHandlerBuffer
struct DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D_marshaled_com : public DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_com
{
};
// UnityEngine.Networking.UnityWebRequest
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Networking.UnityWebRequest::m_Ptr
intptr_t ___m_Ptr_0;
// UnityEngine.Networking.DownloadHandler UnityEngine.Networking.UnityWebRequest::m_DownloadHandler
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * ___m_DownloadHandler_1;
// UnityEngine.Networking.UploadHandler UnityEngine.Networking.UnityWebRequest::m_UploadHandler
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * ___m_UploadHandler_2;
// UnityEngine.Networking.CertificateHandler UnityEngine.Networking.UnityWebRequest::m_CertificateHandler
CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E * ___m_CertificateHandler_3;
// System.Uri UnityEngine.Networking.UnityWebRequest::m_Uri
Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 * ___m_Uri_4;
// System.Boolean UnityEngine.Networking.UnityWebRequest::<disposeCertificateHandlerOnDispose>k__BackingField
bool ___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5;
// System.Boolean UnityEngine.Networking.UnityWebRequest::<disposeDownloadHandlerOnDispose>k__BackingField
bool ___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6;
// System.Boolean UnityEngine.Networking.UnityWebRequest::<disposeUploadHandlerOnDispose>k__BackingField
bool ___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
inline static int32_t get_offset_of_m_DownloadHandler_1() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___m_DownloadHandler_1)); }
inline DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * get_m_DownloadHandler_1() const { return ___m_DownloadHandler_1; }
inline DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB ** get_address_of_m_DownloadHandler_1() { return &___m_DownloadHandler_1; }
inline void set_m_DownloadHandler_1(DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * value)
{
___m_DownloadHandler_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DownloadHandler_1), (void*)value);
}
inline static int32_t get_offset_of_m_UploadHandler_2() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___m_UploadHandler_2)); }
inline UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * get_m_UploadHandler_2() const { return ___m_UploadHandler_2; }
inline UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA ** get_address_of_m_UploadHandler_2() { return &___m_UploadHandler_2; }
inline void set_m_UploadHandler_2(UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * value)
{
___m_UploadHandler_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_UploadHandler_2), (void*)value);
}
inline static int32_t get_offset_of_m_CertificateHandler_3() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___m_CertificateHandler_3)); }
inline CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E * get_m_CertificateHandler_3() const { return ___m_CertificateHandler_3; }
inline CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E ** get_address_of_m_CertificateHandler_3() { return &___m_CertificateHandler_3; }
inline void set_m_CertificateHandler_3(CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E * value)
{
___m_CertificateHandler_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CertificateHandler_3), (void*)value);
}
inline static int32_t get_offset_of_m_Uri_4() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___m_Uri_4)); }
inline Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 * get_m_Uri_4() const { return ___m_Uri_4; }
inline Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 ** get_address_of_m_Uri_4() { return &___m_Uri_4; }
inline void set_m_Uri_4(Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 * value)
{
___m_Uri_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Uri_4), (void*)value);
}
inline static int32_t get_offset_of_U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5)); }
inline bool get_U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5() const { return ___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5; }
inline bool* get_address_of_U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5() { return &___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5; }
inline void set_U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5(bool value)
{
___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5 = value;
}
inline static int32_t get_offset_of_U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6)); }
inline bool get_U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6() const { return ___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6; }
inline bool* get_address_of_U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6() { return &___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6; }
inline void set_U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6(bool value)
{
___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6 = value;
}
inline static int32_t get_offset_of_U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7() { return static_cast<int32_t>(offsetof(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E, ___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7)); }
inline bool get_U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7() const { return ___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7; }
inline bool* get_address_of_U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7() { return &___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7; }
inline void set_U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7(bool value)
{
___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.UnityWebRequest
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_pinvoke ___m_DownloadHandler_1;
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_pinvoke ___m_UploadHandler_2;
CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E_marshaled_pinvoke ___m_CertificateHandler_3;
Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 * ___m_Uri_4;
int32_t ___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5;
int32_t ___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6;
int32_t ___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7;
};
// Native definition for COM marshalling of UnityEngine.Networking.UnityWebRequest
struct UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_com
{
intptr_t ___m_Ptr_0;
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB_marshaled_com* ___m_DownloadHandler_1;
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_com* ___m_UploadHandler_2;
CertificateHandler_tDA66C86D1302CE4266DBB078361F7A363C7B005E_marshaled_com* ___m_CertificateHandler_3;
Uri_t4A915E1CC15B2C650F478099AD448E9466CBF612 * ___m_Uri_4;
int32_t ___U3CdisposeCertificateHandlerOnDisposeU3Ek__BackingField_5;
int32_t ___U3CdisposeDownloadHandlerOnDisposeU3Ek__BackingField_6;
int32_t ___U3CdisposeUploadHandlerOnDisposeU3Ek__BackingField_7;
};
// UnityEngine.Networking.UnityWebRequestAsyncOperation
struct UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396 : public AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86
{
public:
// UnityEngine.Networking.UnityWebRequest UnityEngine.Networking.UnityWebRequestAsyncOperation::<webRequest>k__BackingField
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * ___U3CwebRequestU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CwebRequestU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396, ___U3CwebRequestU3Ek__BackingField_2)); }
inline UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * get_U3CwebRequestU3Ek__BackingField_2() const { return ___U3CwebRequestU3Ek__BackingField_2; }
inline UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E ** get_address_of_U3CwebRequestU3Ek__BackingField_2() { return &___U3CwebRequestU3Ek__BackingField_2; }
inline void set_U3CwebRequestU3Ek__BackingField_2(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * value)
{
___U3CwebRequestU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CwebRequestU3Ek__BackingField_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.UnityWebRequestAsyncOperation
struct UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396_marshaled_pinvoke : public AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86_marshaled_pinvoke
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_pinvoke* ___U3CwebRequestU3Ek__BackingField_2;
};
// Native definition for COM marshalling of UnityEngine.Networking.UnityWebRequestAsyncOperation
struct UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396_marshaled_com : public AsyncOperation_tB6913CEC83169F22E96067CE8C7117A221E51A86_marshaled_com
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_marshaled_com* ___U3CwebRequestU3Ek__BackingField_2;
};
// UnityEngine.Networking.UploadHandlerRaw
struct UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669 : public UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA
{
public:
public:
};
// Native definition for P/Invoke marshalling of UnityEngine.Networking.UploadHandlerRaw
struct UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669_marshaled_pinvoke : public UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of UnityEngine.Networking.UploadHandlerRaw
struct UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669_marshaled_com : public UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA_marshaled_com
{
};
// UnityEngine.Texture
struct Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
struct Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE_StaticFields
{
public:
// System.Int32 UnityEngine.Texture::GenerateAllMips
int32_t ___GenerateAllMips_4;
public:
inline static int32_t get_offset_of_GenerateAllMips_4() { return static_cast<int32_t>(offsetof(Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE_StaticFields, ___GenerateAllMips_4)); }
inline int32_t get_GenerateAllMips_4() const { return ___GenerateAllMips_4; }
inline int32_t* get_address_of_GenerateAllMips_4() { return &___GenerateAllMips_4; }
inline void set_GenerateAllMips_4(int32_t value)
{
___GenerateAllMips_4 = value;
}
};
// UnityEngine.Texture2D
struct Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF : public Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
// System.Collections.Generic.Dictionary`2/Enumerator<!0,!1> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::GetEnumerator()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0 Dictionary_2_GetEnumerator_mA44BBB15DFBD8E08B5E60E23AA5044D45C3F889F_gshared (Dictionary_2_tBD1E3221EBD04CEBDA49B84779912E91F56B958D * __this, const RuntimeMethod* method);
// System.Collections.Generic.KeyValuePair`2<!0,!1> System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::get_Current()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 Enumerator_get_Current_m17E1C36ECBB09CC2AB892710866F8655D83A6048_gshared_inline (Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0 * __this, const RuntimeMethod* method);
// !0 System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::get_Key()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * KeyValuePair_2_get_Key_mCAD7B121DB998D7C56EB0281215A860EFE9DCD95_gshared_inline (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * __this, const RuntimeMethod* method);
// !1 System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::get_Value()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * KeyValuePair_2_get_Value_m622223593F7461E7812C581DDB145270016ED303_gshared_inline (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * __this, const RuntimeMethod* method);
// System.Boolean System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Enumerator_MoveNext_mCAD84084129516BD41DE5CC3E1FABA5A8DF836D0_gshared (Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0 * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Enumerator_Dispose_m85CA135BAB22C9F0C87C84AB90FF6740D1859279_gshared (Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.CustomYieldInstruction::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CustomYieldInstruction__ctor_m01929E3EEB78B751510038B32D889061960DA1BE (CustomYieldInstruction_t4ED1543FBAA3143362854EB1867B42E5D190A5C7 * __this, const RuntimeMethod* method);
// UnityEngine.Networking.UnityWebRequest UnityEngine.Networking.UnityWebRequest::Post(System.String,UnityEngine.WWWForm)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * UnityWebRequest_Post_m5F29B83B6FEDEAEAAC938DD26AE484A2750DB646 (String_t* ___uri0, WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB * ___formData1, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UnityWebRequest::set_chunkedTransfer(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest_set_chunkedTransfer_mA743E172FDB5D5892DD6D3AA6836B66CD6233B5B (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, bool ___value0, const RuntimeMethod* method);
// UnityEngine.Networking.UnityWebRequestAsyncOperation UnityEngine.Networking.UnityWebRequest::SendWebRequest()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UnityWebRequestAsyncOperation_tDCAC6B6C7D51563F8DFD4963E3BE362470125396 * UnityWebRequest_SendWebRequest_m990921023F56ECB8FF8C118894A317EB6E2F5B50 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UnityWebRequest::.ctor(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest__ctor_mC2ED369A4ACE53AFF2E70A38BE95EB48D68D4975 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, String_t* ___url0, String_t* ___method1, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UploadHandlerRaw::.ctor(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UploadHandlerRaw__ctor_mB46261D7AA64B605D5CA8FF9027A4A32E57A7BD9 (UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669 * __this, ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___data0, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UploadHandler::set_contentType(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UploadHandler_set_contentType_mAECD24AB554541300BD126E01C65329F0A29A328 (UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * __this, String_t* ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UnityWebRequest::set_uploadHandler(UnityEngine.Networking.UploadHandler)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest_set_uploadHandler_m8D5DF24FBE7F8F0DCF27E11CE3C6CF4363DF23BA (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.DownloadHandlerBuffer::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DownloadHandlerBuffer__ctor_m01FD35970E4B4FC45FC99A648408F53A8B164774 (DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UnityWebRequest::set_downloadHandler(UnityEngine.Networking.DownloadHandler)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest_set_downloadHandler_m7496D2C5F755BEB68651A4F33EA9BDA319D092C2 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * ___value0, const RuntimeMethod* method);
// System.Collections.Generic.Dictionary`2/Enumerator<!0,!1> System.Collections.Generic.Dictionary`2<System.String,System.String>::GetEnumerator()
inline Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB Dictionary_2_GetEnumerator_m8C0A038B5FA7E62DEF4DB9EF1F5FCC4348D785C5 (Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * __this, const RuntimeMethod* method)
{
return (( Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB (*) (Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 *, const RuntimeMethod*))Dictionary_2_GetEnumerator_mA44BBB15DFBD8E08B5E60E23AA5044D45C3F889F_gshared)(__this, method);
}
// System.Collections.Generic.KeyValuePair`2<!0,!1> System.Collections.Generic.Dictionary`2/Enumerator<System.String,System.String>::get_Current()
inline KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC Enumerator_get_Current_m45394A0B01FA26CB32851562F9CBF27DB35FF4DD_inline (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC (*) (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *, const RuntimeMethod*))Enumerator_get_Current_m17E1C36ECBB09CC2AB892710866F8655D83A6048_gshared_inline)(__this, method);
}
// !0 System.Collections.Generic.KeyValuePair`2<System.String,System.String>::get_Key()
inline String_t* KeyValuePair_2_get_Key_m42802FFFC275E928911F87B16DFE504319DF58F1_inline (KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC * __this, const RuntimeMethod* method)
{
return (( String_t* (*) (KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC *, const RuntimeMethod*))KeyValuePair_2_get_Key_mCAD7B121DB998D7C56EB0281215A860EFE9DCD95_gshared_inline)(__this, method);
}
// !1 System.Collections.Generic.KeyValuePair`2<System.String,System.String>::get_Value()
inline String_t* KeyValuePair_2_get_Value_mB6B24D3920A4744624F8ED9AE493783D0E5F81DD_inline (KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC * __this, const RuntimeMethod* method)
{
return (( String_t* (*) (KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC *, const RuntimeMethod*))KeyValuePair_2_get_Value_m622223593F7461E7812C581DDB145270016ED303_gshared_inline)(__this, method);
}
// System.Void UnityEngine.Networking.UnityWebRequest::SetRequestHeader(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest_SetRequestHeader_m5ED4EFBACC106390DF5D81D19E4D4D9D59F13EFB (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, String_t* ___name0, String_t* ___value1, const RuntimeMethod* method);
// System.Boolean System.Collections.Generic.Dictionary`2/Enumerator<System.String,System.String>::MoveNext()
inline bool Enumerator_MoveNext_mA57D4325DBD9D10EB3E43C99CC18DB6C3CE85FC8 (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB * __this, const RuntimeMethod* method)
{
return (( bool (*) (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *, const RuntimeMethod*))Enumerator_MoveNext_mCAD84084129516BD41DE5CC3E1FABA5A8DF836D0_gshared)(__this, method);
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.String,System.String>::Dispose()
inline void Enumerator_Dispose_m76E867298698AA2B89F9D57E21CEFCD16B372D22 (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB * __this, const RuntimeMethod* method)
{
(( void (*) (Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *, const RuntimeMethod*))Enumerator_Dispose_m85CA135BAB22C9F0C87C84AB90FF6740D1859279_gshared)(__this, method);
}
// System.Boolean UnityEngine.Networking.UnityWebRequest::get_isDone()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UnityWebRequest_get_isDone_mF8C92D10767B80877BCFE6D119CBE9090ACCDFBD (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// UnityEngine.Networking.UnityWebRequest/Result UnityEngine.Networking.UnityWebRequest::get_result()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnityWebRequest_get_result_m4E9272AB25BD5CE7B927F4B1873763510476BDC6 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.String UnityEngine.Networking.UnityWebRequest::get_error()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UnityWebRequest_get_error_m32B69D2365C1FE2310B5936C7C295B71A92CC2B4 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.Int64 UnityEngine.Networking.UnityWebRequest::get_responseCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UnityWebRequest_get_responseCode_m27D1260ADC92070608532D81B836CAA2742D1753 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.String UnityEngine.Networking.UnityWebRequest::GetHTTPStatusString(System.Int64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UnityWebRequest_GetHTTPStatusString_m317BB359DAAE3592F55F8C989FC076FEA76BC7C0 (int64_t ___responseCode0, const RuntimeMethod* method);
// System.String System.String::Format(System.String,System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Format_m8D1CB0410C35E052A53AE957C914C841E54BAB66 (String_t* ___format0, RuntimeObject * ___arg01, RuntimeObject * ___arg12, const RuntimeMethod* method);
// System.Boolean UnityEngine.WWW::WaitUntilDoneIfPossible()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method);
// UnityEngine.Networking.DownloadHandler UnityEngine.Networking.UnityWebRequest::get_downloadHandler()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * UnityWebRequest_get_downloadHandler_mCE0A0C53A63419FE5AE25915AFB36EABE294C732 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.String UnityEngine.Networking.DownloadHandler::get_text()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* DownloadHandler_get_text_mD89D7125640800A8F5C4B9401C080C405953828A (DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Texture2D::.ctor(System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Texture2D__ctor_m7D64AB4C55A01F2EE57483FD9EF826607DF9E4B4 (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * __this, int32_t ___width0, int32_t ___height1, const RuntimeMethod* method);
// System.Byte[] UnityEngine.Networking.DownloadHandler::get_data()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* DownloadHandler_get_data_m3AE551AAE6BF21279435D386E76EA7084CC037D3 (DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * __this, const RuntimeMethod* method);
// System.Boolean UnityEngine.ImageConversion::LoadImage(UnityEngine.Texture2D,System.Byte[],System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ImageConversion_LoadImage_m1E5C9BF6206ED40B23CDB28341B8A64E05C43683 (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * ___tex0, ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___data1, bool ___markNonReadable2, const RuntimeMethod* method);
// UnityEngine.Texture2D UnityEngine.WWW::CreateTextureFromDownloadedData(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * WWW_CreateTextureFromDownloadedData_m978F4A746B24EEA580E7AA8F1F05203196A299F9 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, bool ___markNonReadable0, const RuntimeMethod* method);
// System.String UnityEngine.Networking.UnityWebRequest::get_url()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UnityWebRequest_get_url_m802F6A7942362F28F2D856F17B2BDF8C2561734E (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.UnityWebRequest::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityWebRequest_Dispose_m8032472F6BC2EC4FEE017DE7E4C440078BC4E1C8 (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * __this, const RuntimeMethod* method);
// System.String UnityEngine.WWW::get_url()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* WWW_get_url_m1D75D492D78A7AA8F607C5D7700497B8FE5E9526 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method);
// System.Boolean System.String::StartsWith(System.String,System.StringComparison)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool String_StartsWith_mEA750A0572C706249CDD826681741B7DD733381E (String_t* __this, String_t* ___value0, int32_t ___comparisonType1, const RuntimeMethod* method);
// System.Void UnityEngine.Debug::LogError(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Debug_LogError_m8850D65592770A364D494025FF3A73E8D4D70485 (RuntimeObject * ___message0, const RuntimeMethod* method);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.WWW::.ctor(System.String,UnityEngine.WWWForm)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WWW__ctor_m2F58987EB716A6D1B9B2425464E5C42FB6CF7DE6 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, String_t* ___url0, WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB * ___form1, const RuntimeMethod* method)
{
{
CustomYieldInstruction__ctor_m01929E3EEB78B751510038B32D889061960DA1BE(__this, /*hidden argument*/NULL);
String_t* L_0 = ___url0;
WWWForm_t078274293DA1BDA9AB5689AF8BCBF0EE17A2BABB * L_1 = ___form1;
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_2 = UnityWebRequest_Post_m5F29B83B6FEDEAEAAC938DD26AE484A2750DB646(L_0, L_1, /*hidden argument*/NULL);
__this->set__uwr_0(L_2);
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_3 = __this->get__uwr_0();
NullCheck(L_3);
UnityWebRequest_set_chunkedTransfer_mA743E172FDB5D5892DD6D3AA6836B66CD6233B5B(L_3, (bool)0, /*hidden argument*/NULL);
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_4 = __this->get__uwr_0();
NullCheck(L_4);
UnityWebRequest_SendWebRequest_m990921023F56ECB8FF8C118894A317EB6E2F5B50(L_4, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.WWW::.ctor(System.String,System.Byte[],System.Collections.Generic.Dictionary`2<System.String,System.String>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WWW__ctor_m6686CBC878BB9EB28F4C4171C203CA4E3DE3656C (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, String_t* ___url0, ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___postData1, Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * ___headers2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WWW__ctor_m6686CBC878BB9EB28F4C4171C203CA4E3DE3656C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * V_1 = NULL;
Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB V_2;
memset((&V_2), 0, sizeof(V_2));
KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC V_3;
memset((&V_3), 0, sizeof(V_3));
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
void* __leave_targets_storage = alloca(sizeof(int32_t) * 1);
il2cpp::utils::LeaveTargetStack __leave_targets(__leave_targets_storage);
NO_UNUSED_WARNING (__leave_targets);
String_t* G_B3_0 = NULL;
{
CustomYieldInstruction__ctor_m01929E3EEB78B751510038B32D889061960DA1BE(__this, /*hidden argument*/NULL);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_0 = ___postData1;
if (!L_0)
{
goto IL_0012;
}
}
{
G_B3_0 = _stringLiteral14E338D17C42E552FA7AF42CDAE40CA1F0E8A04D;
goto IL_0017;
}
IL_0012:
{
G_B3_0 = _stringLiteral3781CFEEF925855A4B7284E1783A7D715A6333F6;
}
IL_0017:
{
V_0 = G_B3_0;
String_t* L_1 = ___url0;
String_t* L_2 = V_0;
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_3 = (UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E *)il2cpp_codegen_object_new(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E_il2cpp_TypeInfo_var);
UnityWebRequest__ctor_mC2ED369A4ACE53AFF2E70A38BE95EB48D68D4975(L_3, L_1, L_2, /*hidden argument*/NULL);
__this->set__uwr_0(L_3);
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_4 = __this->get__uwr_0();
NullCheck(L_4);
UnityWebRequest_set_chunkedTransfer_mA743E172FDB5D5892DD6D3AA6836B66CD6233B5B(L_4, (bool)0, /*hidden argument*/NULL);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_5 = ___postData1;
UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669 * L_6 = (UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669 *)il2cpp_codegen_object_new(UploadHandlerRaw_t398466F5905D0829DE2807D531A2419DA8B61669_il2cpp_TypeInfo_var);
UploadHandlerRaw__ctor_mB46261D7AA64B605D5CA8FF9027A4A32E57A7BD9(L_6, L_5, /*hidden argument*/NULL);
V_1 = L_6;
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * L_7 = V_1;
NullCheck(L_7);
UploadHandler_set_contentType_mAECD24AB554541300BD126E01C65329F0A29A328(L_7, _stringLiteral14B6DF3349D302FD20ED0B3BD448C2045066E9BE, /*hidden argument*/NULL);
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_8 = __this->get__uwr_0();
UploadHandler_t5F80A2A6874D4D330751BE3524009C21C9B74BDA * L_9 = V_1;
NullCheck(L_8);
UnityWebRequest_set_uploadHandler_m8D5DF24FBE7F8F0DCF27E11CE3C6CF4363DF23BA(L_8, L_9, /*hidden argument*/NULL);
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_10 = __this->get__uwr_0();
DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D * L_11 = (DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D *)il2cpp_codegen_object_new(DownloadHandlerBuffer_t74D11E891308B7FD5255C8D0D876AD0DBF512B6D_il2cpp_TypeInfo_var);
DownloadHandlerBuffer__ctor_m01FD35970E4B4FC45FC99A648408F53A8B164774(L_11, /*hidden argument*/NULL);
NullCheck(L_10);
UnityWebRequest_set_downloadHandler_m7496D2C5F755BEB68651A4F33EA9BDA319D092C2(L_10, L_11, /*hidden argument*/NULL);
Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * L_12 = ___headers2;
NullCheck(L_12);
Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB L_13 = Dictionary_2_GetEnumerator_m8C0A038B5FA7E62DEF4DB9EF1F5FCC4348D785C5(L_12, /*hidden argument*/Dictionary_2_GetEnumerator_m8C0A038B5FA7E62DEF4DB9EF1F5FCC4348D785C5_RuntimeMethod_var);
V_2 = L_13;
}
IL_006b:
try
{ // begin try (depth: 1)
{
goto IL_008f;
}
IL_006d:
{
KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC L_14 = Enumerator_get_Current_m45394A0B01FA26CB32851562F9CBF27DB35FF4DD_inline((Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *)(&V_2), /*hidden argument*/Enumerator_get_Current_m45394A0B01FA26CB32851562F9CBF27DB35FF4DD_RuntimeMethod_var);
V_3 = L_14;
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_15 = __this->get__uwr_0();
String_t* L_16 = KeyValuePair_2_get_Key_m42802FFFC275E928911F87B16DFE504319DF58F1_inline((KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC *)(&V_3), /*hidden argument*/KeyValuePair_2_get_Key_m42802FFFC275E928911F87B16DFE504319DF58F1_RuntimeMethod_var);
String_t* L_17 = KeyValuePair_2_get_Value_mB6B24D3920A4744624F8ED9AE493783D0E5F81DD_inline((KeyValuePair_2_tE863694F1DB1F441CAE5A282829BDB941B2DEEBC *)(&V_3), /*hidden argument*/KeyValuePair_2_get_Value_mB6B24D3920A4744624F8ED9AE493783D0E5F81DD_RuntimeMethod_var);
NullCheck(L_15);
UnityWebRequest_SetRequestHeader_m5ED4EFBACC106390DF5D81D19E4D4D9D59F13EFB(L_15, L_16, L_17, /*hidden argument*/NULL);
}
IL_008f:
{
bool L_18 = Enumerator_MoveNext_mA57D4325DBD9D10EB3E43C99CC18DB6C3CE85FC8((Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *)(&V_2), /*hidden argument*/Enumerator_MoveNext_mA57D4325DBD9D10EB3E43C99CC18DB6C3CE85FC8_RuntimeMethod_var);
if (L_18)
{
goto IL_006d;
}
}
IL_0098:
{
IL2CPP_LEAVE(0xA9, FINALLY_009a);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_009a;
}
FINALLY_009a:
{ // begin finally (depth: 1)
Enumerator_Dispose_m76E867298698AA2B89F9D57E21CEFCD16B372D22((Enumerator_tEDF5E503528903FB9B9A1D645C82789D7B8006CB *)(&V_2), /*hidden argument*/Enumerator_Dispose_m76E867298698AA2B89F9D57E21CEFCD16B372D22_RuntimeMethod_var);
IL2CPP_END_FINALLY(154)
} // end finally (depth: 1)
IL2CPP_CLEANUP(154)
{
IL2CPP_JUMP_TBL(0xA9, IL_00a9)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_00a9:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_19 = __this->get__uwr_0();
NullCheck(L_19);
UnityWebRequest_SendWebRequest_m990921023F56ECB8FF8C118894A317EB6E2F5B50(L_19, /*hidden argument*/NULL);
return;
}
}
// System.String UnityEngine.WWW::get_error()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* WWW_get_error_mB278F5EC90EF99FEF70D80112940CFB49E79C9BC (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WWW_get_error_mB278F5EC90EF99FEF70D80112940CFB49E79C9BC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
String_t* V_1 = NULL;
bool V_2 = false;
bool V_3 = false;
String_t* V_4 = NULL;
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_0 = __this->get__uwr_0();
NullCheck(L_0);
bool L_1 = UnityWebRequest_get_isDone_mF8C92D10767B80877BCFE6D119CBE9090ACCDFBD(L_0, /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_1) == ((int32_t)0))? 1 : 0);
bool L_2 = V_0;
if (!L_2)
{
goto IL_0017;
}
}
{
V_1 = (String_t*)NULL;
goto IL_0087;
}
IL_0017:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_3 = __this->get__uwr_0();
NullCheck(L_3);
int32_t L_4 = UnityWebRequest_get_result_m4E9272AB25BD5CE7B927F4B1873763510476BDC6(L_3, /*hidden argument*/NULL);
V_2 = (bool)((((int32_t)L_4) == ((int32_t)2))? 1 : 0);
bool L_5 = V_2;
if (!L_5)
{
goto IL_0037;
}
}
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_6 = __this->get__uwr_0();
NullCheck(L_6);
String_t* L_7 = UnityWebRequest_get_error_m32B69D2365C1FE2310B5936C7C295B71A92CC2B4(L_6, /*hidden argument*/NULL);
V_1 = L_7;
goto IL_0087;
}
IL_0037:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_8 = __this->get__uwr_0();
NullCheck(L_8);
int64_t L_9 = UnityWebRequest_get_responseCode_m27D1260ADC92070608532D81B836CAA2742D1753(L_8, /*hidden argument*/NULL);
V_3 = (bool)((((int32_t)((((int64_t)L_9) < ((int64_t)(((int64_t)((int64_t)((int32_t)400))))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_10 = V_3;
if (!L_10)
{
goto IL_0083;
}
}
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_11 = __this->get__uwr_0();
NullCheck(L_11);
int64_t L_12 = UnityWebRequest_get_responseCode_m27D1260ADC92070608532D81B836CAA2742D1753(L_11, /*hidden argument*/NULL);
String_t* L_13 = UnityWebRequest_GetHTTPStatusString_m317BB359DAAE3592F55F8C989FC076FEA76BC7C0(L_12, /*hidden argument*/NULL);
V_4 = L_13;
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_14 = __this->get__uwr_0();
NullCheck(L_14);
int64_t L_15 = UnityWebRequest_get_responseCode_m27D1260ADC92070608532D81B836CAA2742D1753(L_14, /*hidden argument*/NULL);
int64_t L_16 = L_15;
RuntimeObject * L_17 = Box(Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3_il2cpp_TypeInfo_var, &L_16);
String_t* L_18 = V_4;
String_t* L_19 = String_Format_m8D1CB0410C35E052A53AE957C914C841E54BAB66(_stringLiteral8E752B76D455A50FE476984D4B09A7CDBF2A753E, L_17, L_18, /*hidden argument*/NULL);
V_1 = L_19;
goto IL_0087;
}
IL_0083:
{
V_1 = (String_t*)NULL;
goto IL_0087;
}
IL_0087:
{
String_t* L_20 = V_1;
return L_20;
}
}
// System.String UnityEngine.WWW::get_text()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* WWW_get_text_m0D2EF7BBFB58E37FE30A665389355ACA65804138 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WWW_get_text_m0D2EF7BBFB58E37FE30A665389355ACA65804138_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * V_0 = NULL;
bool V_1 = false;
String_t* V_2 = NULL;
bool V_3 = false;
bool V_4 = false;
{
bool L_0 = WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D(__this, /*hidden argument*/NULL);
V_1 = (bool)((((int32_t)L_0) == ((int32_t)0))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0016;
}
}
{
V_2 = _stringLiteralDA39A3EE5E6B4B0D3255BFEF95601890AFD80709;
goto IL_0057;
}
IL_0016:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_2 = __this->get__uwr_0();
NullCheck(L_2);
int32_t L_3 = UnityWebRequest_get_result_m4E9272AB25BD5CE7B927F4B1873763510476BDC6(L_2, /*hidden argument*/NULL);
V_3 = (bool)((((int32_t)L_3) == ((int32_t)2))? 1 : 0);
bool L_4 = V_3;
if (!L_4)
{
goto IL_0030;
}
}
{
V_2 = _stringLiteralDA39A3EE5E6B4B0D3255BFEF95601890AFD80709;
goto IL_0057;
}
IL_0030:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_5 = __this->get__uwr_0();
NullCheck(L_5);
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_6 = UnityWebRequest_get_downloadHandler_mCE0A0C53A63419FE5AE25915AFB36EABE294C732(L_5, /*hidden argument*/NULL);
V_0 = L_6;
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_7 = V_0;
V_4 = (bool)((((RuntimeObject*)(DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB *)L_7) == ((RuntimeObject*)(RuntimeObject *)NULL))? 1 : 0);
bool L_8 = V_4;
if (!L_8)
{
goto IL_004e;
}
}
{
V_2 = _stringLiteralDA39A3EE5E6B4B0D3255BFEF95601890AFD80709;
goto IL_0057;
}
IL_004e:
{
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_9 = V_0;
NullCheck(L_9);
String_t* L_10 = DownloadHandler_get_text_mD89D7125640800A8F5C4B9401C080C405953828A(L_9, /*hidden argument*/NULL);
V_2 = L_10;
goto IL_0057;
}
IL_0057:
{
String_t* L_11 = V_2;
return L_11;
}
}
// UnityEngine.Texture2D UnityEngine.WWW::CreateTextureFromDownloadedData(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * WWW_CreateTextureFromDownloadedData_m978F4A746B24EEA580E7AA8F1F05203196A299F9 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, bool ___markNonReadable0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WWW_CreateTextureFromDownloadedData_m978F4A746B24EEA580E7AA8F1F05203196A299F9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * V_0 = NULL;
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * V_1 = NULL;
bool V_2 = false;
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * V_3 = NULL;
bool V_4 = false;
bool V_5 = false;
{
bool L_0 = WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D(__this, /*hidden argument*/NULL);
V_2 = (bool)((((int32_t)L_0) == ((int32_t)0))? 1 : 0);
bool L_1 = V_2;
if (!L_1)
{
goto IL_0018;
}
}
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_2 = (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF *)il2cpp_codegen_object_new(Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF_il2cpp_TypeInfo_var);
Texture2D__ctor_m7D64AB4C55A01F2EE57483FD9EF826607DF9E4B4(L_2, 2, 2, /*hidden argument*/NULL);
V_3 = L_2;
goto IL_0064;
}
IL_0018:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_3 = __this->get__uwr_0();
NullCheck(L_3);
int32_t L_4 = UnityWebRequest_get_result_m4E9272AB25BD5CE7B927F4B1873763510476BDC6(L_3, /*hidden argument*/NULL);
V_4 = (bool)((((int32_t)L_4) == ((int32_t)2))? 1 : 0);
bool L_5 = V_4;
if (!L_5)
{
goto IL_0030;
}
}
{
V_3 = (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF *)NULL;
goto IL_0064;
}
IL_0030:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_6 = __this->get__uwr_0();
NullCheck(L_6);
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_7 = UnityWebRequest_get_downloadHandler_mCE0A0C53A63419FE5AE25915AFB36EABE294C732(L_6, /*hidden argument*/NULL);
V_0 = L_7;
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_8 = V_0;
V_5 = (bool)((((RuntimeObject*)(DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB *)L_8) == ((RuntimeObject*)(RuntimeObject *)NULL))? 1 : 0);
bool L_9 = V_5;
if (!L_9)
{
goto IL_004a;
}
}
{
V_3 = (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF *)NULL;
goto IL_0064;
}
IL_004a:
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_10 = (Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF *)il2cpp_codegen_object_new(Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF_il2cpp_TypeInfo_var);
Texture2D__ctor_m7D64AB4C55A01F2EE57483FD9EF826607DF9E4B4(L_10, 2, 2, /*hidden argument*/NULL);
V_1 = L_10;
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_11 = V_1;
DownloadHandler_tEEAE0DD53DB497C8A491C4F7B7A14C3CA027B1DB * L_12 = V_0;
NullCheck(L_12);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_13 = DownloadHandler_get_data_m3AE551AAE6BF21279435D386E76EA7084CC037D3(L_12, /*hidden argument*/NULL);
bool L_14 = ___markNonReadable0;
ImageConversion_LoadImage_m1E5C9BF6206ED40B23CDB28341B8A64E05C43683(L_11, L_13, L_14, /*hidden argument*/NULL);
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_15 = V_1;
V_3 = L_15;
goto IL_0064;
}
IL_0064:
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_16 = V_3;
return L_16;
}
}
// UnityEngine.Texture2D UnityEngine.WWW::get_texture()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * WWW_get_texture_mC23FF88883698F3E6F7BED2733A2DB3B18F788E4 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * V_0 = NULL;
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_0 = WWW_CreateTextureFromDownloadedData_m978F4A746B24EEA580E7AA8F1F05203196A299F9(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000b;
}
IL_000b:
{
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * L_1 = V_0;
return L_1;
}
}
// System.String UnityEngine.WWW::get_url()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* WWW_get_url_m1D75D492D78A7AA8F607C5D7700497B8FE5E9526 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_0 = __this->get__uwr_0();
NullCheck(L_0);
String_t* L_1 = UnityWebRequest_get_url_m802F6A7942362F28F2D856F17B2BDF8C2561734E(L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000f;
}
IL_000f:
{
String_t* L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.WWW::get_keepWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WWW_get_keepWaiting_m231A6A7A835610182D78FC414665CC75195ABD70 (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
bool V_0 = false;
int32_t G_B3_0 = 0;
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_0 = __this->get__uwr_0();
if (!L_0)
{
goto IL_0019;
}
}
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_1 = __this->get__uwr_0();
NullCheck(L_1);
bool L_2 = UnityWebRequest_get_isDone_mF8C92D10767B80877BCFE6D119CBE9090ACCDFBD(L_1, /*hidden argument*/NULL);
G_B3_0 = ((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
goto IL_001a;
}
IL_0019:
{
G_B3_0 = 0;
}
IL_001a:
{
V_0 = (bool)G_B3_0;
goto IL_001d;
}
IL_001d:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.WWW::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WWW_Dispose_mF5A8B944281564903043545BC1E7F1CAD941519F (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
bool V_0 = false;
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_0 = __this->get__uwr_0();
V_0 = (bool)((!(((RuntimeObject*)(UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E *)L_0) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
bool L_1 = V_0;
if (!L_1)
{
goto IL_0023;
}
}
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_2 = __this->get__uwr_0();
NullCheck(L_2);
UnityWebRequest_Dispose_m8032472F6BC2EC4FEE017DE7E4C440078BC4E1C8(L_2, /*hidden argument*/NULL);
__this->set__uwr_0((UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E *)NULL);
}
IL_0023:
{
return;
}
}
// System.Boolean UnityEngine.WWW::WaitUntilDoneIfPossible()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D (WWW_tCC46D6E5A368D4A83A3D6FAFF00B19700C5373E2 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WWW_WaitUntilDoneIfPossible_m8D6B638F661CBD13B442F392BF42F5C9BDF0E84D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_0 = __this->get__uwr_0();
NullCheck(L_0);
bool L_1 = UnityWebRequest_get_isDone_mF8C92D10767B80877BCFE6D119CBE9090ACCDFBD(L_0, /*hidden argument*/NULL);
V_0 = L_1;
bool L_2 = V_0;
if (!L_2)
{
goto IL_0014;
}
}
{
V_1 = (bool)1;
goto IL_0054;
}
IL_0014:
{
String_t* L_3 = WWW_get_url_m1D75D492D78A7AA8F607C5D7700497B8FE5E9526(__this, /*hidden argument*/NULL);
NullCheck(L_3);
bool L_4 = String_StartsWith_mEA750A0572C706249CDD826681741B7DD733381E(L_3, _stringLiteral218F5A08519088A96BE3C1074984C53EA49F1CCA, 5, /*hidden argument*/NULL);
V_2 = L_4;
bool L_5 = V_2;
if (!L_5)
{
goto IL_0044;
}
}
{
goto IL_002e;
}
IL_002c:
{
}
IL_002e:
{
UnityWebRequest_tB75B39F6951CA0DBA2D5BEDF85FDCAAC6026A37E * L_6 = __this->get__uwr_0();
NullCheck(L_6);
bool L_7 = UnityWebRequest_get_isDone_mF8C92D10767B80877BCFE6D119CBE9090ACCDFBD(L_6, /*hidden argument*/NULL);
V_3 = (bool)((((int32_t)L_7) == ((int32_t)0))? 1 : 0);
bool L_8 = V_3;
if (L_8)
{
goto IL_002c;
}
}
{
V_1 = (bool)1;
goto IL_0054;
}
IL_0044:
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_tEB68BCBEB8EFD60F8043C67146DC05E7F50F374B_il2cpp_TypeInfo_var);
Debug_LogError_m8850D65592770A364D494025FF3A73E8D4D70485(_stringLiteralE2429764F10DC7E990250D2AE4138FE5AC928076, /*hidden argument*/NULL);
V_1 = (bool)0;
goto IL_0054;
}
IL_0054:
{
bool L_9 = V_1;
return L_9;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 Enumerator_get_Current_m17E1C36ECBB09CC2AB892710866F8655D83A6048_gshared_inline (Enumerator_tE4E91EE5578038530CF0C46227953BA787E7A0A0 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 L_0 = (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 )__this->get_current_3();
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * KeyValuePair_2_get_Key_mCAD7B121DB998D7C56EB0281215A860EFE9DCD95_gshared_inline (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = (RuntimeObject *)__this->get_key_0();
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * KeyValuePair_2_get_Value_m622223593F7461E7812C581DDB145270016ED303_gshared_inline (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = (RuntimeObject *)__this->get_value_1();
return L_0;
}
}
| 47.875508 | 334 | 0.843514 | OgiJr |
a34df082483423905affbc02731bfeb1c9faa405 | 4,674 | cc | C++ | lite/kernels/arm/softmax_compute.cc | 714627034/Paddle-Lite | 015ba88a4d639db0b73603e37f83e47be041a4eb | [
"Apache-2.0"
] | 1,799 | 2019-08-19T03:29:38.000Z | 2022-03-31T14:30:50.000Z | lite/kernels/arm/softmax_compute.cc | 714627034/Paddle-Lite | 015ba88a4d639db0b73603e37f83e47be041a4eb | [
"Apache-2.0"
] | 3,767 | 2019-08-19T03:36:04.000Z | 2022-03-31T14:37:26.000Z | lite/kernels/arm/softmax_compute.cc | yingshengBD/Paddle-Lite | eea59b66f61bb2acad471010c9526eeec43a15ca | [
"Apache-2.0"
] | 798 | 2019-08-19T02:28:23.000Z | 2022-03-31T08:31:54.000Z | // Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "lite/kernels/arm/softmax_compute.h"
#include "lite/backends/arm/math/funcs.h"
#ifdef ENABLE_ARM_FP16
#include "lite/backends/arm/math/fp16/funcs_fp16.h"
#endif
namespace paddle {
namespace lite {
namespace kernels {
namespace arm {
template <>
void SoftmaxCompute<PRECISION(kFloat), PRECISION(kFloat)>::Run() {
auto& param = Param<operators::SoftmaxParam>();
const float* din = param.x->data<float>();
float* dout = param.output->mutable_data<float>();
auto x_dims = param.x->dims();
auto x_rank = x_dims.size();
int axis = param.axis;
if (axis < 0) {
axis += x_rank;
}
int outer_num = x_dims.Slice(0, axis).production();
int inner_num = x_dims.Slice(axis + 1, x_rank).production();
int axis_size = x_dims[axis];
if (inner_num == 1) {
if (axis_size > 4) {
lite::arm::math::softmax_inner1_large_axis(
din, dout, outer_num, axis_size);
} else {
lite::arm::math::softmax_inner1_small_axis(
din, dout, outer_num, axis_size);
}
} else {
int compute_size = outer_num * inner_num;
if (axis_size == 4 && inner_num % 8 == 0) {
lite::arm::math::softmax_inner8_axis4(
din, dout, axis_size, inner_num, outer_num);
} else if (axis_size == 4 && inner_num % 4 == 0) {
lite::arm::math::softmax_inner4_axis4(
din, dout, axis_size, inner_num, outer_num);
} else {
if (inner_num % 8 == 0) {
lite::arm::math::softmax_inner8(
din, dout, axis_size, inner_num, outer_num);
} else if (inner_num % 4 == 0) {
lite::arm::math::softmax_inner4(
din, dout, axis_size, inner_num, outer_num);
} else {
lite::arm::math::softmax_basic(
din, dout, axis_size, inner_num, outer_num);
}
}
}
}
#ifdef ENABLE_ARM_FP16
template <>
void SoftmaxCompute<PRECISION(kFP16), PRECISION(kFP16)>::Run() {
auto& param = Param<operators::SoftmaxParam>();
const float16_t* din = param.x->data<float16_t>();
float16_t* dout = param.output->mutable_data<float16_t>();
auto x_dims = param.x->dims();
auto x_rank = x_dims.size();
int axis = param.axis;
if (axis < 0) {
axis += x_rank;
}
int outer_num = x_dims.Slice(0, axis).production();
int inner_num = x_dims.Slice(axis + 1, x_rank).production();
int axis_size = x_dims[axis];
if (inner_num == 1) {
if (axis_size >= 8) {
lite::arm::math::fp16::softmax_inner1_large_axis_fp16(
din, dout, outer_num, axis_size);
} else {
lite::arm::math::fp16::softmax_inner1_small_axis_fp16(
din, dout, outer_num, axis_size);
}
} else {
int compute_size = outer_num * inner_num;
if (axis_size == 4 && inner_num % 8 == 0) {
lite::arm::math::fp16::softmax_inner8_axis4_fp16(
din, dout, axis_size, inner_num, outer_num);
} else {
if (inner_num % 8 == 0) {
lite::arm::math::fp16::softmax_inner8_axis1_fp16(
din, dout, axis_size, inner_num, outer_num);
} else {
lite::arm::math::fp16::softmax_basic_fp16(
din, dout, axis_size, inner_num, outer_num);
}
}
}
}
#endif // ENABLE_ARM_FP16
} // namespace arm
} // namespace kernels
} // namespace lite
} // namespace paddle
#ifdef ENABLE_ARM_FP16
typedef paddle::lite::kernels::arm::SoftmaxCompute<PRECISION(kFP16),
PRECISION(kFP16)>
SoftmaxFp16;
REGISTER_LITE_KERNEL(softmax, kARM, kFP16, kNCHW, SoftmaxFp16, def)
.BindInput("X", {LiteType::GetTensorTy(TARGET(kARM), PRECISION(kFP16))})
.BindOutput("Out", {LiteType::GetTensorTy(TARGET(kARM), PRECISION(kFP16))})
.Finalize();
#endif // ENABLE_ARM_FP16
typedef paddle::lite::kernels::arm::SoftmaxCompute<PRECISION(kFloat),
PRECISION(kFloat)>
SoftmaxFp32;
REGISTER_LITE_KERNEL(softmax, kARM, kFloat, kNCHW, SoftmaxFp32, def)
.BindInput("X", {LiteType::GetTensorTy(TARGET(kARM))})
.BindOutput("Out", {LiteType::GetTensorTy(TARGET(kARM))})
.Finalize();
| 35.142857 | 79 | 0.64249 | 714627034 |
a35059f3ab3d4a828e6a74795a40d56d561a9e5a | 8,111 | cpp | C++ | src/tmx/TmxCtl/src/lib/PluginInstall.cpp | OSADP/V2I-Hub | 0b18ae6914acda276592cecb65a1eb727b76ca1d | [
"Apache-2.0"
] | null | null | null | src/tmx/TmxCtl/src/lib/PluginInstall.cpp | OSADP/V2I-Hub | 0b18ae6914acda276592cecb65a1eb727b76ca1d | [
"Apache-2.0"
] | null | null | null | src/tmx/TmxCtl/src/lib/PluginInstall.cpp | OSADP/V2I-Hub | 0b18ae6914acda276592cecb65a1eb727b76ca1d | [
"Apache-2.0"
] | 2 | 2020-02-02T18:31:07.000Z | 2021-04-23T15:07:11.000Z | /*
* PluginInstall.cpp
*
* Created on: Feb 1, 2018
* Author: gmb
*/
#include "TmxControl.h"
#include <boost/filesystem.hpp>
#include <libgen.h>
#include <System.h>
#include <sys/stat.h>
#ifndef PLUGINDIRECTORY_ENV
#define PLUGINDIRECTORY_ENV "TMX_PLUGIN_DIRECTORY"
#endif
#define INSTPLUGIN_DELETE_STMT "\
DELETE FROM IVP.installedPlugin"
#define PLUGIN_DELETE_STMT "\
DELETE FROM IVP.plugin \
WHERE name = ?"
using namespace std;
using namespace sql;
using namespace tmx;
using namespace tmx::utils;
namespace tmxctl {
bool TmxControl::plugin_install(pluginlist &plugins, ...) {
if (!checkPerm())
return false;
return plugin_install();
}
bool TmxControl::plugin_install() {
pluginlist plugins;
plugins.push_back("%");
struct stat tmpStat;
boost::filesystem::path temp;
boost::filesystem::path file((*_opts)["plugin-install"].as<string>());
if (file.empty() || access(file.c_str(), R_OK) < 0) {
PLOG(logERROR) << "Could not open file " << file << " for install";
return false;
}
string cmd = "file -b ";
cmd += file.string();
cmd += " 2>/dev/null";
string cmdResults = System::ExecCommand(cmd);
string ext = file.extension().string();
if (!cmdResults.empty())
PLOG(logDEBUG1) << "File returns: " << cmdResults;
PLOG(logDEBUG1) << "File extension is " << ext;
// Determine the directory to extract to from the manifest option
boost::filesystem::path cwd = boost::filesystem::current_path();
boost::filesystem::path pluginDir((*_opts)["plugin-directory"].as<string>());
PLOG(logDEBUG) << "Installing plugin to " << pluginDir;
#define tstr(X) strncmp(X, cmdResults.c_str(), strlen(X)) == 0
string exCmd = "tar -x -C ";
exCmd += pluginDir.string();
exCmd += " -f ";
string listCmd = "tar -t -f ";
// Handle the Debian archive separately
if (tstr("Debian") || ext == ".deb") {
int exitCode = 1;
#ifndef NO_DEBIAN_PKG_MGR
// Try the native package manager first
string dpkgResults = System::ExecCommand("dpkg -l >/dev/null 2>&1", &exitCode);
if (exitCode == 0) {
cmd = "sudo dpkg --install ";
cmd += file.string();
PLOG(logDEBUG) << "Installing Debian package with " << cmd;
exitCode = system(cmd.c_str());
return (exitCode == 0);
}
#endif
temp = boost::filesystem::temp_directory_path();
temp /= boost::filesystem::unique_path();
mkdir(temp.c_str(), S_IRWXU);
// A .deb is just an ar archive with the tar file inside it
boost::filesystem::path canonicalPath = boost::filesystem::canonical(file, cwd);
chdir(temp.c_str());
PLOG(logDEBUG) << "Writing in " << temp;
cmd = "ar -x ";
cmd += canonicalPath.string();
PLOG(logDEBUG) << "Extracting debian archive with " << cmd;
cmdResults = System::ExecCommand(cmd, &exitCode);
if (exitCode < 0) {
rmdir(temp.c_str());
return false;
}
bool found = false;
for (boost::filesystem::directory_iterator iter = boost::filesystem::directory_iterator(temp);
iter != boost::filesystem::directory_iterator(); iter++) {
if (strncmp("data.tar", iter->path().filename().c_str(), 8) == 0) {
file = iter->path();
ext = file.extension().string();
PLOG(logDEBUG1) << "Data file is " << file;
found = true;
} else {
// Don't need it
unlink(iter->path().c_str());
}
}
if (!found) {
PLOG(logERROR) << "Debian package appears corrupt";
rmdir(temp.c_str());
return false;
}
chdir("/");
// Path in the Debian archive is relative from /.
// Therefore, do not use the -C option
exCmd = "tar -x -f ";
}
string compressOpt = "";
if (tstr("gzip") || ext == ".gz" || ext == ".tgz") {
compressOpt = " -z";
} else if (tstr("Zip") || ext == ".zip") {
listCmd = "unzip -l ";
exCmd = "unzip -o -d ";
exCmd += pluginDir.string();
exCmd += " ";
} else if (tstr("compress'd") || ext == ".Z" || ext == ".tZ") {
compressOpt = " -Z";
} else if (tstr("bzip2") || ext == ".bz2" || ext == ".tbz2") {
compressOpt = " -j";
} else if (tstr("XZ") || ext == ".xz" || ext == ".txz") {
compressOpt = " -J";
}
#undef tstr
cmd = listCmd;
cmd += file.string();
cmd += compressOpt;
cmd += " 2>/dev/null | grep \"manifest.json$\"";
PLOG(logDEBUG) << "Listing archive with " << cmd;
cmdResults = System::ExecCommand(cmd);
PLOG(logDEBUG1) << "Command returned with " << cmdResults;
// Make sure this is not a relative path
if (cmdResults[0] == '.')
cmdResults.erase(0, 1);
// ZIP files contain some other stuff, fast forward to the last field
size_t idx = cmdResults.find_last_of(' ');
if (idx != string::npos)
cmdResults = cmdResults.substr(idx+1);
boost::filesystem::path mfest = boost::filesystem::absolute(cmdResults, pluginDir);
cmd = exCmd;
cmd += file.string();
cmd += compressOpt;
PLOG(logDEBUG) << "Installing files with " << cmd;
System::ExecCommand(cmd.c_str());
chdir(cwd.c_str());
if (!temp.empty()) {
// Remove the temp file
unlink(file.c_str());
rmdir(temp.c_str());
}
if (stat(mfest.parent_path().c_str(), &tmpStat) != 0) {
PLOG(logERROR) << "Could not extract archive. Missing " << mfest.parent_path();
return false;
}
// Try to set permissions on the file
cmd = "chown -R www-data:www-data ";
cmd += mfest.parent_path().string();
cmd += " >/dev/null 2>&1";
PLOG(logDEBUG) << "Changing ownership with " << cmd;
System::ExecCommand(cmd);
PLOG(logDEBUG) << "Loading manifest from " << mfest;
boost::any m(mfest.string());
(*_opts).insert(make_pair("load-manifest", boost::program_options::variable_value(m, false)));
return this->load_manifest(plugins);
}
bool TmxControl::plugin_remove(pluginlist &, ...) {
if (!checkPerm())
return false;
return plugin_remove();
}
bool TmxControl::plugin_remove() {
struct stat tmpStat;
pluginlist plugins(1, (*_opts)["plugin-remove"].as<string>());
string query = add_constraint(INSTPLUGIN_DELETE_STMT, plugins);
// Get the path for the plugin
this->list(plugins);
message_path_type basePath(plugins[0], ATTRIBUTE_PATH_CHARACTER);
message_path_type pathPath(basePath);
pathPath /= message_path_type("path", ATTRIBUTE_PATH_CHARACTER);
boost::filesystem::path dirPath(_output.retrieve(pathPath, "/tmp/__?NO+PATH?__"));
pathPath = basePath;
pathPath /= message_path_type("exeName", ATTRIBUTE_PATH_CHARACTER);
boost::filesystem::path exePath = dirPath;
exePath += _output.retrieve(pathPath, "/__?NO+FILE?__");
_output.get_storage().get_tree().clear();
// If the active system has an installed package manager, invoke that first
if (!exePath.empty() && stat(exePath.c_str(), &tmpStat) == 0) {
PLOG(logDEBUG1) << "Plugin found under " << dirPath;
#ifndef NO_DEBIAN_PKG_MGR
string cmd = "dpkg -S ";
cmd += exePath.string();
cmd += " 2>/dev/null";
string dpkgResult = System::ExecCommand(cmd);
if (!dpkgResult.empty()) {
// There is a Debian package component installed for this plugin, so execute the removal process
// First get the component name from the output
size_t idx = dpkgResult.find_first_of(':');
if (idx != string::npos) {
cmd = "sudo dpkg --remove ";
cmd += dpkgResult.substr(0, idx);
PLOG(logDEBUG) << "Removing Debian package with " << cmd;
int exitVal = system(cmd.c_str());
return exitVal == 0;
}
}
#endif
}
try
{
DbConnection conn = _pool.Connection();
// Delete from installedPlugin table
PLOG(logDEBUG1) << "Executing query: " << query;
unique_ptr<PreparedStatement> stmt(conn.Get()->prepareStatement(query));
int rows = stmt->executeUpdate();
// Delete from plugin table
PLOG(logDEBUG1) << "Executing query (?1 = " << plugins[0] << "): " << PLUGIN_DELETE_STMT;
stmt.reset(conn.Get()->prepareStatement(PLUGIN_DELETE_STMT));
stmt->setString(1, plugins[0]);
rows += stmt->executeUpdate();
PLOG(logDEBUG1) << "Deleted " << rows << " rows.";
// Remove the installed files
if (!dirPath.empty() && stat(dirPath.c_str(), &tmpStat) == 0) {
PLOG(logDEBUG) << "Deleting file path " << dirPath;
boost::filesystem::remove_all(dirPath);
}
return rows > 0;
}
catch (exception &ex)
{
PLOG(logERROR) << TmxException(ex);
return false;
}
}
}
| 25.426332 | 99 | 0.650845 | OSADP |
a3515a565993e1f29cd5faf45971285db135672d | 2,080 | cpp | C++ | src/StepLibrary/MockMessageConsumer.cpp | dale-wilson/HSQueue | 04d01ed42707069d28e81b5494aba61904e6e591 | [
"BSD-3-Clause"
] | 2 | 2015-12-29T17:33:25.000Z | 2021-12-20T02:30:44.000Z | src/StepLibrary/MockMessageConsumer.cpp | dale-wilson/HighQueue | 04d01ed42707069d28e81b5494aba61904e6e591 | [
"BSD-3-Clause"
] | null | null | null | src/StepLibrary/MockMessageConsumer.cpp | dale-wilson/HighQueue | 04d01ed42707069d28e81b5494aba61904e6e591 | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2015 Object Computing, Inc.
// All rights reserved.
// See the file license.txt for licensing information.
#include <Steps/StepPch.hpp>
#include "MockMessageConsumer.hpp"
#include <Steps/StepFactory.hpp>
using namespace HighQueue;
using namespace Steps;
namespace
{
StepFactory::Registrar<MockMessageConsumer<SmallMockMessage> > registerStepSmall("small_test_message_consumer", "Validate and consume small test messages");
StepFactory::Registrar<MockMessageConsumer<MediumMockMessage> > registerStepMedium("medium_test_message_consumer", "Validate and consume medium test messages");
StepFactory::Registrar<MockMessageConsumer<LargeMockMessage> > registerStepLarge("large_test_message_consumer", "Validate and consume large test messages");
const std::string keyMessageCount = "message_count";
}
BaseMessageConsumer::BaseMessageConsumer()
: messageCount_(0)
, heartbeats_(0)
, shutdowns_(0)
, gaps_(0)
, messagesHandled_(0)
, nextSequence_(0)
, sequenceError_(0)
, unexpectedMessageError_(0)
{
}
BaseMessageConsumer::~BaseMessageConsumer()
{
}
bool BaseMessageConsumer::configureParameter(const std::string & key, const ConfigurationNode & configuration)
{
if(key == keyMessageCount)
{
uint64_t messageCount;
if(!configuration.getValue(messageCount))
{
LogFatal("MessageConsumer can't interpret value for " << keyMessageCount);
}
messageCount_ = uint32_t(messageCount);
return true;
}
return Step::configureParameter(key, configuration);
}
void BaseMessageConsumer::logStats()
{
LogStatistics("MessageConsumer " << name_ << " heartbeats: " << heartbeats_);
LogStatistics("MessageConsumer " << name_ << " shutdowns: " << shutdowns_);
LogStatistics("MessageConsumer " << name_ << " messagesHandled: " << messagesHandled_);
LogStatistics("MessageConsumer " << name_ << " sequenceError: " << sequenceError_);
LogStatistics("MessageConsumer " << name_ << " unexpectedMessageError: " << unexpectedMessageError_);
}
| 33.548387 | 164 | 0.725962 | dale-wilson |
a351c29d65dcf8cbe51a49df7bf795476e00db69 | 37,347 | cpp | C++ | compiler/AST/AstDumpToNode.cpp | SamuelHoward/chapel | f1b927b5abaf6210ec05347c88d5f15c17b7ea47 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | compiler/AST/AstDumpToNode.cpp | SamuelHoward/chapel | f1b927b5abaf6210ec05347c88d5f15c17b7ea47 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | compiler/AST/AstDumpToNode.cpp | SamuelHoward/chapel | f1b927b5abaf6210ec05347c88d5f15c17b7ea47 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | /*
* Copyright 2020 Hewlett Packard Enterprise Development LP
* Copyright 2004-2019 Cray Inc.
* Other additional copyright holders may be indicated within.
*
* The entirety of this work is licensed under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
*
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "AstDumpToNode.h"
#include "CatchStmt.h"
#include "CForLoop.h"
#include "DeferStmt.h"
#include "DoWhileStmt.h"
#include "driver.h"
#include "expr.h"
#include "flags.h"
#include "ForallStmt.h"
#include "ForLoop.h"
#include "ImportStmt.h"
#include "log.h"
#include "ParamForLoop.h"
#include "stlUtil.h"
#include "stmt.h"
#include "stringutil.h"
#include "symbol.h"
#include "type.h"
#include "TryStmt.h"
#include "WhileDoStmt.h"
bool AstDumpToNode::compact = false;
const char* AstDumpToNode::delimitEnter = "#<"; // or { } or ( ) etc.
const char* AstDumpToNode::delimitExit = ">";
bool AstDumpToNode::showNodeIDs = true;
void AstDumpToNode::view(const char* passName, int passNum)
{
forv_Vec(ModuleSymbol, module, gModuleSymbols)
{
if (log_module[0] == '\0' || strcmp(log_module, module->name) == 0)
{
if (strcmp(module->name, "_root") != 0)
view(passName, passNum, module);
}
}
}
void AstDumpToNode::view(const char* passName,
int passNum,
ModuleSymbol* module)
{
AstDumpToNode logger;
if (logger.open(module, passName, passNum) == true)
{
module->accept(&logger);
logger.close();
}
}
AstDumpToNode::AstDumpToNode(FILE* fp, int offset)
{
mPath = 0;
mFP = fp;
mOffset = offset;
mNeedSpace = false;
mModule = 0;
}
AstDumpToNode::AstDumpToNode()
{
mPath = 0;
mFP = 0;
mOffset = 0;
mNeedSpace = false;
mModule = 0;
}
AstDumpToNode::~AstDumpToNode()
{
if (mPath != 0 && mFP != 0)
{
close();
}
}
void AstDumpToNode::offsetSet(int offset)
{
mOffset = offset;
}
bool AstDumpToNode::open(ModuleSymbol* mod, const char* passName, int passNum)
{
char numBuf[4] = { '\0' };
snprintf(numBuf, 4, "%02d", passNum);
mPath = astr(mod->name, "_", numBuf, passName, ".ast");
mFP = fopen(astr(log_dir, mPath), "w");
mModule = mod;
if (mFP != 0)
{
fprintf(mFP, "AST dump for %s after pass %s.\n\n", mod->name, passName);
}
return (mFP != 0) ? true : false;
}
bool AstDumpToNode::close()
{
bool retval = false;
if (mFP != 0)
{
retval = (fclose(mFP) == 0) ? true : false;
mFP = 0;
}
return retval;
}
/************************************* | **************************************
* *
* The visit functions for each concrete class *
* *
* Note that there are default implementations in AstLogger *
* *
************************************** | *************************************/
// pad right to longStringLength unless compact
void AstDumpToNode::writeLongString(const char* msg, const char* arg) const
{
static const size_t longStringLength = 38;
fputs(msg, mFP);
if (compact || strlen(arg) >= longStringLength)
fputs(arg, mFP);
else
fprintf(mFP, "%-28s", arg);
}
// Print the node ID, only if desired i.e. if showNodeIDs.
// spaceBefore, spaceAfter matter only when showNodeIds.
void AstDumpToNode::writeNodeID(BaseAST* node,
bool spaceBefore,
bool spaceAfter) const
{
if (showNodeIDs)
{
const char* sb = spaceBefore ? " " : "";
const char* sa = spaceAfter ? " " : "";
if (compact)
fprintf(mFP, "%s%d%s", sb, node->id, sa);
else
fprintf(mFP, "%s%7d%s", sb, node->id, sa);
}
}
void AstDumpToNode::enterNode(BaseAST* node) const
{
if (compact)
{
fprintf(mFP, "%s%s", delimitEnter, node->astTagAsString());
writeNodeID(node, true, false);
}
else
{
if (FnSymbol* fn = toFnSymbol(node))
{
fprintf(mFP, "%s%-14s", delimitEnter, node->astTagAsString());
writeNodeID(node, true, false);
if (fn->hasFlag(FLAG_GENERIC) == true)
{
fprintf(mFP, " (Generic)");
}
}
else if (isUnresolvedSymExpr(node) == true)
{
fprintf(mFP, "%s%-14s", delimitEnter, "UsymExpr");
writeNodeID(node, true, false);
}
else
{
fprintf(mFP, "%s%-14s", delimitEnter, node->astTagAsString());
writeNodeID(node, true, false);
}
}
}
void AstDumpToNode::enterNodeSym(Symbol* node, const char* name) const
{
enterNode(node);
writeLongString(" name: ", name ? name : node->name);
}
void AstDumpToNode::exitNode(BaseAST* node, bool addNewline) const
{
fputs(delimitExit, mFP);
if (addNewline)
fputc('\n', mFP);
}
bool AstDumpToNode::enterModSym(ModuleSymbol* node)
{
bool retval = false;
// chpl_Program embeds a list of all the modules.
// Skip the contents of the embedded ones.
if (mModule != 0 &&
strcmp(mModule->name, "chpl__Program") == 0 &&
strcmp(node->name, "chpl__Program") != 0)
{
enterNode(node);
fprintf(mFP, " %s", node->name);
exitNode(node);
retval = false;
}
else
{
const char* tag = ModuleSymbol::modTagToString(node->modTag);
enterNode(node);
fprintf(mFP, " %s", node->name);
mOffset = mOffset + 2;
newline();
fprintf(mFP, "ModTag: %s\n", tag);
newline();
retval = true;
}
return retval;
}
void AstDumpToNode::exitModSym(ModuleSymbol* node)
{
if (node->modUseList.size() > 0)
{
fputc('\n', mFP);
newline();
fputs("ModUseList:", mFP);
forv_Vec(ModuleSymbol, mod, node->modUseList)
{
fprintf(mFP, " %s", mod->name);
}
}
mOffset = mOffset - 2;
newline();
exitNode(node, true);
}
//
//
//
bool AstDumpToNode::enterBlockStmt(BlockStmt* node)
{
char heading[128] = { '\0' };
bool firstTime = true;
enterNode(node);
write(false, heading, true);
if (node->blockInfoGet())
{
mOffset = mOffset + 2;
newline();
write(false, "BlockInfo: ", false);
mOffset = mOffset + 11;
node->blockInfoGet()->accept(this);
mOffset = mOffset - 11;
mOffset = mOffset - 2;
fprintf(mFP, "\n");
}
// Show blockTag bits.
if (node->blockTag & BLOCK_EXTERN)
write(true, "extern", true);
if (node->blockTag & BLOCK_SCOPELESS)
write(true, "scopeless", true);
if (node->blockTag & BLOCK_TYPE_ONLY)
write(true, "type_only", true);
if (node->blockTag & BLOCK_C_FOR_LOOP)
write(true, "C_FOR_LOOP", true);
mOffset = mOffset + 2;
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
if (!compact) fprintf(mFP, "\n");
newline();
next_ast->accept(this);
}
if (node->useList)
{
fprintf(mFP, "\n");
newline();
write(false, "ModUses:", false);
mOffset = mOffset + 2;
newline();
node->useList->accept(this);
mOffset = mOffset - 2;
}
if (node->byrefVars)
{
newline();
write(false, "ByRefVars:", false);
mOffset = mOffset + 2;
newline();
node->byrefVars->accept(this);
mOffset = mOffset - 2;
}
mOffset = mOffset - 2;
newline();
exitNode(node);
write(false, "", true);
return false;
}
//
//
//
bool AstDumpToNode::enterForallStmt(ForallStmt* node)
{
enterNode(node);
write(false, "", true);
if (node->zippered())
write(true, "zip", true);
mOffset = mOffset + 2;
writeField("inductionVariables: ", node->inductionVariables());
writeField("iteratedExpressions: ", node->iteratedExpressions());
writeField("shadowVariables: ", node->shadowVariables());
newline();
if (node->fRecIterIRdef) {
writeField("fRecIterIRdef: ", 20, node->fRecIterIRdef);
writeField("fRecIterICdef: ", 20, node->fRecIterICdef);
writeField("fRecIterGetIterator: ", 20, node->fRecIterGetIterator);
writeField("fRecIterFreeIterator: ", 20, node->fRecIterFreeIterator);
}
writeField("loopBody: ", 10, node->loopBody());
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterWhileDoStmt(WhileDoStmt* node)
{
bool firstTime = true;
enterNode(node);
if (node->condExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("CondExpr: ", mFP);
mOffset = mOffset + 10;
node->condExprGet()->accept(this);
mOffset = mOffset - 10;
mOffset = mOffset - 2;
fputc('\n', mFP);
}
mOffset = mOffset + 2;
newline();
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
newline();
next_ast->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterDoWhileStmt(DoWhileStmt* node)
{
bool firstTime = true;
enterNode(node);
if (node->condExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("CondExpr: ", mFP);
mOffset = mOffset + 10;
node->condExprGet()->accept(this);
mOffset = mOffset - 10;
mOffset = mOffset - 2;
fputc('\n', mFP);
}
mOffset = mOffset + 2;
newline();
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
newline();
next_ast->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterCForLoop(CForLoop* node)
{
bool firstTime = true;
enterNode(node);
if (node->initBlockGet())
{
mOffset = mOffset + 2;
newline();
fputs("Init: ", mFP);
mOffset = mOffset + 6;
node->initBlockGet()->accept(this);
mOffset = mOffset - 6;
mOffset = mOffset - 2;
fputc('\n', mFP);
}
if (node->testBlockGet())
{
mOffset = mOffset + 2;
newline();
fputs("Test: ", mFP);
mOffset = mOffset + 6;
node->testBlockGet()->accept(this);
mOffset = mOffset - 6;
mOffset = mOffset - 2;
fputc('\n', mFP);
}
if (node->incrBlockGet())
{
mOffset = mOffset + 2;
newline();
fputs("Incr: ", mFP);
mOffset = mOffset + 6;
node->incrBlockGet()->accept(this);
mOffset = mOffset - 6;
mOffset = mOffset - 2;
fputc('\n', mFP);
}
mOffset = mOffset + 2;
newline();
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
newline();
next_ast->accept(this);
fputc('\n', mFP);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterForLoop(ForLoop* node)
{
bool firstTime = true;
enterNode(node);
if (node->indexGet() != 0 || node->iteratorGet() != 0)
{
mOffset = mOffset + 2;
newline();
if (node->indexGet() != 0)
{
fputs("Index: ", mFP);
mOffset = mOffset + 10;
node->indexGet()->accept(this);
mOffset = mOffset - 10;
if (node->iteratorGet() != 0)
newline();
}
if (node->iteratorGet() != 0)
{
fputs("Iterator: ", mFP);
mOffset = mOffset + 10;
node->iteratorGet()->accept(this);
mOffset = mOffset - 10;
}
mOffset = mOffset - 2;
fputc('\n', mFP);
}
mOffset = mOffset + 2;
newline();
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
{
if (!compact) fprintf(mFP, "\n");
newline();
}
next_ast->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
//
//
//
bool AstDumpToNode::enterParamForLoop(ParamForLoop* node)
{
bool firstTime = true;
enterNode(node);
if (node->indexExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("Index Expr: ", mFP);
mOffset = mOffset + 13;
node->indexExprGet()->accept(this);
mOffset = mOffset - 13;
mOffset = mOffset - 2;
}
if (node->lowExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("Low Expr: ", mFP);
mOffset = mOffset + 13;
node->lowExprGet()->accept(this);
mOffset = mOffset - 13;
mOffset = mOffset - 2;
}
if (node->highExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("High Expr: ", mFP);
mOffset = mOffset + 13;
node->highExprGet()->accept(this);
mOffset = mOffset - 13;
mOffset = mOffset - 2;
}
if (node->strideExprGet())
{
mOffset = mOffset + 2;
newline();
fputs("Stride Expr: ", mFP);
mOffset = mOffset + 13;
node->strideExprGet()->accept(this);
mOffset = mOffset - 13;
mOffset = mOffset - 2;
}
mOffset = mOffset + 2;
fprintf(mFP, "\n");
newline();
for_alist(next_ast, node->body)
{
if (firstTime == true)
firstTime = false;
else
newline();
next_ast->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterDefExpr(DefExpr* node)
{
enterNode(node);
if (node->sym != 0 &&
node->exprType == 0 &&
node->init == 0 &&
compact == false &&
isModuleSymbol(node->sym) == false &&
isFnSymbol(node->sym) == false &&
isArgSymbol(node->sym) == false)
{
fputs(" sym: ", mFP);
if (compact == false)
mOffset = mOffset + 39;
node->sym->accept(this);
if (compact == false)
mOffset = mOffset - 39;
}
else
{
mOffset = mOffset + 2;
if (node->sym)
{
newline();
fputs("sym: ", mFP);
mOffset = mOffset + 10;
node->sym->accept(this);
mOffset = mOffset - 10;
}
if (node->exprType)
{
newline();
fputs("exprType: ", mFP);
mOffset = mOffset + 10;
node->exprType->accept(this);
mOffset = mOffset - 10;
}
if (node->init)
{
newline();
fputs("init: ", mFP);
mOffset = mOffset + 10;
node->init->accept(this);
mOffset = mOffset - 10;
}
mOffset = mOffset - 2;
}
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterFnSym(FnSymbol* node)
{
bool firstFormal = true;
enterNode(node);
mOffset = mOffset + 2;
if (node->hasFlag(FLAG_BEGIN) == true ||
node->hasFlag(FLAG_ON) == true ||
node->hasFlag(FLAG_COBEGIN_OR_COFORALL) == true) {
int count = 0;
newline();
fprintf(mFP, "Flags: ");
if (node->hasFlag(FLAG_BEGIN)) {
fprintf(mFP, "FLAG_BEGIN");
count = count + 1;
}
if (node->hasFlag(FLAG_ON)) {
if (count > 0)
fprintf(mFP, ", ");
fprintf(mFP, "FLAG_ON");
count = count + 1;
}
if (node->hasFlag(FLAG_COBEGIN_OR_COFORALL)) {
if (count > 0)
fprintf(mFP, ", ");
fprintf(mFP, "FLAG_COBEGIN_OR_COFORALL");
count = count + 1;
}
}
newline();
fprintf(mFP, "FileName: %s", node->astloc.filename);
newline();
fprintf(mFP, "LineNum: %5d", node->astloc.lineno);
if (node->_this && node->_this->defPoint)
{
newline();
fprintf(mFP, "DefPoint: ");
mOffset = mOffset + 10;
ast_symbol(node->_this->type->symbol, false);
mOffset = mOffset - 10;
}
newline();
fprintf(mFP, "Name: %s", node->name);
// Now the return type info
switch (node->retTag)
{
case RET_VALUE:
break;
case RET_REF:
newline();
write("RetTag: ref");
break;
case RET_CONST_REF:
newline();
write("RetTag: const ref");
break;
case RET_PARAM:
newline();
write("RetTag: param");
break;
case RET_TYPE:
newline();
write("RetTag: type");
break;
}
if (node->retType && node->retType->symbol)
{
newline();
fprintf(mFP, "RetType: ");
mOffset = mOffset + 10;
writeType(node->retType, false);
mOffset = mOffset - 10;
}
newline();
write(false, "Formals:", false);
if (node->formals.length > 0)
{
fprintf(mFP, " ");
mOffset = mOffset + 10;
for_alist(next_ast, node->formals)
{
if (firstFormal == true)
firstFormal = false;
else
newline();
next_ast->accept(this);
}
mOffset = mOffset - 10;
}
if (node->body)
{
newline();
writeField("Body: ", 10, node->body);
}
if (node->where)
{
newline();
writeField("Where: ", 10, node->where);
}
if (node->retExprType)
{
newline();
write(false, "RetExprType: ", false);
mOffset = mOffset + 10;
node->retExprType->accept(this);
mOffset = mOffset - 10;
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterCallExpr(CallExpr* node)
{
if (node->primitive == NULL)
fprintf(mFP, compact ? "%s%s " : "%s%-15s", delimitEnter, "Call");
else if (node->isPrimitive(PRIM_MOVE))
fprintf(mFP, compact ? "%s%s " : "%s%-15s", delimitEnter, "PrimMove");
else if (node->isPrimitive(PRIM_RETURN))
fprintf(mFP, compact ? "%s%s " : "%s%-15s", delimitEnter, "Return");
else
fprintf(mFP,
compact ? "%sPrimOp %s " : "%sPrimOp %-18s",
delimitEnter,
node->primitive->name);
writeNodeID(node, false, false);
mOffset = mOffset + 2;
if (compact)
mNeedSpace = true;
if (FnSymbol* fn = node->theFnSymbol())
{
if (fn->hasFlag(FLAG_BEGIN_BLOCK))
write(" begin");
if (fn->hasFlag(FLAG_ON_BLOCK))
write(" on");
}
if (node->baseExpr)
{
newline();
node->baseExpr->accept(this);
}
for_alist(next_ast, node->argList)
{
newline();
next_ast->accept(this);
}
mOffset = mOffset - 2;
if (!compact) newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterContextCallExpr(ContextCallExpr* node)
{
enterNode(node);
mOffset = mOffset + 2;
for_alist(expr, node->options) {
newline();
expr->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterNamedExpr(NamedExpr* node)
{
enterNode(node);
fprintf(mFP, compact ? " %s " : "(%s =", node->name);
mNeedSpace = true;
return true;
}
void AstDumpToNode::exitNamedExpr(NamedExpr* node)
{
if (!compact)
write(")");
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterIfExpr(IfExpr* node) {
return false;
}
void AstDumpToNode::exitIfExpr(IfExpr* node) {
}
//
//
//
void AstDumpToNode::visitSymExpr(SymExpr* node)
{
Symbol* sym = node->symbol();
enterNode(node);
if (compact)
{
fputc(' ', mFP);
writeSymbolCompact(sym);
}
else
{
fputs(" var: ", mFP);
writeSymbol(sym);
}
exitNode(node);
}
//
//
//
void AstDumpToNode::visitUsymExpr(UnresolvedSymExpr* node)
{
enterNode(node);
fprintf(mFP, " \"%s\"", node->unresolved);
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterLoopExpr(LoopExpr* node) {
return false;
}
void AstDumpToNode::exitLoopExpr(LoopExpr* node) {
}
void AstDumpToNode::visitUseStmt(UseStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
if (compact)
{
mNeedSpace = true;
fprintf(mFP, " 'use'");
}
newline();
node->src->accept(this);
if (node->isARename()) {
fprintf(mFP, " 'as' %s", node->getRename());
}
if (!node->isPlainUse()) {
node->writeListPredicate(mFP);
for_vector(const char, str, node->named) {
newline();
fprintf(mFP, "%s", str);
}
for (std::map<const char*, const char*>::iterator it = node->renamed.begin();
it != node->renamed.end(); ++it) {
newline();
fprintf(mFP, "%s 'as' %s", it->second, it->first);
}
}
mOffset = mOffset - 2;
newline();
exitNode(node);
}
void AstDumpToNode::visitImportStmt(ImportStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
if (compact)
{
mNeedSpace = true;
fprintf(mFP, " 'import'");
}
newline();
node->src->accept(this);
mOffset = mOffset - 2;
newline();
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterCondStmt(CondStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
newline();
fputs("cond: ", mFP);
mOffset = mOffset + 6;
node->condExpr->accept(this);
mOffset = mOffset - 6;
fputc('\n', mFP);
newline();
writeField("cons: ", 6, node->thenStmt);
if (node->elseStmt)
{
fputc('\n', mFP);
newline();
writeField("alt: ", 6, node->elseStmt);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
void AstDumpToNode::visitEblockStmt(ExternBlockStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
newline();
fputs(node->c_code, mFP);
mOffset = mOffset - 2;
newline();
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterGotoStmt(GotoStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
newline();
switch (node->gotoTag)
{
case GOTO_NORMAL:
fprintf(mFP, "tag: goto");
break;
case GOTO_BREAK:
fprintf(mFP, "tag: break");
break;
case GOTO_CONTINUE:
fprintf(mFP, "tag: continue");
break;
case GOTO_RETURN:
fprintf(mFP, "tag: gotoReturn");
break;
case GOTO_GETITER_END:
fprintf(mFP, "tag: gotoGetiterEnd");
break;
case GOTO_ITER_RESUME:
fprintf(mFP, "tag: gotoIterResume");
break;
case GOTO_ITER_END:
fprintf(mFP, "tag: gotoIterEnd");
break;
case GOTO_ERROR_HANDLING:
fprintf(mFP, "tag: gotoErrorHandling");
break;
case GOTO_BREAK_ERROR_HANDLING:
fprintf(mFP, "tag: gotoBreakErrorHandling");
break;
case GOTO_ERROR_HANDLING_RETURN:
fprintf(mFP, "tag: gotoErrorHandlingReturn");
break;
}
if (SymExpr* label = toSymExpr(node->label))
{
if (label->symbol() != gNil)
{
newline();
fprintf(mFP, "label: ");
mOffset = mOffset + 2;
ast_symbol(label->symbol(), true);
mOffset = mOffset - 2;
}
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
bool AstDumpToNode::enterTryStmt(TryStmt* node)
{
enterNode(node);
if (node->tryBang() == true)
{
fprintf(mFP, " Try!");
}
mOffset = mOffset + 2;
newline();
if (node->_body != NULL)
{
node->_body->accept(this);
}
for_alist(catchStmt, node->_catches) {
newline();
catchStmt->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
bool AstDumpToNode::enterCatchStmt(CatchStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
newline();
if (node->_body != NULL)
{
mOffset = mOffset + 2;
node->_body->accept(this);
mOffset = mOffset - 2;
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
bool AstDumpToNode::enterDeferStmt(DeferStmt* node)
{
enterNode(node);
mOffset = mOffset + 2;
newline();
if (BlockStmt* body = node->body())
{
mOffset = mOffset + 2;
body->accept(this);
mOffset = mOffset - 2;
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
bool AstDumpToNode::enterAggrType(AggregateType* node)
{
const char* tagName = 0;
bool firstTime = true;
switch (node->aggregateTag)
{
case AGGREGATE_CLASS:
tagName = "Class";
break;
case AGGREGATE_RECORD:
tagName = "Record";
break;
case AGGREGATE_UNION:
tagName = "Union";
break;
}
enterNode(node);
fprintf(mFP,
" %-6s %s",
tagName,
(node->symbol) ? node->symbol->name : "SymbolUnbound");
mOffset = mOffset + 2;
newline();
for_alist(field, node->fields)
{
if (firstTime == true)
firstTime = false;
else
newline();
field->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
void AstDumpToNode::exitAggrType(AggregateType* node)
{
}
//
//
//
bool AstDumpToNode::enterEnumType(EnumType* node)
{
bool firstTime = true;
enterNode(node);
mOffset = mOffset + 2;
newline();
for_alist(field, node->constants)
{
if (firstTime == true)
firstTime = false;
else
newline();
field->accept(this);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
void AstDumpToNode::visitPrimType(PrimitiveType* node)
{
enterNode(node);
fprintf(mFP, " %s", node->symbol->name);
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterArgSym(ArgSymbol* node)
{
enterNode(node);
mOffset = mOffset + 2;
ast_symbol(node, true);
if (node->typeExpr)
{
newline();
fprintf(mFP, "typeExpr: ");
mOffset = mOffset + 14;
node->typeExpr->accept(this);
mOffset = mOffset - 14;
}
if (node->defaultExpr)
{
newline();
fprintf(mFP, "defaultExpr: ");
mOffset = mOffset + 14;
node->defaultExpr->accept(this);
mOffset = mOffset - 14;
}
if (node->variableExpr)
{
newline();
fprintf(mFP, "variableExpr: ");
mOffset = mOffset + 14;
node->variableExpr->accept(this);
mOffset = mOffset - 14;
}
if (node->depth() >= 0)
{
newline();
fprintf(mFP, "depth: %4d", node->depth());
newline();
fprintf(mFP, "offset: %4d", node->offset());
}
if (node->flags.any() == true)
{
newline();
writeFlags(mFP, node);
}
mOffset = mOffset - 2;
newline();
exitNode(node);
return false;
}
//
//
//
void AstDumpToNode::visitEnumSym(EnumSymbol* node)
{
enterNode(node);
fprintf(mFP, " name: %s", node->name);
exitNode(node, false);
}
//
//
//
void AstDumpToNode::visitLabelSym(LabelSymbol* node)
{
enterNode(node);
fputc(' ', mFP);
mOffset = mOffset + 2;
ast_symbol(node, true);
mOffset = mOffset - 2;
exitNode(node);
}
//
//
//
bool AstDumpToNode::enterTypeSym(TypeSymbol* node)
{
enterNodeSym(node);
if (node->type)
{
writeType(node->type);
}
exitNode(node);
return false;
}
//
//
//
void AstDumpToNode::visitVarSym(VarSymbol* node)
{
writeSymbol(node);
}
/************************************* | **************************************
* *
* Helper routines *
* *
************************************** | *************************************/
// "module." or "class::" is applicable, "" otherwise
// beware it may return a static buffer
static const char* symPrefixString(Symbol* sym) {
const char* retval = "";
if (sym != NULL)
{
static char symPrefixBuffer[1024];
Symbol* parent = sym->defPoint ? sym->defPoint->parentSymbol : NULL;
if (isModuleSymbol(parent))
sprintf(symPrefixBuffer, "%s.", parent->name);
else if (isTypeSymbol(parent))
sprintf(symPrefixBuffer, "%s::", parent->name);
else
symPrefixBuffer[0] = '\0';
retval = symPrefixBuffer;
}
return retval;
}
void AstDumpToNode::writeSymbol(Symbol* sym) const
{
char name[1024];
ModuleSymbol* mod = sym->getModule();
if (compact)
{
sprintf(name, "%s%s", symPrefixString(sym), sym->name);
}
else if (mod != 0)
{
#if 0
if (false)
;
else if (sym == 0)
sprintf(name, "??.NULL");
else if (mod->name == 0 && sym->name == 0)
sprintf(name, "??.??");
else if (mod->name != 0 && sym->name == 0)
sprintf(name, "%s.??", mod->name);
else if (mod->name == 0 && sym->name != 0)
sprintf(name, "??.%s", sym->name);
else
sprintf(name, "%s.%s", mod->name, sym->name);
#else
sprintf(name, "%s", sym->name);
#endif
}
else
{
if (sym->name == 0)
sprintf(name, "NULL.??");
else
sprintf(name, "NULL.%s", sym->name);
}
if (false)
{
}
else if (ArgSymbol* arg = toArgSymbol(sym))
{
int len = -1;
enterNodeSym(sym, name);
if (sym->type != 0)
{
len = writeType(sym->type);
}
if (compact == false && arg->depth() >= 0)
{
if (len > 0 && len < 45)
{
for (int i = len; i < 45; i++)
fputc(' ', stdout);
}
fprintf(mFP, " depth: %2d offset: %4d", arg->depth(), arg->offset());
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (isEnumSymbol(sym) == true)
{
enterNodeSym(sym, name);
if (sym->type != 0)
{
writeType(sym->type);
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (isFnSymbol(sym) == true)
{
enterNodeSym(sym, name);
if (sym->type != 0)
{
writeType(sym->type);
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (isLabelSymbol(sym) == true)
{
enterNodeSym(sym, name);
if (sym->type != 0)
{
writeType(sym->type);
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (isModuleSymbol(sym) == true)
{
enterNodeSym(sym, name);
if (sym->type != 0)
{
writeType(sym->type);
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (isTypeSymbol(sym) == true)
{
enterNodeSym(sym, name);
if (sym->type != 0)
{
writeType(sym->type);
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
else if (VarSymbol* var = toVarSymbol(sym))
{
enterNode(sym);
fprintf(mFP, " ");
if (var->immediate == 0)
{
int len = -1;
if (sym->type == 0 && var->depth() < 0)
{
fprintf(mFP, "name: %s", name);
}
else
{
writeLongString("name: ", name);
len = 0 + writeQual(sym->qualType());
len = len + writeType(sym->type);
}
if (compact == false && var->depth() >= 0)
{
if (len > 0 && len < 45)
{
for (int i = len; i < 45; i++)
fputc(' ', stdout);
}
fprintf(mFP, " depth: %2d offset: %4d", var->depth(), var->offset());
}
}
else
{
const size_t bufSize = 128;
char imm[bufSize];
if (var->type == dtBool)
{
if (var->immediate->v_bool == 0)
sprintf(imm, "false");
else
sprintf(imm, "true");
}
else
{
snprint_imm(imm, bufSize, *var->immediate);
if (var->type != 0 && is_imag_type(var->type) == true)
{
char* tail = strchr(imm, '\0');
*tail++ = 'i';
*tail = '\0';
}
}
writeLongString("imm: ", imm);
if (sym->type)
{
writeType(sym->type);
}
}
if (!compact)
writeFlags(mFP, sym);
exitNode(sym);
}
}
void AstDumpToNode::writeSymbolCompact(Symbol* sym) const
{
// ad-hoc suppress "VarSymbol" et al.
fputs(delimitEnter, mFP);
if (!sym)
{
fprintf(mFP, "<NULL>");
}
else if (VarSymbol* var = toVarSymbol(sym))
{
if (Immediate* imm = var->immediate)
{
fprintf(mFP, "imm: ");
fprint_imm(mFP, *imm);
}
else
{
writeNodeID(sym, false, true);
fprintf(mFP, "%s%s", symPrefixString(sym), sym->name);
}
}
else if (ArgSymbol* arg = toArgSymbol(sym))
{
writeNodeID(sym, false, true);
fprintf(mFP, "arg %s", arg->name);
}
else
{
writeNodeID(sym, false, true);
fprintf(mFP, "%s %s", sym->astTagAsString(), sym->name);
}
fputs(delimitExit, mFP);
}
void AstDumpToNode::ast_symbol(const char* tag, Symbol* sym, bool def)
{
fprintf(mFP, "%s ", tag);
ast_symbol(sym, def);
}
void AstDumpToNode::ast_symbol(Symbol* sym, bool def)
{
ModuleSymbol* mod = sym->getModule();
if (def)
{
if (ArgSymbol* arg = toArgSymbol(sym))
{
newline();
switch (arg->intent)
{
case INTENT_IN:
fprintf(mFP, "intent: in");
newline();
break;
case INTENT_INOUT:
fprintf(mFP, "intent: inout");
newline();
break;
case INTENT_OUT:
fprintf(mFP, "intent: out");
newline();
break;
case INTENT_CONST:
fprintf(mFP, "intent: const");
newline();
break;
case INTENT_CONST_IN:
fprintf(mFP, "intent: const in");
newline();
break;
case INTENT_CONST_REF:
fprintf(mFP, "intent: const ref");
newline();
break;
case INTENT_REF:
fprintf(mFP, "intent: ref");
newline();
break;
case INTENT_REF_MAYBE_CONST:
fprintf(mFP, "intent: const? ref");
newline();
break;
case INTENT_PARAM:
fprintf(mFP, "intent: param");
newline();
break;
case INTENT_TYPE:
fprintf(mFP, "intent: type");
newline();
break;
case INTENT_BLANK:
fprintf(mFP, "intent: blank");
newline();
break;
}
}
}
if ((mod == 0 || mod->name == 0) && sym->name == 0)
{
fprintf(mFP, "name: %s.%s", "??", "??");
}
else if ((mod == 0 || mod->name == 0) && sym->name != 0)
{
fprintf(mFP, "name: %s.%s", "??", sym->name);
}
else if (mod->name != 0 && sym->name == 0)
{
fprintf(mFP, "name: %s.%s", mod->name, "??");
}
else if (def == true)
{
fprintf(mFP, "name: %s", sym->name);
}
else
{
fprintf(mFP, "name: %s.%s", mod->name, sym->name);
}
if (sym->type)
{
newline();
fprintf(mFP, "type: ");
writeType(sym->type, false);
}
#if 0
if (sym->hasFlag(FLAG_GENERIC))
write(false, " \"generic\"", false);
#endif
mNeedSpace = true;
}
int AstDumpToNode::writeQual(QualifiedType qual) const
{
const char* name = qualifierToStr(qual.getQual());
if (compact)
fprintf(mFP, " qual: %s", name);
else
fprintf(mFP, "qual: %-16s", name);
return 6 + ((int) strlen(name));
}
int AstDumpToNode::writeType(Type* type, bool announce) const
{
int len = -1;
if (announce)
{
fputs(" type: ", mFP);
len = 7;
}
if (false)
;
else if (type == 0)
;
else if (PrimitiveType* t = toPrimitiveType(type))
{
if (compact)
{
// ad-hoc suppress "PrimitiveType"
fputs(delimitEnter, mFP);
writeNodeID(t, false, true);
fputs(t->symbol->name, mFP);
fputs(delimitExit, mFP);
}
else
{
enterNode(type);
fputc(' ', mFP);
fputs(t->symbol->name, mFP);
exitNode(type);
len = 20 + 12 + 1 + strlen(t->symbol->name) + 1;
}
}
else if (AggregateType* t = toAggregateType(type))
{
const char* tagName = 0;
switch (t->aggregateTag)
{
case AGGREGATE_CLASS:
tagName = "Class";
break;
case AGGREGATE_RECORD:
tagName = "Record";
break;
case AGGREGATE_UNION:
tagName = "Union";
break;
}
enterNode(type);
fprintf(mFP, " %-6s %s", tagName, t->symbol->name);
exitNode(type);
}
else if (EnumType* t = toEnumType(type))
{
enterNode(type);
fprintf(mFP, " %s", t->symbol->name);
exitNode(type);
}
else
USR_FATAL("This cannot happen");
return len;
}
void AstDumpToNode::writeField(const char* msg, int offset, BaseAST* field) {
write(false, msg, false);
if (compact) {
// leave mOffset unchanged
newline();
field->accept(this);
} else {
mOffset = mOffset + offset;
field->accept(this);
mOffset = mOffset - offset;
}
}
void AstDumpToNode::writeField(const char* msg, AList& list) {
if (list.length == 0) return;
newline();
write(false, msg, false);
int offset = strlen(msg);
if (!compact) mOffset = mOffset + offset;
bool need_newline = compact ? true : false;
for_alist(next_ast, list)
{
if (need_newline)
newline();
else
need_newline = true;
next_ast->accept(this);
}
if (!compact) mOffset = mOffset - offset;
if (!compact) newline();
}
void AstDumpToNode::write(const char* text)
{
write(true, text, true);
}
void AstDumpToNode::write(bool spaceBefore, const char* text, bool spaceAfter)
{
if (spaceBefore == true && mNeedSpace == true)
fputc(' ', mFP);
fputs(text, mFP);
mNeedSpace = spaceAfter;
}
void AstDumpToNode::newline() {
fputc('\n', mFP);
for (int i = 0; i < mOffset; ++i)
fputc(' ', mFP);
mNeedSpace = false;
}
| 17.616509 | 81 | 0.548451 | SamuelHoward |
a354219f0d065f57ea7f7863a4a20b49fb141df6 | 435 | cpp | C++ | cuadernillo2/pruebas/correccion/tad01.cpp | alihyderr/PED | a5bc722deb7c84a2f9818c9a56630ce8b7572f7b | [
"MIT"
] | null | null | null | cuadernillo2/pruebas/correccion/tad01.cpp | alihyderr/PED | a5bc722deb7c84a2f9818c9a56630ce8b7572f7b | [
"MIT"
] | null | null | null | cuadernillo2/pruebas/correccion/tad01.cpp | alihyderr/PED | a5bc722deb7c84a2f9818c9a56630ce8b7572f7b | [
"MIT"
] | null | null | null | #include <iostream>
#include "tabbcalendario.h"
using namespace std;
int
main(void)
{
TABBCalendario a;
TCalendario c1(1, 1,2000,(char *)"fecha"), c2(1, 1,2000,(char *)"fecha1"), c3(3, 3,2000,(char *)"fecha");
a.Insertar(c1);
a.Insertar(c2);
a.Insertar(c3);
cout<<"Inorden="<<a.Inorden()<<endl;
cout<<"Preorden="<<a.Preorden()<<endl;
cout<<"Postorden="<<a.Postorden()<<endl;
return 0;
}
| 19.772727 | 108 | 0.593103 | alihyderr |
a355653290e850c080f8f2da55d073e154d152c0 | 934 | cpp | C++ | Array/zhanchengguo/0701-返回倒数第k个节点/main.cpp | JessonYue/LeetCodeLearning | 3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79 | [
"MIT"
] | 39 | 2020-05-31T06:14:39.000Z | 2021-01-09T11:06:39.000Z | Array/zhanchengguo/0701-返回倒数第k个节点/main.cpp | JessonYue/LeetCodeLearning | 3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79 | [
"MIT"
] | 7 | 2020-06-02T11:04:14.000Z | 2020-06-11T14:11:58.000Z | Array/zhanchengguo/0701-返回倒数第k个节点/main.cpp | JessonYue/LeetCodeLearning | 3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79 | [
"MIT"
] | 20 | 2020-05-31T06:21:57.000Z | 2020-10-01T04:48:38.000Z | #include <iostream>
#include "stack"
#include "string"
#include "vector"
using namespace std;
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
int kthToLast(ListNode *head, int k);
int main() {
ListNode *a = new ListNode(1);
ListNode *b = new ListNode(2);
ListNode *c = new ListNode(3);
ListNode *d = new ListNode(4);
a->next = b;
b->next = c;
c->next = d;
d->next = NULL;
int value = kthToLast(a, 2);
printf("value is %d\n", value);
return 0;
}
/**
* 思路：快慢指针来实现，先让快指针移动k次，之后快慢指针同时移动，直到快指针结束，
* 则此时的慢指针为所需的节点位置，因为快慢指针一直保持相距k个节点
* @param head
* @param k
* @return
*/
int kthToLast(ListNode *head, int k) {
ListNode *slow = head;
ListNode *fast = head;
while (k-- > 0) {
fast = fast->next;
}
while (fast != NULL) {
fast = fast->next;
slow = slow->next;
}
return slow->val;
}
| 17.296296 | 43 | 0.571734 | JessonYue |
a35666c1f20c292b7b9b6ac7dd821aab39493f75 | 1,341 | cc | C++ | sketches/sketch_vc.cc | rbuch/vt | 74c2e0cae3201dfbcbfda7644c354703ddaed6bb | [
"BSD-3-Clause"
] | 26 | 2019-11-26T08:36:15.000Z | 2022-02-15T17:13:21.000Z | sketches/sketch_vc.cc | rbuch/vt | 74c2e0cae3201dfbcbfda7644c354703ddaed6bb | [
"BSD-3-Clause"
] | 1,215 | 2019-09-09T14:31:33.000Z | 2022-03-30T20:20:14.000Z | sketches/sketch_vc.cc | rbuch/vt | 74c2e0cae3201dfbcbfda7644c354703ddaed6bb | [
"BSD-3-Clause"
] | 12 | 2019-09-08T00:03:05.000Z | 2022-02-23T21:28:35.000Z |
// runtime code
struct VirtualContext {
using virtual_context_id_t = int64_t;
bool is_migrateable = false;
virtual_context_id_t get_virtual_context_id();
};
struct VirtualContextMessage : vt::Message {
};
// user code
struct MyContext : VirtualContext {
int my_data;
MyContext() = default;
};
struct MyMsg : vt::VirtualContextMessage {
int size, info;
};
MyContext* my_handler(MyMsg* msg) {
return new MyContext(size, info);
}
// work msg for MyContext
struct MyWorkMsg : vt::VirtualContextMessage {
int work_info;
};
void my_work_handler(MyWorkMsg* msg, MyContext* context) {
// do work on context
}
int main(int argc, char** argv) {
CollectiveOps::initialize_context(argc, argv);
CollectiveOps::initialize_runtime();
auto const& my_node = theContext()->getNode();
auto const& num_nodes = theContext()->get_num_nodes();
if (num_nodes == 1) {
CollectiveOps::abort("At least 2 ranks required");
}
if (my_node == 5) {
MyMsg* msg = make_shared_message<MyMsg>(10, 100);
virtual_context_id_t my_id = the_virtual->create_virtual_context<
MyContext, MyMsg, my_handler
>(msg);
MyWorkMsg* msg = make_shared_message<MyWorkMsg>();
the_virtual->sendMsg<MyContext, MyWorkMsg, my_work_handler>(my_id, work_msg);
}
while (1) {
theMsg()->scheduler();
}
return 0;
}
| 20.318182 | 81 | 0.698732 | rbuch |
a356dfb1e80f7228eeb393112e3e6520ead971b0 | 11,659 | hh | C++ | contrib/Delphes-3.1.2/external/fastjet/tools/Pruner.hh | aaronvincent/gambit_aaron | a38bd6fc10d781e71f2adafd401c76e1e3476b05 | [
"Unlicense"
] | 3 | 2018-06-15T09:12:17.000Z | 2021-06-20T15:58:21.000Z | contrib/Delphes-3.1.2/external/fastjet/tools/Pruner.hh | aaronvincent/gambit_aaron | a38bd6fc10d781e71f2adafd401c76e1e3476b05 | [
"Unlicense"
] | 1 | 2016-08-19T23:48:43.000Z | 2016-08-20T01:01:34.000Z | contrib/Delphes-3.1.2/external/fastjet/tools/Pruner.hh | aaronvincent/gambit_aaron | a38bd6fc10d781e71f2adafd401c76e1e3476b05 | [
"Unlicense"
] | 6 | 2016-08-18T23:16:00.000Z | 2020-04-13T01:13:20.000Z | #ifndef __FASTJET_TOOLS_PRUNER_HH__
#define __FASTJET_TOOLS_PRUNER_HH__
//STARTHEADER
// $Id: Pruner.hh 2616 2011-09-30 18:03:40Z salam $
//
// Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
//
//----------------------------------------------------------------------
// This file is part of FastJet.
//
// FastJet is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// The algorithms that underlie FastJet have required considerable
// development and are described in hep-ph/0512210. If you use
// FastJet as part of work towards a scientific publication, please
// include a citation to the FastJet paper.
//
// FastJet is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FastJet. If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------
//ENDHEADER
#include "fastjet/ClusterSequence.hh"
#include "fastjet/WrappedStructure.hh"
#include "fastjet/tools/Transformer.hh"
#include <iostream>
#include <string>
FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
// fwd declarations
class Pruner;
class PrunerStructure;
class PruningRecombiner;
class PruningPlugin;
//----------------------------------------------------------------------
/// @ingroup tools_generic
/// \class Pruner
/// Transformer that prunes a jet
///
/// This transformer prunes a jet according to the ideas presented in
/// arXiv:0903.5081 (S.D. Ellis, C.K. Vermilion and J.R. Walsh).
///
/// The jet's constituents are reclustered with a user-specified jet
/// definition, with the modification that objects i and j are only
/// recombined if at least one of the following two criteria is
/// satisfied:
///
/// - the geometric distance between i and j is smaller than 'Rcut'
/// with Rcut = Rcut_factor*2m/pt (Rcut_factor is a parameter of
/// the Pruner and m and pt obtained from the jet being pruned)
/// - the transverse momenta of i and j are at least 'zcut' p_t(i+j)
///
/// If both these criteria fail, i and j are not recombined, the
/// harder of i and j is kept, and the softer is rejected.
///
/// Usage:
/// \code
/// Pruner pruner(jet_def, zcut, Rcut_factor);
/// PseudoJet pruned_jet = pruner(jet);
/// \endcode
///
/// The pruned_jet has a valid associated cluster sequence. In addition
/// the subjets of the original jet that have been vetoed by pruning
/// (i.e. have been 'pruned away') can be accessed using
///
/// \code
/// vector<PseudoJet> rejected_subjets = pruned_jet.structure_of<Pruner>().rejected();
/// \endcode
///
/// If the re-clustering happens to find more than a single inclusive
/// jet (this should normally not happen if the radius of the jet
/// definition used for the reclustering was set large enough),
/// the hardest of these jets is retured as the result of the
/// Pruner. The other jets can be accessed through
///
/// \code
/// vector<PseudoJet> extra_jets = pruned_jet.structure_of<Pruner>().extra_jets();
/// \endcode
///
/// Instead of using Rcut_factor and zcut, one can alternatively
/// construct a Pruner by passing two (pointers to) functions of
/// PseudoJet that dynamically compute the Rcut and zcut to
/// be used for the jet being pruned.
///
/// When the jet being pruned has area support and explicit ghosts,
/// the resulting pruned jet will likewise have area.
///
//----------------------------------------------------------------------
class Pruner : public Transformer{
public:
/// minimal constructor, which takes a jet algorithm, sets the radius
/// to JetDefinition::max_allowable_R (practically equivalent to
/// infinity) and also tries to use a recombiner based on the one in
/// the jet definition of the particular jet being pruned.
///
/// \param jet_alg the jet algorithm for the internal clustering
/// \param zcut pt-fraction cut in the pruning
/// \param Rcut_factor the angular distance cut in the pruning will be
/// Rcut_factor * 2m/pt
Pruner(const JetAlgorithm jet_alg, double zcut, double Rcut_factor)
: _jet_def(jet_alg, JetDefinition::max_allowable_R),
_zcut(zcut), _Rcut_factor(Rcut_factor),
_zcut_dyn(0), _Rcut_dyn(0), _get_recombiner_from_jet(true) {}
/// alternative ctor in which the full reclustering jet definition can
/// be specified.
///
/// \param jet_def the jet definition for the internal clustering
/// \param zcut pt-fraction cut in the pruning
/// \param Rcut_factor the angular distance cut in the pruning will be
/// Rcut_factor * 2m/pt
Pruner(const JetDefinition &jet_def, double zcut, double Rcut_factor)
: _jet_def(jet_def),
_zcut(zcut), _Rcut_factor(Rcut_factor),
_zcut_dyn(0), _Rcut_dyn(0), _get_recombiner_from_jet(false) {}
/// alternative ctor in which the pt-fraction cut and angular distance
/// cut are functions of the jet being pruned.
///
/// \param jet_def the jet definition for the internal clustering
/// \param zcut_dyn dynamic pt-fraction cut in the pruning
/// \param Rcut_dyn dynamic angular distance cut in the pruning
Pruner(const JetDefinition &jet_def,
FunctionOfPseudoJet<double> *zcut_dyn,
FunctionOfPseudoJet<double> *Rcut_dyn);
/// action on a single jet
virtual PseudoJet result(const PseudoJet &jet) const;
/// description
virtual std::string description() const;
// the type of the associated structure
typedef PrunerStructure StructureType;
private:
/// check if the jet has explicit_ghosts (knowing that there is an
/// area support)
bool _check_explicit_ghosts(const PseudoJet &jet) const;
/// return a pointer to a "common" recombiner if there is one,
/// alternatively a null pointer.
const JetDefinition::Recombiner * _get_common_recombiner(const PseudoJet &jet) const;
JetDefinition _jet_def; ///< the internal jet definition
double _zcut; ///< the pt-fraction cut
double _Rcut_factor; ///< the angular separation cut factor
FunctionOfPseudoJet<double> *_zcut_dyn; ///< dynamic zcut
FunctionOfPseudoJet<double> *_Rcut_dyn; ///< dynamic Rcut
bool _get_recombiner_from_jet; ///< true for minimal constructor,
///< causes recombiner to be set equal
///< to that already used in the jet
///< (if it can be deduced)
};
//----------------------------------------------------------------------
/// @ingroup tools_generic
/// \class PrunerStructure
/// The structure associated with a PseudoJet thas has gone through a
/// Pruner transformer
//----------------------------------------------------------------------
class PrunerStructure : public WrappedStructure{
public:
/// default ctor
/// \param result_jet the jet for which we have to keep the structure
PrunerStructure(const PseudoJet & result_jet)
: WrappedStructure(result_jet.structure_shared_ptr()){}
/// description
virtual std::string description() const{ return "Pruned PseudoJet";}
/// return the constituents that have been rejected
std::vector<PseudoJet> rejected() const{
return validated_cs()->childless_pseudojets();
}
/// return the other jets that may have been found along with the
/// result of the pruning
/// The resulting vector is sorted in pt
std::vector<PseudoJet> extra_jets() const;
protected:
friend class Pruner; ///< to allow setting the internal information
};
//----------------------------------------------------------------------
/// \if internal_doc
/// @ingroup internal
/// \class PruningRecombiner
/// recombines the objects that are not vetoed by pruning
///
/// This recombiner only recombines, using the provided 'recombiner',
/// objects (i and j) that pass at least one of the following two criteria:
///
/// - the geometric distance between i and j is smaller than 'Rcut'
/// - the transverse momenta of i and j are at least 'zcut' p_t(i+j)
///
/// If both these criteria fail, the hardest of i and j is kept and
/// the softest is rejected.
///
/// Note that this in not meant for standalone use [in particular
/// because it could lead to memory issues due to the rejected indices
/// stored internally].
///
/// \endif
class PruningRecombiner : public JetDefinition::Recombiner{
public:
/// ctor
/// \param zcut transverse momentum fraction cut
/// \param Rcut angular separation cut
/// \param recomb pointer to a recombiner to use to cluster pairs
PruningRecombiner(double zcut, double Rcut,
const JetDefinition::Recombiner *recombiner)
: _zcut2(zcut*zcut), _Rcut2(Rcut*Rcut),
_recombiner(recombiner){}
/// perform a recombination taking into account the pruning
/// conditions
virtual void recombine(const PseudoJet &pa,
const PseudoJet &pb,
PseudoJet &pab) const;
/// returns the description of the recombiner
virtual std::string description() const;
/// return the history indices that have been pruned away
const std::vector<unsigned int> & rejected() const{ return _rejected;}
/// clears the list of rejected indices
///
/// If one decides to use this recombiner standalone, one has to
/// call this after each clustering in order for the rejected() vector
/// to remain sensible and not grow to infinite size.
void clear_rejected(){ _rejected.clear();}
private:
double _zcut2; ///< transverse momentum fraction cut (squared)
double _Rcut2; ///< angular separation cut (squared)
const JetDefinition::Recombiner *_recombiner; ///< the underlying recombiner to use
mutable std::vector<unsigned int> _rejected; ///< list of rejected history indices
};
//----------------------------------------------------------------------
/// \if internal_doc
/// @ingroup internal
/// \class PruningPlugin
/// FastJet internal plugin that clusters the particles using the
/// PruningRecombiner.
///
/// See PruningRecombiner for a description of what pruning does.
///
/// Note that this is an internal FastJet class used by the Pruner
/// transformer and it is not meant to be used as a standalone clustering
/// tool.
///
/// \endif
//----------------------------------------------------------------------
class PruningPlugin : public JetDefinition::Plugin{
public:
/// ctor
/// \param jet_def the jet definition to be used for the
/// internal clustering
/// \param zcut transverse momentum fraction cut
/// \param Rcut angular separation cut
PruningPlugin(const JetDefinition &jet_def, double zcut, double Rcut)
: _jet_def(jet_def), _zcut(zcut), _Rcut(Rcut){}
/// the actual clustering work for the plugin
virtual void run_clustering(ClusterSequence &input_cs) const;
/// description of the plugin
virtual std::string description() const;
/// returns the radius
virtual double R() const {return _jet_def.R();}
private:
JetDefinition _jet_def; ///< the internal jet definition
double _zcut; ///< transverse momentum fraction cut
double _Rcut; ///< angular separation cut
};
FASTJET_END_NAMESPACE // defined in fastjet/internal/base.hh
#endif // __FASTJET_TOOLS_PRUNER_HH__
| 38.478548 | 88 | 0.66884 | aaronvincent |
a3574c4857679e9827022e9a53448e73d2f38ce8 | 1,202 | cpp | C++ | src/ioThreads.cpp | Aerijo/languageserver-tools | 6834f3d96a5d73d975ce2714f18bf5a5383ab2e6 | [
"MIT"
] | null | null | null | src/ioThreads.cpp | Aerijo/languageserver-tools | 6834f3d96a5d73d975ce2714f18bf5a5383ab2e6 | [
"MIT"
] | null | null | null | src/ioThreads.cpp | Aerijo/languageserver-tools | 6834f3d96a5d73d975ce2714f18bf5a5383ab2e6 | [
"MIT"
] | null | null | null | #include <iostream>
#include <thread>
#include <string>
#include <rapidjson/document.h>
#include "QueueManager.h"
#include "library.h"
bool isExitNotif (const Document &message) {
return std::strcmp(message["method"].GetString(), "exit") == 0;
}
std::thread launchStdinLoop () {
std::cin.tie(nullptr);
return std::thread([]{
while (true) {
Document message = getMessage();
if (message.HasParseError() || isExitNotif(message)) {
break;
}
QueueManager::pushMessage(message);
}
});
}
void sendMessage (Document &message) {
message.AddMember("jsonrpc", "2.0", message.GetAllocator());
StringBuffer buffer;
Writer<StringBuffer> writer (buffer);
message.Accept(writer);
std::cout
<< "Content-Length: "
<< buffer.GetLength()
<< "\r\n\r\n"
<< buffer.GetString();
std::cout.flush();
}
std::thread launchStdoutLoop () {
return std::thread([]{
auto *queue = QueueManager::getInstance();
while (true) {
Document message = queue->for_stdout.dequeue();
sendMessage(message);
}
});
} | 22.259259 | 67 | 0.569884 | Aerijo |
a35879a76f0cf687abdb13d6200138f47d1b3462 | 1,236 | cc | C++ | common_audio/signal_processing/dot_product_with_scale.cc | Aexyn/webrtc2 | daea5bf2deb843567a792f22ea2047a037e09d78 | [
"DOC",
"BSD-3-Clause"
] | 2 | 2018-01-16T13:29:45.000Z | 2018-08-10T09:15:23.000Z | common_audio/signal_processing/dot_product_with_scale.cc | Aexyn/webrtc2 | daea5bf2deb843567a792f22ea2047a037e09d78 | [
"DOC",
"BSD-3-Clause"
] | 1 | 2017-10-11T23:38:42.000Z | 2017-10-11T23:38:42.000Z | common_audio/signal_processing/dot_product_with_scale.cc | Aexyn/webrtc2 | daea5bf2deb843567a792f22ea2047a037e09d78 | [
"DOC",
"BSD-3-Clause"
] | 1 | 2020-07-29T09:13:46.000Z | 2020-07-29T09:13:46.000Z | /*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "common_audio/signal_processing/dot_product_with_scale.h"
#include "rtc_base/safe_conversions.h"
int32_t WebRtcSpl_DotProductWithScale(const int16_t* vector1,
const int16_t* vector2,
size_t length,
int scaling) {
int64_t sum = 0;
size_t i = 0;
/* Unroll the loop to improve performance. */
for (i = 0; i + 3 < length; i += 4) {
sum += (vector1[i + 0] * vector2[i + 0]) >> scaling;
sum += (vector1[i + 1] * vector2[i + 1]) >> scaling;
sum += (vector1[i + 2] * vector2[i + 2]) >> scaling;
sum += (vector1[i + 3] * vector2[i + 3]) >> scaling;
}
for (; i < length; i++) {
sum += (vector1[i] * vector2[i]) >> scaling;
}
return rtc::saturated_cast<int32_t>(sum);
}
| 35.314286 | 71 | 0.597896 | Aexyn |
a358a7337a069e37e833cb52fb73237674d6d71e | 3,531 | cpp | C++ | level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp | 8tab/compute-runtime | 71bd96ad7184df83c7af04ffa8e0d6678ab26f99 | [
"MIT"
] | null | null | null | level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp | 8tab/compute-runtime | 71bd96ad7184df83c7af04ffa8e0d6678ab26f99 | [
"MIT"
] | null | null | null | level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp | 8tab/compute-runtime | 71bd96ad7184df83c7af04ffa8e0d6678ab26f99 | [
"MIT"
] | null | null | null | /*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "mock_driver_handle.h"
namespace L0 {
namespace ult {
using MockDriverHandle = Mock<L0::ult::DriverHandle>;
using namespace testing;
using ::testing::Invoke;
using ::testing::Return;
Mock<DriverHandle>::Mock() {
EXPECT_CALL(*this, getDevice)
.WillRepeatedly(testing::Invoke(this, &MockDriverHandle::doGetDevice));
EXPECT_CALL(*this, getMemoryManager)
.WillRepeatedly(Invoke(this, &MockDriverHandle::doGetMemoryManager));
EXPECT_CALL(*this, getSvmAllocsManager)
.WillRepeatedly(Invoke(this, &MockDriverHandle::doGetSvmAllocManager));
EXPECT_CALL(*this, allocHostMem)
.WillRepeatedly(Invoke(this, &MockDriverHandle::doAllocHostMem));
EXPECT_CALL(*this, allocDeviceMem)
.WillRepeatedly(Invoke(this, &MockDriverHandle::doAllocDeviceMem));
EXPECT_CALL(*this, freeMem)
.WillRepeatedly(Invoke(this, &MockDriverHandle::doFreeMem));
};
NEO::MemoryManager *Mock<DriverHandle>::doGetMemoryManager() {
return memoryManager;
}
NEO::SVMAllocsManager *Mock<DriverHandle>::doGetSvmAllocManager() {
return svmAllocsManager;
}
ze_result_t Mock<DriverHandle>::doGetDevice(uint32_t *pCount, ze_device_handle_t *phDevices) {
if (*pCount == 0) { // User wants to know number of devices
*pCount = this->num_devices;
return ZE_RESULT_SUCCESS;
}
if (phDevices == nullptr) // User is expected to allocate space
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
phDevices[0] = &this->device;
return ZE_RESULT_SUCCESS;
}
ze_result_t Mock<DriverHandle>::doAllocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment,
void **ptr) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY);
auto allocation = svmAllocsManager->createUnifiedMemoryAllocation(0u, size, unifiedMemoryProperties);
if (allocation == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
*ptr = allocation;
return ZE_RESULT_SUCCESS;
}
ze_result_t Mock<DriverHandle>::doAllocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY);
auto allocation = svmAllocsManager->createUnifiedMemoryAllocation(0u, size, unifiedMemoryProperties);
if (allocation == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
}
*ptr = allocation;
return ZE_RESULT_SUCCESS;
}
ze_result_t Mock<DriverHandle>::doFreeMem(const void *ptr) {
auto allocation = svmAllocsManager->getSVMAlloc(ptr);
if (allocation == nullptr) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
svmAllocsManager->freeSVMAlloc(const_cast<void *>(ptr));
if (svmAllocsManager->getSvmMapOperation(ptr)) {
svmAllocsManager->removeSvmMapOperation(ptr);
}
return ZE_RESULT_SUCCESS;
}
void Mock<DriverHandle>::setupDevices(std::vector<std::unique_ptr<NEO::Device>> neoDevices) {
this->numDevices = static_cast<uint32_t>(neoDevices.size());
for (auto &neoDevice : neoDevices) {
auto device = Device::create(this, neoDevice.release(), std::numeric_limits<uint32_t>::max());
this->devices.push_back(device);
}
}
Mock<DriverHandle>::~Mock(){};
} // namespace ult
} // namespace L0
| 32.694444 | 155 | 0.722741 | 8tab |
a35bd4ae48b4c1e27fcaedf07b7445ae01f0cc20 | 638 | cpp | C++ | Camp_1-2562/05 String/Wordchain.cpp | MasterIceZ/POSN_BUU | 56e176fb843d7ddcee0cf4acf2bb141576c260cf | [
"MIT"
] | null | null | null | Camp_1-2562/05 String/Wordchain.cpp | MasterIceZ/POSN_BUU | 56e176fb843d7ddcee0cf4acf2bb141576c260cf | [
"MIT"
] | null | null | null | Camp_1-2562/05 String/Wordchain.cpp | MasterIceZ/POSN_BUU | 56e176fb843d7ddcee0cf4acf2bb141576c260cf | [
"MIT"
] | null | null | null | #include<stdio.h>
#include<string.h>
char a[1010],b[1010],c[1010];
int main(){
int i,n,j,cnt=0,ch=1,l;
scanf("%d %d",&l,&n);
for(i=0;i<l;i++){
scanf(" %c",&a[i]);
}
if(n==1){
for(j==0;j<l;j++){
printf("%c",a[j]);
}
return 0;
}
for(i=0;i<n-1;i++){
cnt=0;
for(j=0;j<l;j++){
scanf(" %c",&b[j]);
}
for(j=0;j<l;j++){
if(a[j]!=b[j]){
cnt++;
}
}
if(cnt>2&&ch){
for(j=0;j<l;j++){
c[j]=a[j];
ch=0;
}
}
if(ch){
for(j=0;j<l;j++)
c[j]=b[j];
}
strcpy(a,b);
}
for(j=0;j<l;j++){
printf("%c",c[j]);
}
}
/*
4
12
HEAD
HEAP
LEAP
TEAR
REAR
BAER
BAET
BEEP
JEEP
JOIP
JEIP
AEIO
*/
| 10.813559 | 29 | 0.440439 | MasterIceZ |
a35be88feee8472e2e0141fc86b5749bb7eab7f1 | 11,701 | cpp | C++ | external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderDiscardTests.cpp | TinkerBoard-Android/external_deqp | fbf76f4e30a964813b9cdfa0dd36dadc25220939 | [
"Apache-2.0"
] | null | null | null | external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderDiscardTests.cpp | TinkerBoard-Android/external_deqp | fbf76f4e30a964813b9cdfa0dd36dadc25220939 | [
"Apache-2.0"
] | null | null | null | external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderDiscardTests.cpp | TinkerBoard-Android/external_deqp | fbf76f4e30a964813b9cdfa0dd36dadc25220939 | [
"Apache-2.0"
] | 3 | 2017-01-21T00:56:25.000Z | 2020-10-31T12:00:02.000Z | /*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
*
* Copyright (c) 2015 The Khronos Group Inc.
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
* Copyright (c) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Shader discard statement tests.
*//*--------------------------------------------------------------------*/
#include "vktShaderRenderDiscardTests.hpp"
#include "vktShaderRender.hpp"
#include "tcuStringTemplate.hpp"
#include "gluTexture.hpp"
#include <string>
using tcu::StringTemplate;
namespace vkt
{
namespace sr
{
namespace
{
class SamplerUniformSetup : public UniformSetup
{
public:
SamplerUniformSetup (bool useSampler)
: m_useSampler(useSampler)
{}
virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4&) const
{
instance.useUniform(0u, UI_ONE);
instance.useUniform(1u, UI_TWO);
if (m_useSampler)
instance.useSampler2D(2u, 0u); // To the uniform binding location 2 bind the texture 0
}
private:
const bool m_useSampler;
};
class ShaderDiscardCaseInstance : public ShaderRenderCaseInstance
{
public:
ShaderDiscardCaseInstance (Context& context,
bool isVertexCase,
const ShaderEvaluator& evaluator,
const UniformSetup& uniformSetup,
bool usesTexture);
virtual ~ShaderDiscardCaseInstance (void);
};
ShaderDiscardCaseInstance::ShaderDiscardCaseInstance (Context& context,
bool isVertexCase,
const ShaderEvaluator& evaluator,
const UniformSetup& uniformSetup,
bool usesTexture)
: ShaderRenderCaseInstance (context, isVertexCase, evaluator, uniformSetup, DE_NULL)
{
if (usesTexture)
{
de::SharedPtr<TextureBinding> brickTexture(new TextureBinding(m_context.getTestContext().getArchive(),
"vulkan/data/brick.png",
TextureBinding::TYPE_2D,
tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::LINEAR,
tcu::Sampler::LINEAR)));
m_textures.push_back(brickTexture);
}
}
ShaderDiscardCaseInstance::~ShaderDiscardCaseInstance (void)
{
}
class ShaderDiscardCase : public ShaderRenderCase
{
public:
ShaderDiscardCase (tcu::TestContext& testCtx,
const char* name,
const char* description,
const char* shaderSource,
const ShaderEvalFunc evalFunc,
bool usesTexture);
virtual TestInstance* createInstance (Context& context) const
{
DE_ASSERT(m_evaluator != DE_NULL);
DE_ASSERT(m_uniformSetup != DE_NULL);
return new ShaderDiscardCaseInstance(context, m_isVertexCase, *m_evaluator, *m_uniformSetup, m_usesTexture);
}
private:
const bool m_usesTexture;
};
ShaderDiscardCase::ShaderDiscardCase (tcu::TestContext& testCtx,
const char* name,
const char* description,
const char* shaderSource,
const ShaderEvalFunc evalFunc,
bool usesTexture)
: ShaderRenderCase (testCtx, name, description, false, evalFunc, new SamplerUniformSetup(usesTexture), DE_NULL)
, m_usesTexture (usesTexture)
{
m_fragShaderSource = shaderSource;
m_vertShaderSource =
"#version 310 es\n"
"layout(location=0) in highp vec4 a_position;\n"
"layout(location=1) in highp vec4 a_coords;\n"
"layout(location=0) out mediump vec4 v_color;\n"
"layout(location=1) out mediump vec4 v_coords;\n\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_color = vec4(a_coords.xyz, 1.0);\n"
" v_coords = a_coords;\n"
"}\n";
}
enum DiscardMode
{
DISCARDMODE_ALWAYS = 0,
DISCARDMODE_NEVER,
DISCARDMODE_UNIFORM,
DISCARDMODE_DYNAMIC,
DISCARDMODE_TEXTURE,
DISCARDMODE_LAST
};
enum DiscardTemplate
{
DISCARDTEMPLATE_MAIN_BASIC = 0,
DISCARDTEMPLATE_FUNCTION_BASIC,
DISCARDTEMPLATE_MAIN_STATIC_LOOP,
DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP,
DISCARDTEMPLATE_FUNCTION_STATIC_LOOP,
DISCARDTEMPLATE_LAST
};
// Evaluation functions
inline void evalDiscardAlways (ShaderEvalContext& c) { c.discard(); }
inline void evalDiscardNever (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
inline void evalDiscardDynamic (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); if (c.coords.x()+c.coords.y() > 0.0f) c.discard(); }
inline void evalDiscardTexture (ShaderEvalContext& c)
{
c.color.xyz() = c.coords.swizzle(0,1,2);
if (c.texture2D(0, c.coords.swizzle(0,1) * 0.25f + 0.5f).x() < 0.7f)
c.discard();
}
static ShaderEvalFunc getEvalFunc (DiscardMode mode)
{
switch (mode)
{
case DISCARDMODE_ALWAYS: return evalDiscardAlways;
case DISCARDMODE_NEVER: return evalDiscardNever;
case DISCARDMODE_UNIFORM: return evalDiscardAlways;
case DISCARDMODE_DYNAMIC: return evalDiscardDynamic;
case DISCARDMODE_TEXTURE: return evalDiscardTexture;
default:
DE_ASSERT(DE_FALSE);
return evalDiscardAlways;
}
}
static const char* getTemplate (DiscardTemplate variant)
{
#define GLSL_SHADER_TEMPLATE_HEADER \
"#version 310 es\n" \
"layout(location = 0) in mediump vec4 v_color;\n" \
"layout(location = 1) in mediump vec4 v_coords;\n" \
"layout(location = 0) out mediump vec4 o_color;\n" \
"layout(set = 0, binding = 2) uniform sampler2D ut_brick;\n" \
"layout(set = 0, binding = 0) uniform block0 { mediump int ui_one; };\n\n"
switch (variant)
{
case DISCARDTEMPLATE_MAIN_BASIC:
return GLSL_SHADER_TEMPLATE_HEADER
"void main (void)\n"
"{\n"
" o_color = v_color;\n"
" ${DISCARD};\n"
"}\n";
case DISCARDTEMPLATE_FUNCTION_BASIC:
return GLSL_SHADER_TEMPLATE_HEADER
"void myfunc (void)\n"
"{\n"
" ${DISCARD};\n"
"}\n\n"
"void main (void)\n"
"{\n"
" o_color = v_color;\n"
" myfunc();\n"
"}\n";
case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
return GLSL_SHADER_TEMPLATE_HEADER
"void main (void)\n"
"{\n"
" o_color = v_color;\n"
" for (int i = 0; i < 2; i++)\n"
" {\n"
" if (i > 0)\n"
" ${DISCARD};\n"
" }\n"
"}\n";
case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
return GLSL_SHADER_TEMPLATE_HEADER
"layout(set = 0, binding = 1) uniform block1 { mediump int ui_two; };\n\n"
"void main (void)\n"
"{\n"
" o_color = v_color;\n"
" for (int i = 0; i < ui_two; i++)\n"
" {\n"
" if (i > 0)\n"
" ${DISCARD};\n"
" }\n"
"}\n";
case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
return GLSL_SHADER_TEMPLATE_HEADER
"void myfunc (void)\n"
"{\n"
" for (int i = 0; i < 2; i++)\n"
" {\n"
" if (i > 0)\n"
" ${DISCARD};\n"
" }\n"
"}\n\n"
"void main (void)\n"
"{\n"
" o_color = v_color;\n"
" myfunc();\n"
"}\n";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
#undef GLSL_SHADER_TEMPLATE_HEADER
}
static const char* getTemplateName (DiscardTemplate variant)
{
switch (variant)
{
case DISCARDTEMPLATE_MAIN_BASIC: return "basic";
case DISCARDTEMPLATE_FUNCTION_BASIC: return "function";
case DISCARDTEMPLATE_MAIN_STATIC_LOOP: return "static_loop";
case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP: return "dynamic_loop";
case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP: return "function_static_loop";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
}
static const char* getModeName (DiscardMode mode)
{
switch (mode)
{
case DISCARDMODE_ALWAYS: return "always";
case DISCARDMODE_NEVER: return "never";
case DISCARDMODE_UNIFORM: return "uniform";
case DISCARDMODE_DYNAMIC: return "dynamic";
case DISCARDMODE_TEXTURE: return "texture";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
}
static const char* getTemplateDesc (DiscardTemplate variant)
{
switch (variant)
{
case DISCARDTEMPLATE_MAIN_BASIC: return "main";
case DISCARDTEMPLATE_FUNCTION_BASIC: return "function";
case DISCARDTEMPLATE_MAIN_STATIC_LOOP: return "static loop";
case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP: return "dynamic loop";
case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP: return "static loop in function";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
}
static const char* getModeDesc (DiscardMode mode)
{
switch (mode)
{
case DISCARDMODE_ALWAYS: return "Always discard";
case DISCARDMODE_NEVER: return "Never discard";
case DISCARDMODE_UNIFORM: return "Discard based on uniform value";
case DISCARDMODE_DYNAMIC: return "Discard based on varying values";
case DISCARDMODE_TEXTURE: return "Discard based on texture value";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
}
de::MovePtr<ShaderDiscardCase> makeDiscardCase (tcu::TestContext& testCtx, DiscardTemplate tmpl, DiscardMode mode)
{
StringTemplate shaderTemplate(getTemplate(tmpl));
std::map<std::string, std::string> params;
switch (mode)
{
case DISCARDMODE_ALWAYS: params["DISCARD"] = "discard"; break;
case DISCARDMODE_NEVER: params["DISCARD"] = "if (false) discard"; break;
case DISCARDMODE_UNIFORM: params["DISCARD"] = "if (ui_one > 0) discard"; break;
case DISCARDMODE_DYNAMIC: params["DISCARD"] = "if (v_coords.x+v_coords.y > 0.0) discard"; break;
case DISCARDMODE_TEXTURE: params["DISCARD"] = "if (texture(ut_brick, v_coords.xy*0.25+0.5).x < 0.7) discard"; break;
default:
DE_ASSERT(DE_FALSE);
break;
}
std::string name = std::string(getTemplateName(tmpl)) + "_" + getModeName(mode);
std::string description = std::string(getModeDesc(mode)) + " in " + getTemplateDesc(tmpl);
return de::MovePtr<ShaderDiscardCase>(new ShaderDiscardCase(testCtx, name.c_str(), description.c_str(), shaderTemplate.specialize(params).c_str(), getEvalFunc(mode), mode == DISCARDMODE_TEXTURE));
}
class ShaderDiscardTests : public tcu::TestCaseGroup
{
public:
ShaderDiscardTests (tcu::TestContext& textCtx);
virtual ~ShaderDiscardTests (void);
virtual void init (void);
private:
ShaderDiscardTests (const ShaderDiscardTests&); // not allowed!
ShaderDiscardTests& operator= (const ShaderDiscardTests&); // not allowed!
};
ShaderDiscardTests::ShaderDiscardTests (tcu::TestContext& testCtx)
: TestCaseGroup(testCtx, "discard", "Discard statement tests")
{
}
ShaderDiscardTests::~ShaderDiscardTests (void)
{
}
void ShaderDiscardTests::init (void)
{
for (int tmpl = 0; tmpl < DISCARDTEMPLATE_LAST; tmpl++)
for (int mode = 0; mode < DISCARDMODE_LAST; mode++)
addChild(makeDiscardCase(m_testCtx, (DiscardTemplate)tmpl, (DiscardMode)mode).release());
}
} // anonymous
tcu::TestCaseGroup* createDiscardTests (tcu::TestContext& testCtx)
{
return new ShaderDiscardTests(testCtx);
}
} // sr
} // vkt
| 29.622785 | 197 | 0.660884 | TinkerBoard-Android |
a35c2d00644ae9955391a748cd5afdd8d7e74129 | 892 | cpp | C++ | Sources/Common/Vertex.cpp | CubbyFlow/RenderFlow | c38686917ab526463430b05de78fafb85a35bd20 | [
"MIT"
] | 3 | 2021-07-07T13:39:01.000Z | 2022-03-11T02:40:49.000Z | Sources/Common/Vertex.cpp | CubbyFlow/RenderFlow | c38686917ab526463430b05de78fafb85a35bd20 | [
"MIT"
] | 7 | 2021-07-08T02:50:03.000Z | 2021-07-24T09:12:11.000Z | Sources/Common/Vertex.cpp | CubbyFlow/RenderFlow | c38686917ab526463430b05de78fafb85a35bd20 | [
"MIT"
] | 1 | 2021-07-21T20:30:21.000Z | 2021-07-21T20:30:21.000Z | #include <Common/Vertex.hpp>
namespace Common
{
std::size_t VertexHelper::GetNumberOfFloats(VertexFormat format)
{
std::size_t size = 0;
if (static_cast<bool>(format & VertexFormat::Position3))
{
size += 3;
}
if (static_cast<bool>(format & VertexFormat::Normal3))
{
size += 3;
}
if (static_cast<bool>(format & VertexFormat::TexCoord2))
{
size += 2;
}
if (static_cast<bool>(format & VertexFormat::TexCoord3))
{
size += 3;
}
if (static_cast<bool>(format & VertexFormat::Color4))
{
size += 4;
}
if (static_cast<bool>(format & VertexFormat::Tangent4))
{
size += 4;
}
return size;
}
std::size_t VertexHelper::GetSizeInBytes(VertexFormat format)
{
return sizeof(float) * GetNumberOfFloats(format);
}
} // namespace Common | 21.756098 | 65 | 0.575112 | CubbyFlow |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.